Changeset 8490 in orxonox.OLD for trunk/src/lib/graphics

Timestamp:

Jun 15, 2006, 9:34:48 PM (19 years ago)

Author:

patrick

Message:

merged the bsp branche back to trunk

Location:

trunk/src/lib/graphics

Files:

• graphics_engine.cc (modified) (2 diffs)
• graphics_engine.h (modified) (2 diffs)
• importer/Makefile.am (modified) (6 diffs)
• importer/bsp_file.cc (modified) (16 diffs)
• importer/bsp_file.h (modified) (2 diffs)
• importer/bsp_manager.cc (modified) (22 diffs)
• importer/bsp_manager.h (modified) (5 diffs)
• importer/interactive_model.cc (copied) (copied from branches/bsp_model/src/lib/graphics/importer/interactive_model.cc)
• importer/interactive_model.h (copied) (copied from branches/bsp_model/src/lib/graphics/importer/interactive_model.h)
• importer/md2 (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md2)
• importer/md2/md2Model.cc (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md2/md2Model.cc)
• importer/md2/md2Model.h (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md2/md2Model.h)
• importer/md2Model.cc (deleted)
• importer/md2Model.h (deleted)
• importer/md3 (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3)
• importer/md3/md3_animation.cc (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_animation.cc)
• importer/md3/md3_animation.h (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_animation.h)
• importer/md3/md3_bone_frame.cc (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_bone_frame.cc)
• importer/md3/md3_bone_frame.h (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_bone_frame.h)
• importer/md3/md3_data.cc (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_data.cc) (1 diff)
• importer/md3/md3_data.h (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_data.h)
• importer/md3/md3_mesh.cc (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_mesh.cc)
• importer/md3/md3_mesh.h (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_mesh.h)
• importer/md3/md3_model.cc (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_model.cc)
• importer/md3/md3_model.h (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_model.h)
• importer/md3/md3_tag.cc (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_tag.cc)
• importer/md3/md3_tag.h (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md3/md3_tag.h)
• importer/md_model_structure.cc (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md_model_structure.cc)
• importer/md_model_structure.h (copied) (copied from branches/bsp_model/src/lib/graphics/importer/md_model_structure.h)

trunk/src/lib/graphics/graphics_engine.cc

@@ -66 +66 @@
 
   this->bDisplayFPS = false;
+  this->bAntialiasing = false;
   this->minFPS = 9999;
   this->maxFPS = 0;
@@ -283 +284 @@
   SDL_GL_SetAttribute( SDL_GL_ACCUM_ALPHA_SIZE, 0);
 
-  SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);      //Use at least 5 bits of Red
-  SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);    //Use at least 5 bits of Green
-  SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);     //Use at least 5 bits of Blue
-  SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);   //Use at least 16 bits for the depth buffer
+  SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);      //Use at least 5 bits of Red
+  SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);    //Use at least 5 bits of Green
+  SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);     //Use at least 5 bits of Blue
+  SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);   //Use at least 16 bits for the depth buffer
   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);  //Enable double buffering
+
+  // enable antialiasing?
+  if( this->bAntialiasing)
+  {
+    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES,4);
+    SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS,1);
+  }
 
   glEnable(GL_CULL_FACE);

trunk/src/lib/graphics/graphics_engine.h

@@ -46 +46 @@
     static void setBackgroundColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha = 1.0);
 
+    inline void setAntialiasing(bool flag) { this->bAntialiasing = flag; }
+    inline bool getAntialiasing() { return this->bAntialiasing; }
 
     /** @returns the x resolution */
@@ -109 +111 @@
     bool                       shadowsEnabled;     //!< If Shadows should be enabled.
     bool                       particlesEnabled;   //!< If particles should be enabled.
+    bool                       bAntialiasing;      //!< true if antialiasing enabled
+
     int                        particlesValue;     //!< How many particles
     int                        textureQuality;     //!< the quality of Textures

trunk/src/lib/graphics/importer/Makefile.am

@@ -5 +5 @@
 
 libORXimporter_a_SOURCES = model.cc \
+                           interactive_model.cc \
+                           md_model_structure.cc \
                            vertex_array_model.cc \
                            grid.cc \
@@ -10 +12 @@
                            objModel.cc \
                            primitive_model.cc \
-                           md2Model.cc \
                            height_map.cc \
                            bsp_manager.cc \
@@ -22 +23 @@
                            texture_sequence.cc \
                            media_container.cc \
-                           movie_player.cc
+                           movie_player.cc \
+                           \
+                           bsp_manager.cc \
+                           bsp_file.cc \
+                           bsp_tree_node.cc \
+                           bsp_tree_leaf.cc \
+                           \
+                           md2/md2Model.cc \
+                           \
+                           md3/md3_model.cc \
+                           md3/md3_animation.cc \
+                           md3/md3_bone_frame.cc \
+                           md3/md3_mesh.cc \
+                           md3/md3_data.cc \
+                           md3/md3_tag.cc
 
 
@@ -32 +47 @@
 noinst_HEADERS = \
                 model.h \
+                interactive_model.h \
+                md_model_structure.cc \
                 tc.h \
                 vertex_array_model.h \
@@ -38 +55 @@
                 objModel.h \
                 primitive_model.h \
-                md2Model.h \
                 anorms.h \
                 anormtab.h \
@@ -54 +70 @@
                 bsp_file.h \
                 bsp_tree_node.h \
-                bsp_tree_leaf.h
+                bsp_tree_leaf.h \
+                \
+                md2/md2Model.h \
+                \
+                md3/md3_model.h \
+                md3/md3_animation.h \
+                md3/md3_bone_frame.h \
+                md3/md3_mesh.h \
+                md3/md3_data.h \
+                md3/md3_tag.h
+

trunk/src/lib/graphics/importer/bsp_file.cc

@@ -37 +37 @@
 #include <SDL/SDL_image.h>
 
+// STL Containers
+#include <vector>
+
 using namespace std;
 
@@ -50 +53 @@
 int BspFile::read(const char* name)
 {
-  //this->scale = 0.4;
+  this->scale = 1.0;
   int offset;
   int size;
@@ -211 +214 @@
     bspFile.read(this->visData, size);
 
-    PRINTF(4)("BSP FILE: VisDataSize: %i Bytes. \n", size);
-    PRINTF(4)("BSP FILE: NumVisData: %i. \n", size /1 - 8);
-    PRINTF(4)("BSP FILE: Remainder: %i. \n", size % 1);
-    PRINTF(4)("BSP FILE: VisDataOffset: %i. \n", offset);
+    PRINTF(0)("BSP FILE: VisDataSize: %i Bytes. \n", size);
+    PRINTF(0)("BSP FILE: NumVisData: %i. \n", size /1 - 8);
+    PRINTF(0)("BSP FILE: Remainder: %i. \n", size % 1);
+    PRINTF(0)("BSP FILE: VisDataOffset: %i. \n", offset);
 
     // Get the Textures
@@ -388 +391 @@
 {
   ::std::string absFileName;
-  char fileName [228];
-  char ext [100];
+  char* baseName = "/worlds/bsp/";
+
+  char fileName [500];
+  char ext [500];
   struct stat results;
 
@@ -401 +406 @@
     if(strlen(fileName) == 0)
     {
+
      //         Default Material
-      this->Materials[i].mat = new Material();
+    this->Materials[i].mat = new Material();
     this->Materials[i].mat->setDiffuse(0.1,0.1,1.0);
     this->Materials[i].mat->setAmbient(0.1,0.1,1.0 );
@@ -417 +423 @@
 
       // Check for mov
-    strcpy(fileName, &this->textures[8+ 72*i]);
+    strcpy(fileName, baseName);
+    strcpy(ext, &this->textures[8+ 72*i]);
+    strncat(fileName, ext, strlen(fileName) + strlen(&this->textures[8+ 72*i]) );
     strcpy(ext, ".mov");
-    strncat (fileName, ext, strlen(fileName));
+    strncat (fileName, ext, strlen(fileName) );
+
+    PRINTF(0)("BSP FILE: Name %s . \n", fileName);
 
     absFileName = ResourceManager::getFullName(fileName);
@@ -430 +440 @@
 
     // Check for avi
-    strcpy(fileName, &this->textures[8+ 72*i]);
+    strcpy(fileName, baseName);
+    strcpy(ext, &this->textures[8+ 72*i]);
+    strncat(fileName, ext, strlen(fileName) + strlen(&this->textures[8+ 72*i]) );
     strcpy(ext, ".avi");
     strncat (fileName, ext, strlen(fileName));
@@ -443 +455 @@
 
        // Check for mpg
-    strcpy(fileName, &this->textures[8+ 72*i]);
+    strcpy(fileName, baseName);
+    strcpy(ext, &this->textures[8+ 72*i]);
+    strncat(fileName, ext, strlen(fileName) + strlen(&this->textures[8+ 72*i]) );
     strcpy(ext, ".mpg");
     strncat (fileName, ext, strlen(fileName));
@@ -456 +470 @@
 
     // Check for tga
-    strcpy(fileName, &this->textures[8+ 72*i]);
+    strcpy(fileName, baseName);
+    strcpy(ext, &this->textures[8+ 72*i]);
+    strncat(fileName, ext, strlen(fileName) + strlen(&this->textures[8+ 72*i]) );
     strcpy(ext, ".tga");
     strncat (fileName, ext, strlen(fileName));
@@ -468 +484 @@
     }
     // Check for TGA
-    strcpy(fileName, &this->textures[8+ 72*i]);
+    strcpy(fileName, baseName);
+    strcpy(ext, &this->textures[8+ 72*i]);
+    strncat(fileName, ext, strlen(fileName) + strlen(&this->textures[8+ 72*i]) );
     strcpy(ext, ".TGA");
     strncat (fileName, ext, strlen(fileName));
@@ -479 +497 @@
     }
     // Check for jpg
-    strcpy(fileName, &this->textures[8+ 72*i]);
+    strcpy(fileName, baseName);
+    strcpy(ext, &this->textures[8+ 72*i]);
+    strncat(fileName, ext, strlen(fileName) + strlen(&this->textures[8+ 72*i]) );
     strcpy(ext, ".jpg");
     strncat (fileName, ext, strlen(fileName));
@@ -491 +511 @@
 
     // Check for JPG
-    strcpy(fileName, &this->textures[8+ 72*i]);
+    strcpy(fileName, baseName);
+    strcpy(ext, &this->textures[8+ 72*i]);
+    strncat(fileName, ext, strlen(fileName) + strlen(&this->textures[8+ 72*i]) );
     strcpy(ext, ".JPG");
     strncat (fileName, ext, strlen(fileName));
@@ -504 +526 @@
 
     // Check for bmp
-    strcpy(fileName, &this->textures[8+ 72*i]);
+    strcpy(fileName, baseName);
+    strcpy(ext, &this->textures[8+ 72*i]);
+    strncat(fileName, ext, strlen(fileName) + strlen(&this->textures[8+ 72*i]) );
     strcpy(ext, ".bmp");
     strncat (fileName, ext, strlen(fileName));
@@ -516 +540 @@
 
     // Check for BMP
-    strcpy(fileName, &this->textures[8+ 72*i]);
+    strcpy(fileName, baseName);
+    strcpy(ext, &this->textures[8+ 72*i]);
+    strncat(fileName, ext, strlen(fileName) + strlen(&this->textures[8+ 72*i]) );
     strcpy(ext, ".BMP");
     strncat (fileName, ext, strlen(fileName));
@@ -577 +603 @@
   MoviePlayer * testMC = new MoviePlayer(mat);
   testMC->start(0);
+  
+  this->MovieMaterials.push_back(testMC);
 
   //Material* tmp = new Material();
@@ -605 +633 @@
   sc =  ((unsigned char *)(&lightMapTexture))[i];
   sc *= 1/255.0;
-  scale = 2.0;
+
+  scale = 1.0f; // Adjust brightness here
+
   if(sc > 1.0f && (temp = (1.0f/sc)) < scale) scale=temp;
   scale*=255.0;

trunk/src/lib/graphics/importer/bsp_file.h

@@ -18 +18 @@
 */
 
+#include <vector>
 class SDL_Surface;
 class BspTreeNode;
@@ -212 +213 @@
 
  
-
+  ::std::vector<MoviePlayer* > MovieMaterials; //!< Movieplayer Materials
 };
 

trunk/src/lib/graphics/importer/bsp_manager.cc

@@ -39 +39 @@
 #include "movie_player.h"
 
-#include "cd_engine.h"
-
 #include "world_entity.h"
 
@@ -47 +45 @@
 
 
+
 //CREATE_FACTORY( BspManager, CL_BSP_MODEL);
 
-BspManager::BspManager()
-{
+BspManager::BspManager(WorldEntity* parent)
+{
+ 
+  this->parent = parent;
   /*// open a BSP file
   this->bspFile = new BspFile();
@@ -59 +60 @@
   this->alreadyVisible = new bool [this->bspFile->numFaces];
   */
-  CDEngine::getInstance()->setBSPModel(this);
+
 }
 
@@ -76 +77 @@
 void BspManager::load(const char* fileName, float scale)
 {
-  //this->setClassID(CL_BSP_MODEL, "BspManager");
-    // open a BSP file
+  // open a BSP file
   this->bspFile = new BspFile();
   this->bspFile->scale =  scale;
@@ -85 +85 @@
   this->alreadyVisible = new bool [this->bspFile->numFaces];
 
-
+  this->outputFraction = 1.0f;
 }
 /*
@@ -102 +102 @@
 */
 
+const void BspManager::tick(float time)
+{
+
+  if(!this->bspFile->MovieMaterials.empty())
+  {
+      ::std::vector<MoviePlayer *>::iterator it = this->bspFile->MovieMaterials.begin() ;
+      while(it != this->bspFile->MovieMaterials.end())
+      {
+         (*it)->tick(time);
+        it++;
+      }
+ //this->bspFile->MovieMaterials.front()->tick(time );
+
+
+  }
+
+}
 const void BspManager::draw()
 {
@@ -109 +126 @@
   this->out1 = this->out;
   this->out2 = this->out;
-  if(this->collPlane != NULL)
-  {
-  this->out1.x += this->collPlane->x*5.0;
-  this->out1.y += this->collPlane->y*5.0;
-  this->out1.z += this->collPlane->z*5.0;
-
-  this->out2.x += this->collPlane->x*10.0;
-  this->out2.y += this->collPlane->y*10.0;
-  this->out2.z += this->collPlane->z*10.0;
+  if(this->collPlane != NULL) {
+    this->out1.x += this->collPlane->x*5.0;
+    this->out1.y += this->collPlane->y*5.0;
+    this->out1.z += this->collPlane->z*5.0;
+
+    this->out2.x += this->collPlane->x*10.0;
+    this->out2.y += this->collPlane->y*10.0;
+    this->out2.z += this->collPlane->z*10.0;
   }
   this->drawDebugCube(&this->out1);
   this->drawDebugCube(&this->out2);
+
   */
+
+
   // Draw Debug Terrain
   /*
@@ -148 +167 @@
 
 
-  // this->viewDir=    State::getCameraTarget()->getAbsCoor() -  State::getCamera()->getAbsCoor() ;
+  this->viewDir=    State::getCamera()->getAbsDirX();
   float d = (cam.x*viewDir.x + cam.y*viewDir.y + cam.z * viewDir.z);
 
@@ -157 +176 @@
 
 
-  this->cam = State::getCameraTargetNode()->getAbsCoor();
-  // this->checkCollision(this->root, &this->cam);   //!< Test Collision Detection
+
+ // this->checkCollision(this->root, &this->cam);   //!< Test Collision Detection
+
+
   this->outputStartsOut = true;
   this->outputAllSolid = false;
   this->outputFraction = 1.0f;
 
-  this->checkCollisionRay(this->root,0.0f,1.0f, &(State::getCameraTargetNode()->getLastAbsCoor()), &this->cam);
-
-  //if(this->outputFraction != 1.0f || this->outputAllSolid ) this->drawDebugCube(&this->cam);
-
   if ( viscluster < 0  || ((int *)(this->bspFile->header))[35] == 0 )  //!< if (sizeof(Visdata) == 0)
   {
@@ -172 +189 @@
 
 
-    // Iterate through all Leafspublic final double readLEDouble()
+    // Iterate through all Leafs
     for(int i = 0; i <  this->bspFile->numLeafs   ; i++ )
     {
@@ -179 +196 @@
       if(curLeaf.cluster<0) continue;
 
-
       /** Do Frustum culling and draw 'em all **/
-      bool inFrustum = true;
-
-      Vector dir;
-      dir.x = State::getCameraNode()->getAbsDirX().x;
-      dir.y =  State::getCameraNode()->getAbsDirX().y;
-      dir.z =  State::getCameraNode()->getAbsDirX().z;
+
+      Vector dir = State::getCameraNode()->getAbsDirX();
+
       float dist =  dir.x*this->cam.x +dir.y*this->cam.y +dir.z*this->cam.z;
       //if(dist < 0) dist = -dist;
@@ -192 +205 @@
       const float dMaxs = dir.x*(float)curLeaf.maxs[0] +dir.y*(float)curLeaf.maxs[1] +dir.z*(float)curLeaf.maxs[2] - dist ;
 
-      if(dMins < -150.0 && dMaxs < -150.0) {
+      if(dMins < -300.0 && dMaxs < -300.0) {
         continue;
       }
-      if( (this->cam - Vector(curLeaf.mins[0],curLeaf.mins[1], curLeaf.mins[2])).len() > 3000  && (this->cam - Vector(curLeaf.maxs[0],curLeaf.maxs[1], curLeaf.maxs[2])).len() > 3000) {
+      if( (this->cam - Vector(curLeaf.mins[0],curLeaf.mins[1], curLeaf.mins[2])).len() > 2000  && (this->cam - Vector(curLeaf.maxs[0],curLeaf.maxs[1], curLeaf.maxs[2])).len() > 2000) {
         continue;
       }
@@ -206 +219 @@
         if (f >=0 && !this->isAlreadyVisible(f)) {
           this->alreadyVisible[f] = true;
-
           addFace(f); // "visibleFaces.append(f)"
         }
@@ -302 +314 @@
     return;
   }
-  if(curFace.type != 1) return;
+ // if(curFace.type != 1) return;
   if((char*)(this->bspFile->textures)[curFace.texture*72]== 0) return;
 
   if(this->lastTex != curFace.texture) {
     if(this->bspFile->Materials[curFace.texture].animated) {
-      glBlendFunc(GL_ONE,GL_ONE_MINUS_SRC_COLOR);
-      glEnable(GL_BLEND);
+     // glBlendFunc(GL_ZERO,GL_ONE);
+
+
+
       if(this->bspFile->Materials[curFace.texture].aviMat->getStatus() == 2) this->bspFile->Materials[curFace.texture].aviMat->start(0);
-      this->bspFile->Materials[curFace.texture].aviMat->tick(0.005);
+      //this->bspFile->Materials[curFace.texture].aviMat->tick(0.005);
       int n =  this->bspFile->Materials[curFace.texture].aviMat->getTexture();
       glActiveTextureARB(GL_TEXTURE0_ARB);
       glBindTexture(GL_TEXTURE_2D, n );
-      glDisable(GL_BLEND);
+      this->lastTex = curFace.texture;
+
     } else {
       this->bspFile->Materials[curFace.texture].mat->select();
@@ -322 +337 @@
 
   if(curFace.lm_index < 0) {
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     glActiveTextureARB(GL_TEXTURE1_ARB);
     glBindTexture(GL_TEXTURE_2D, this->bspFile->whiteLightMap );
     glEnable(GL_TEXTURE_2D);
   } else {
+   // glEnable(GL_BLEND);
+    //glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     glActiveTextureARB(GL_TEXTURE1_ARB);
     glBindTexture(GL_TEXTURE_2D, this->bspFile->glLightMapTextures[curFace.lm_index]);
     glEnable(GL_TEXTURE_2D);
+  //  glDisable(GL_BLEND);
   }
 
@@ -573 +593 @@
   float startFraction = -1.0f;
   float endFraction = 1.0f;
-  bool startsOut = false;
-  bool endsOut = false;
-
-  Vector inputStart = State::getCameraTargetNode()->getLastAbsCoor();
-  Vector inputEnd   = State::getCameraTargetNode()->getAbsCoor();
+  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;
+
+    } else {   // line is leaving the brush
+      float fraction = (startDistance + EPSILON) / (startDistance - endDistance);  // *
+      if (fraction < endFraction)
+        endFraction = fraction;
+      // 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, Vector& inputStart, Vector& inputEnd)
+{
+  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++) {
@@ -736 +825 @@
 
   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) {
+
+  float endDistance = end->dot(node->plane) - node->d;
+  float startDistance = start->dot(node->plane) - node->d;
+
+
+  if( node->isLeaf) {
     leaf& curLeaf = this->bspFile->leaves[node->leafIndex];
     for (int i = 0; i <  curLeaf.n_leafbrushes ; i++) {
@@ -793 +883 @@
 
     // 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);
+    middleFraction = startFraction + (endFraction - startFraction) * fraction1;
+    middle = (*start) + ((*end) - (*start)) * fraction1;
+
 
     // STEP 4: check the first side
@@ -805 +892 @@
 
     else this->checkCollisionRayN(node->right,startFraction, middleFraction,
-                                 start, &middle );
+                                    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);
+    middleFraction = startFraction + (endFraction - startFraction) * fraction2;
+    middle = (*start) + ((*end) - (*start)) * fraction2;
 
     // STEP 6: check the second side
@@ -824 +907 @@
 
 }
+void BspManager::checkCollisionBox(void)
+{
+
+};
+
+void BspManager::TraceBox( Vector& inputStart, Vector& inputEnd,
+               Vector& inputMins, Vector& inputMaxs )
+{
+  if (inputMins.x == 0 && inputMins.y == 0 && inputMins.z == 0 &&
+      inputMaxs.x == 0 && inputMaxs.y == 0 && inputMaxs.z == 0)
+  {   // the user called TraceBox, but this is actually a ray
+   //!> FIXME TraceRay( inputStart, inputEnd );
+  }
+  else
+  {   // setup for a box
+    //traceType = TT_BOX;
+    this->traceMins = inputMins;
+    this->traceMaxs = inputMaxs;
+    this->traceExtents.x = -traceMins.x > traceMaxs.x ?
+        -traceMins.x : traceMaxs.x;
+    this->traceExtents.y = -traceMins.y > traceMaxs.y ?
+        -traceMins.y : traceMaxs.y;
+    this->traceExtents.z = -traceMins.z > traceMaxs.z ?
+        -traceMins.z : traceMaxs.z;
+   //!> FIXME Trace( inputStart, inputEnd );
+  }
+}
 
 void BspManager::checkCollision(WorldEntity* worldEntity)
 {
-  return;
-
+  
+  this->outputStartsOut = true;
+  this->outputAllSolid = false;
+  this->outputFraction = 1.0f;
+  
   Vector position = worldEntity->getAbsCoor();
 
 
   Vector forwardDir = worldEntity->getAbsDirX();
-  forwardDir.x =2.0*forwardDir.x;
-  forwardDir.y =2.0*forwardDir.y;
-  forwardDir.z =2.0*forwardDir.z;
+  forwardDir = forwardDir * 8.0f;
 
   Vector upDir = worldEntity->getAbsDirY();
-  Vector dest = position;
+  upDir.x = 0.0;
+  upDir.y = 1.0;
+  upDir.z = 0.0;
+  Vector dest;
+  /*
   dest.x  += forwardDir.x;
   dest.y  += forwardDir.y;
   dest.z  += forwardDir.z;
-  Vector out = Vector(-1875.0,-1875.0,-1875.0);
-  if(!worldEntity->isA(CL_PLAYABLE)) {
-
-
-
-
+  */
+
+  dest = worldEntity->getAbsCoor() - upDir*40.0;
+  Vector out = dest;
+
+
+
+
+  bool collision = false;
+  Vector position1 = position + Vector(0.0,0.1,0.0);
+  Vector position2 = position + Vector(0.0,0.2,0.0);
+  Vector dest1 = position1 + forwardDir;
+  Vector dest2 = position2 + forwardDir;
+  dest = position - Vector(0.0, 40.0,0.0);
+  Vector out1;
+  Vector out2;
+
+
+  float height = 40;
+  
+  this->inputStart =  position;
+  this->inputEnd =   dest;
+  this->checkCollisionRayN(this->root,0.0f,1.0f, &position, &dest );
+
+  PRINTF(0)(" checking collision: %s, solid = %i, fraction = %f\n", worldEntity->getClassName(), this->outputAllSolid, this->outputFraction);
+  PRINTF(0)("checking collision!! Pos.Coords: %f , %f , %f\n", position.x , position.y, position.z);
+  PRINTF(0)("checking collision!! Dest.Coords: %f , %f , %f\n", dest.x , dest.y, dest.z);  
+//   position1.debug();
+
+  if( this->outputFraction == 1.0f)
+  {
+    if(this->outputAllSolid)
+    {
+      this->collPlane = new plane;
+      this->collPlane->x = 1.0f;
+      this->collPlane->y = 0.0f;
+      this->collPlane->z = 0.0f;
+      collision = true;
+    }
+    else
+      collision = false;
+
+
+    out = dest;
   }
   else {
-    bool collision = false;
-    Vector position1 = position + Vector(0.0,0.1,0.0);
-    Vector position2 = position + Vector(0.0,0.2,0.0);
-    Vector dest1 = position1 + forwardDir;
-    Vector dest2 = position2 + forwardDir;
-    dest = position - upDir;
-    Vector out1;
-    Vector out2;
-
-    this->checkCollisionRayN(this->root,0.0f,1.0f, &position1, &dest1 );
-    if(this->outputFraction == 1.0f)  out1 = dest;
-    else {
-      collision = true;
-      out1.x = position1.x + (dest1.x -position1.x) * this->outputFraction;
-      out1.y = position1.y + (dest1.y -position1.y) * this->outputFraction;
-      out1.z = position1.z + (dest1.z - position1.z) * this->outputFraction;
-
-    }
-
-    this->checkCollisionRayN(this->root,0.0f,1.0f, &position2, &dest2 );
-    if(this->outputFraction == 1.0f) out2= dest;
-    else
-    {
-      collision = true;
-    out2.x = position2.x + (dest2.x -position2.x) * this->outputFraction;
-    out2.y = position2.y + (dest2.y -position2.y) * this->outputFraction;
-    out2.z = position2.z + (dest2.z - position2.z) * this->outputFraction;
-
-    }
-
-    this->checkCollisionRayN(this->root,0.0f,1.0f, &position, &dest );
-    if(this->outputFraction == 1.0f) out = dest;
-    else
-    {
+
     collision = true;
     out.x = position.x + (dest.x -position.x) * this->outputFraction;
@@ -889 +1009 @@
     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;
-    //this->drawDebugCube(&out1);
-    //this->drawDebugCube(&out2);
-
-    //this->drawDebugCube(&out3);
-
-    }
-
-    // Return the normal here: Normal's stored in this->collPlane;
-//    if(collision) worldEntity->collidesWithGround(out,out1,out2);
-
-  }
-
-}
+    Vector out3 = out + Vector(height*this->collPlane->x,height*this->collPlane->y,height*this->collPlane->z);
+    this->out = out;
+  }
+
+  // Return the normal here: Normal's stored in this->collPlane;
+  if( collision) {
+    PRINTF(0)("We got a collision!! Are you sure: outputFraction = %f\n", this->outputFraction);
+    worldEntity->registerCollision(this->parent, worldEntity, Vector(this->collPlane->x, this->collPlane->y, this->collPlane->z), out);
+  }
+
+}
+
 
 void  BspManager::checkCollision(BspTreeNode* node, Vector* cam)
@@ -938 +1053 @@
       this->drawDebugCube(&this->cam);
       this->drawDebugCube(&next);
-      State::getPlayer()->getPlayable()->setRelCoor(-100,-100,-100);
-      State::getPlayer()->getPlayable()->collidesWith(NULL, State::getCameraTargetNode()->getLastAbsCoor());
+     // State::getPlayer()->getPlayable()->setRelCoor(-100,-100,-100);
+      //State::getPlayer()->getPlayable()->collidesWith(NULL, State::getCameraTargetNode()->getLastAbsCoor());
     }
 

trunk/src/lib/graphics/importer/bsp_manager.h

@@ -1 +1 @@
 /*
    orxonox - the future of 3D-vertical-scrollers
- 
+
    Copyright (C) 2006 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: 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/
 */
 
+#ifndef _BSP_MANAGER_H
+#define _BSP_MANAGER_H
+
+
 #include <vector>
 #include <deque>
+
+
 
 // FORWARD DECLARATIONS
@@ -45 +51 @@
 public:
   // Constructors
-  BspManager();
-  
+  BspManager(WorldEntity* parent);
+
   BspManager(const char* fileName, float scale = 0.4f);
   void load(const char* fileName, float scale);
@@ -52 +58 @@
   // Functions
   const void draw();
-  void draw_debug_face(int Face); 
+  const void tick(float time);
+  void draw_debug_face(int Face);
   void draw_face(int Face);
   void draw_patch(face* Face);
-  
 
-  void checkCollision(WorldEntity* worldEntity);
+
+  void checkCollision(WorldEntity* worldEntity); /*!< WorldEntities use this function to check wheter they collided with the BspEntity.
+                                                      If a collision has been detected, the collides-function of worldEntity will be called.*/
 
 private:
   // Functions
   BspTreeNode* getLeaf(BspTreeNode*  node,   Vector* cam) ;  //!< Traverses the tree
-  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  checkCollision(BspTreeNode* node, Vector* cam); //!< Obsolete. Use this function for debugging only!
+  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 TraceBox( Vector& inputStart, Vector& inputEnd,Vector& inputMins, Vector& inputMaxs );
+  void  checkCollisionBox(void);
   void  checkBrushRay(brush* curBrush);
   void  checkBrushRayN(brush* curBrush);
+  void   checkBrushRayN(brush* curBrush, Vector& inputStart, Vector& inputEnd);
+
   void drawDebugCube(Vector* cam);
   bool isAlreadyVisible(int Face);
   void addFace(int Face);
-  
+
   // Data
   BspFile*  bspFile;
@@ -79 +91 @@
   plane* collPlane;
   int lastTex;
-  
-  //obsolete
+
+  //obsolete: global variables for collision detection
   bool  outputStartsOut;
   bool  outputAllSolid;
   float outputFraction;
+  Vector inputStart;
+  Vector inputEnd;
   
+  Vector traceMins; //!< Mins of current bbox
+  Vector traceMaxs; //!< Maxs of current bbox
+  Vector traceExtents; /*!< Stores the maximum of the absolute value of each axis in the box.
+                            For example, if traceMins was (-100,-3,-15) and traceMaxs was (55,22,7), traceExtents */
+
+  WorldEntity* parent;          //!< the parent entity of the bspManager: interface to this
+
   bool * alreadyVisible;
   // Deques to store the visible faces
@@ -90 +111 @@
   ::std::deque<int> opal; //!< the others here.
 
-  Vector out;
-  Vector out1;
-  Vector out2;
+  Vector out;  //!< For debugging only
+  Vector out1; //!< For debugging only
+  Vector out2; //!< For debugging only
+                        
+  int tgl;
 };
 
+#endif /* _BSP_MANAGER_H */

trunk/src/lib/graphics/importer/md3/md3_data.cc

@@ -23 +23 @@
 #include "material.h"
 
+#include "debug.h"
 
 namespace md3