Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/graphics/importer/bsp_manager.cc @ 8513

Last change on this file since 8513 was 8490, checked in by patrick, 18 years ago

merged the bsp branche back to trunk

File size: 36.9 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2006 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11   ### File Specific:
12   main-programmer: bottac@ee.ethz.ch
13
14   Inspired by:
15   Rendering Q3 Maps by Morgan McGuire                  http://graphics.cs.brown.edu/games/quake/quake3.html
16   Unofficial Quake 3 Map Specs by Kekoa Proudfoot      http://graphics.stanford.edu/~kekoa/q3/
17
18   Collision detection adapted from:
19   Quake 3 Collision Detection by Nathan Ostgard        http://www.devmaster.net/articles/quake3collision/
20*/
21
22
23#include "vector.h"
24#include "bsp_file.h"
25#include "bsp_manager.h"
26#include "bsp_tree_leaf.h"
27#include "p_node.h"
28#include "state.h"
29#include "debug.h"
30#include "material.h"
31#include "camera.h"
32#include "vertex_array_model.h"
33#include "world_entities/player.h"
34#include "world_entities/playable.h"
35#include "util/loading/resource_manager.h"
36// STL Containers
37#include <vector>
38#include <deque>
39#include "movie_player.h"
40
41#include "world_entity.h"
42
43#include "util/loading/load_param.h"
44#include "util/loading/factory.h"
45
46
47
48//CREATE_FACTORY( BspManager, CL_BSP_MODEL);
49
50BspManager::BspManager(WorldEntity* parent)
51{
52 
53  this->parent = parent;
54  /*// open a BSP file
55  this->bspFile = new BspFile();
56  this->bspFile->scale = 0.4f;
57  this->bspFile->read(ResourceManager::getFullName("test.bsp").c_str());
58  this->bspFile->build_tree();
59  this->root  = this->bspFile->get_root();
60  this->alreadyVisible = new bool [this->bspFile->numFaces];
61  */
62
63}
64
65
66/*
67BspManager::BspManager(const TiXmlElement* root)
68{
69
70
71  if( root != NULL)
72    this->loadParams(root);
73
74  CDEngine::getInstance()->setBSPModel(this);
75} */
76
77void BspManager::load(const char* fileName, float scale)
78{
79  // open a BSP file
80  this->bspFile = new BspFile();
81  this->bspFile->scale =  scale;
82  this->bspFile->read(ResourceManager::getFullName(fileName).c_str());
83  this->bspFile->build_tree();
84  this->root  = this->bspFile->get_root();
85  this->alreadyVisible = new bool [this->bspFile->numFaces];
86
87  this->outputFraction = 1.0f;
88}
89/*
90BspManager::BspManager(const char* fileName, float scale)
91{
92  // open a BSP file
93  this->bspFile = new BspFile();
94  this->bspFile->scale =  scale;
95  this->bspFile->read(fileName);
96  this->bspFile->build_tree();
97  this->root  = this->bspFile->get_root();
98  this->alreadyVisible = new bool [this->bspFile->numFaces];
99
100  CDEngine::getInstance()->setBSPModel(this);
101}
102*/
103
104const void BspManager::tick(float time)
105{
106
107  if(!this->bspFile->MovieMaterials.empty())
108  {
109      ::std::vector<MoviePlayer *>::iterator it = this->bspFile->MovieMaterials.begin() ;
110      while(it != this->bspFile->MovieMaterials.end())
111      {
112         (*it)->tick(time);
113        it++;
114      }
115 //this->bspFile->MovieMaterials.front()->tick(time );
116
117
118  }
119
120}
121const void BspManager::draw()
122{
123
124  /*
125  this->drawDebugCube(&this->out);
126  this->out1 = this->out;
127  this->out2 = this->out;
128  if(this->collPlane != NULL) {
129    this->out1.x += this->collPlane->x*5.0;
130    this->out1.y += this->collPlane->y*5.0;
131    this->out1.z += this->collPlane->z*5.0;
132
133    this->out2.x += this->collPlane->x*10.0;
134    this->out2.y += this->collPlane->y*10.0;
135    this->out2.z += this->collPlane->z*10.0;
136  }
137  this->drawDebugCube(&this->out1);
138  this->drawDebugCube(&this->out2);
139
140  */
141
142
143  // Draw Debug Terrain
144  /*
145  this->bspFile->Materials[0]->select();
146  for(int i = 0; i <  this->bspFile->numPatches ; i++)
147        {
148                this->bspFile->VertexArrayModels[i]->draw();
149
150        }
151  */
152
153
154
155  // erase alreadyVisible
156  for(int i = 0; i < this->bspFile->numFaces; i++) this->alreadyVisible[i] = false;
157  float tmp = 0;
158  //this->opal.clear();
159  //this->trasparent.clear();
160  // Find all visible faces...
161
162  this->cam = State::getCamera()->getAbsCoor() ;
163  //this->ship = State::getCameraTargetNode()->getAbsCoor();
164
165
166
167
168
169  this->viewDir=    State::getCamera()->getAbsDirX();
170  float d = (cam.x*viewDir.x + cam.y*viewDir.y + cam.z * viewDir.z);
171
172  BspTreeNode*  ActLeaf = this->getLeaf(this->bspFile->root, &ship);
173  int viscluster = -1;
174  viscluster =((leaf*)(this->bspFile->leaves))[ ActLeaf->leafIndex].cluster; // get the players cluster (viscluster)
175
176
177
178
179 // this->checkCollision(this->root, &this->cam);   //!< Test Collision Detection
180
181
182  this->outputStartsOut = true;
183  this->outputAllSolid = false;
184  this->outputFraction = 1.0f;
185
186  if ( viscluster < 0  || ((int *)(this->bspFile->header))[35] == 0 )  //!< if (sizeof(Visdata) == 0)
187  {
188
189
190
191    // Iterate through all Leafs
192    for(int i = 0; i <  this->bspFile->numLeafs   ; i++ )
193    {
194      // cluster =  (this->bspFile->leaves)[i].cluster;
195      leaf& curLeaf = (this->bspFile->leaves)[i];
196      if(curLeaf.cluster<0) continue;
197
198      /** Do Frustum culling and draw 'em all **/
199
200      Vector dir = State::getCameraNode()->getAbsDirX();
201
202      float dist =  dir.x*this->cam.x +dir.y*this->cam.y +dir.z*this->cam.z;
203      //if(dist < 0) dist = -dist;
204      const float dMins = dir.x*(float)curLeaf.mins[0] +dir.y*(float)curLeaf.mins[1] +dir.z*(float)curLeaf.mins[2] - dist ;
205      const float dMaxs = dir.x*(float)curLeaf.maxs[0] +dir.y*(float)curLeaf.maxs[1] +dir.z*(float)curLeaf.maxs[2] - dist ;
206
207      if(dMins < -300.0 && dMaxs < -300.0) {
208        continue;
209      }
210      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) {
211        continue;
212      }
213
214
215      // Iterate through all faces
216      for (int j = 0; j < curLeaf.n_leaffaces ; ++j) {
217        const int g = (j +  curLeaf.leafface);
218        const int f = ((int *)this->bspFile->leafFaces)[g];
219        if (f >=0 && !this->isAlreadyVisible(f)) {
220          this->alreadyVisible[f] = true;
221          addFace(f); // "visibleFaces.append(f)"
222        }
223      }
224
225
226
227
228    } //for
229  } else {
230
231
232    unsigned int v;
233    unsigned char  visSet;
234
235    // Iterate through all Leafs
236
237    for(int i = 0; i <  this->bspFile->numLeafs   ; ++i ) {
238      leaf& camLeaf =  (this->bspFile->leaves)[ActLeaf->leafIndex] ;
239      leaf& curLeaf =  (this->bspFile->leaves)[i] ;
240      int& cluster =  curLeaf.cluster;
241
242      if(cluster < 0) continue;
243      v = ((viscluster *  ( ((int *)this->bspFile->visData)[1]) ) + (cluster / 8));
244      visSet =((char*) (this->bspFile->visData))[v + 8];
245
246      // gets bit of visSet
247      if( ((visSet) & (1 << (cluster &  7))) != 0 ) {
248
249        // Frustum culling
250
251        Vector dir;
252        dir.x = State::getCameraNode()->getAbsDirX().x;
253        dir.y =  State::getCameraNode()->getAbsDirX().y;
254        dir.z =  State::getCameraNode()->getAbsDirX().z;
255        const float dist =  dir.x*this->cam.x +dir.y*this->cam.y +dir.z*this->cam.z;
256        //if(dist < 0) dist = -dist;
257        const float dMins = dir.x*(float)curLeaf.mins[0] +dir.y*(float)curLeaf.mins[1] +dir.z*(float)curLeaf.mins[2] - dist;
258        const float dMaxs = dir.x*(float)curLeaf.maxs[0] +dir.y*(float)curLeaf.maxs[1] +dir.z*(float)curLeaf.maxs[2] - dist;
259
260        if(dMins < -50.0 && dMaxs < -  50.0) {
261          continue;
262        }
263
264
265        // Iterate through all faces
266        for (int j = 0; j < curLeaf.n_leaffaces ; ++j) {
267          const int g = (j +  curLeaf.leafface);
268          const int f = ((int *)this->bspFile->leafFaces)[g];
269
270          if (!this->isAlreadyVisible(f) && f>=0) {
271            this->addFace(f);
272            this->alreadyVisible[f] = true;
273          }
274
275        }
276
277      }// if
278
279    }//for
280
281  }//else
282
283  while(!this->opal.empty()) {
284    this->draw_face(this->opal.front());
285    this->opal.pop_front();
286  }
287  while(!this->trasparent.empty()) {
288    this->draw_face(this->trasparent.back());
289    this->trasparent.pop_back();
290  }
291  //glEnable(GL_TEXTURE_2D);
292  glActiveTextureARB(GL_TEXTURE1_ARB);
293  glBindTexture(GL_TEXTURE_2D, this->bspFile->whiteLightMap);
294
295
296
297}//draw
298
299
300
301void BspManager::draw_face(int curface)
302{
303  face& curFace =  (this->bspFile->faces)[curface];
304  const BspVertex* curVertex = (BspVertex *) this->bspFile->vertice;
305  int stride = sizeof(BspVertex);  // sizeof(Vertex)
306  int offset    = curFace.vertex;
307  if (curFace.effect != -1) return;
308  // PRINTF(0)("BSP Manager: ");
309  // PRINTF(0)("BSP Manager: type: %i  \n", curFace.texture);
310
311  //  if(  curFace.texture < 0 ) return;
312  if(curFace.type == 2) {
313    this->draw_patch( &curFace);
314    return;
315  }
316 // if(curFace.type != 1) return;
317  if((char*)(this->bspFile->textures)[curFace.texture*72]== 0) return;
318
319  if(this->lastTex != curFace.texture) {
320    if(this->bspFile->Materials[curFace.texture].animated) {
321     // glBlendFunc(GL_ZERO,GL_ONE);
322
323
324
325      if(this->bspFile->Materials[curFace.texture].aviMat->getStatus() == 2) this->bspFile->Materials[curFace.texture].aviMat->start(0);
326      //this->bspFile->Materials[curFace.texture].aviMat->tick(0.005);
327      int n =  this->bspFile->Materials[curFace.texture].aviMat->getTexture();
328      glActiveTextureARB(GL_TEXTURE0_ARB);
329      glBindTexture(GL_TEXTURE_2D, n );
330      this->lastTex = curFace.texture;
331
332    } else {
333      this->bspFile->Materials[curFace.texture].mat->select();
334      this->lastTex = curFace.texture;
335    }
336  }
337
338  if(curFace.lm_index < 0) {
339    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
340    glActiveTextureARB(GL_TEXTURE1_ARB);
341    glBindTexture(GL_TEXTURE_2D, this->bspFile->whiteLightMap );
342    glEnable(GL_TEXTURE_2D);
343  } else {
344   // glEnable(GL_BLEND);
345    //glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
346    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
347    glActiveTextureARB(GL_TEXTURE1_ARB);
348    glBindTexture(GL_TEXTURE_2D, this->bspFile->glLightMapTextures[curFace.lm_index]);
349    glEnable(GL_TEXTURE_2D);
350  //  glDisable(GL_BLEND);
351  }
352
353  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
354
355  // glColor4f(3.0,3.0,3.0,1.0);
356  glEnableClientState(GL_VERTEX_ARRAY );
357  glEnableClientState(GL_TEXTURE_COORD_ARRAY );
358  glEnableClientState(GL_NORMAL_ARRAY );
359  //  glEnableClientState(GL_COLOR_ARRAY);
360
361
362  glVertexPointer(3, GL_FLOAT, stride, &(curVertex[offset].position[0]));
363
364  glClientActiveTextureARB(GL_TEXTURE0_ARB);
365  glTexCoordPointer(2, GL_FLOAT, stride, &(curVertex[offset].texcoord[0]));
366  //glEnableClientState(GL_TEXTURE_COORD_ARRAY);
367
368  glClientActiveTextureARB(GL_TEXTURE1_ARB);
369  glTexCoordPointer(2, GL_FLOAT, stride, &(curVertex[offset].texcoord[1]));
370  //glEnableClientState(GL_TEXTURE_COORD_ARRAY);
371
372
373  glNormalPointer( GL_FLOAT, stride, &(curVertex[offset].normal[0]));
374  // glColorPointer(4, GL_BYTE, stride, &(curVertex[offset].color[0]));
375  glDrawElements(GL_TRIANGLES, curFace.n_meshverts,
376                 GL_UNSIGNED_INT, &(((meshvert *)this->bspFile->meshverts) [curFace.meshvert]));
377
378  glDisableClientState(GL_TEXTURE0_ARB);
379  glDisableClientState(GL_TEXTURE1_ARB);
380  glDisableClientState(GL_VERTEX_ARRAY );
381  glDisableClientState(GL_TEXTURE_COORD_ARRAY );
382  glDisableClientState(GL_NORMAL_ARRAY );
383  // glDisableClientState(GL_COLOR_ARRAY);
384
385}
386
387
388void BspManager::draw_debug_face(int curface)
389{
390  face& curFace =  (this->bspFile->faces)[curface];
391  const BspVertex* curVertex = (BspVertex *) this->bspFile->vertice;
392  int stride = 44;  // sizeof(Vertex)
393  int offset    = curFace.vertex;
394
395  // PRINTF(0)("BSP Manager: ");
396  // PRINTF(0)("BSP Manager: type: %i  \n", curFace.texture);
397
398  //  if(  curFace.texture < 0 ) return;
399  if(curFace.type == 2) {
400    this->draw_patch( &curFace);
401    return;
402  }
403  if(curFace.type == 3) return;
404  // if(this->bspFile->Materials[curFace.texture] != NULL)
405
406  this->bspFile->Materials[2].mat->select();
407  this->lastTex = 2;
408
409  glEnableClientState(GL_VERTEX_ARRAY );
410  glEnableClientState(GL_TEXTURE_COORD_ARRAY );
411  glEnableClientState(GL_NORMAL_ARRAY );
412  //glEnableClientState(GL_COLOR_ARRAY);
413  // glEnableClientState(GL_VERTEX_ARRAY );
414  glClientActiveTextureARB(GL_TEXTURE0_ARB);
415  glVertexPointer(3, GL_FLOAT, stride, &(curVertex[offset].position[0]));
416  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
417  // glClientActiveTextureARB(GL_TEXTURE0_ARB);
418  glClientActiveTextureARB(GL_TEXTURE1_ARB);
419  glTexCoordPointer(2, GL_FLOAT, stride, &(curVertex[offset].texcoord[0]));
420  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
421  // glClientActiveTextureARB(GL_TEXTURE1_ARB);
422  // glTexCoordPointer(2, GL_FLOAT, stride, &(curVertex[offset].texcoord[1]));
423  //glEnableClientState(GL_NORMAL_ARRAY );
424
425  glNormalPointer( GL_FLOAT, stride, &(curVertex[offset].normal[0]));
426  //  glColorPointer(4, GL_BYTE, stride, &(curVertex[offset].color[0]));
427  glDrawElements(GL_TRIANGLES, curFace.n_meshverts,
428                 GL_UNSIGNED_INT, &(((meshvert *)this->bspFile->meshverts) [curFace.meshvert]));
429
430}
431
432void BspManager::draw_patch(face* Face)
433{
434  if(this->lastTex != Face->texture) {
435    this->bspFile->Materials[Face->texture].mat->select();
436    this->lastTex = Face->texture;
437  }
438  if (Face->effect != -1) return;
439
440
441  if(Face->lm_index < 0) {
442    glActiveTextureARB(GL_TEXTURE1_ARB);
443    glBindTexture(GL_TEXTURE_2D, this->bspFile->whiteLightMap);
444    glEnable(GL_TEXTURE_2D);
445  } else {
446    glActiveTextureARB(GL_TEXTURE1_ARB);
447    glBindTexture(GL_TEXTURE_2D, this->bspFile->glLightMapTextures[Face->lm_index]);
448    glEnable(GL_TEXTURE_2D);
449  }
450  //glColor4f(3.0,3.0,3.0,1.0);
451
452  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
453  glEnable( GL_AUTO_NORMAL);
454  glEnableClientState(GL_VERTEX_ARRAY );
455  glEnableClientState(GL_TEXTURE_COORD_ARRAY );
456  for(int i = Face->n_meshverts -1; i >=0   ; i--) {
457    //glFrontFace(GL_CW);
458    //PRINTF(0)("BSP Manager: Face->size[0]: %i . \n", Face->size[0]);
459
460
461    //glEnableClientState(GL_NORMAL_ARRAY );
462
463    glVertexPointer(3, GL_FLOAT,44, &((((BspVertex*)(this->bspFile->patchVertice))[8*8*(Face->meshvert+i)]).position[0]));
464
465
466    glClientActiveTextureARB(GL_TEXTURE0_ARB);
467    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
468    glTexCoordPointer(2, GL_FLOAT, 44, &((((BspVertex*)(this->bspFile->patchVertice))[8*8*(Face->meshvert+i)]).texcoord[0][0]));
469
470
471
472    glClientActiveTextureARB(GL_TEXTURE1_ARB);
473    glTexCoordPointer(2, GL_FLOAT, 44, &((((BspVertex*)(this->bspFile->patchVertice))[8*8*(Face->meshvert+i)]).texcoord[1][0]));
474    //glEnableClientState(GL_TEXTURE_COORD_ARRAY);
475
476
477    //  glNormalPointer( GL_FLOAT, 44,&((((BspVertex*)(this->bspFile->patchVertice))[8*8*(Face->meshvert+i)]).normal[0]) );
478
479
480
481
482    for(int row=6; row>=0; --row) {
483      glDrawElements(GL_TRIANGLE_STRIP, 2*(8), GL_UNSIGNED_INT,
484                     & (     (((GLuint*)  (this->bspFile->patchIndexes))[7*8*2*(Face->meshvert+i)+ row*2*8]  ))  );
485    }
486
487    //glFrontFace(GL_CCW);
488  }
489  glDisableClientState(GL_TEXTURE0_ARB);
490  glDisableClientState(GL_TEXTURE1_ARB);
491  glDisable(GL_AUTO_NORMAL);
492  glDisableClientState(GL_VERTEX_ARRAY );
493  glDisableClientState(GL_TEXTURE_COORD_ARRAY );
494
495
496}
497
498bool BspManager::isAlreadyVisible(int Face)
499{
500  return this->alreadyVisible[Face];
501}
502
503
504BspTreeNode*  BspManager::getLeaf(BspTreeNode* node, Vector* cam)
505{
506  float dist = 0;
507  while(!(node->isLeaf)) {
508    dist = (node->plane.x * this->cam.x + node->plane.y*this->cam.y + node->plane.z*this->cam.z) - node->d;
509    if(dist >= 0.0f) {
510      node = node->left;
511    } else {
512      node = node->right;
513    }
514  }
515  return  node;
516}
517
518void BspManager::checkBrushRay(brush* curBrush)
519{
520  float EPSILON = 0.000001;
521  float startDistance;
522  float endDistance;
523
524  float startFraction = -1.0f;
525  float endFraction = 1.0f;
526  bool startsOut = false;
527  bool endsOut = false;
528
529  Vector inputStart = State::getCameraTargetNode()->getLastAbsCoor();
530  Vector inputEnd   = State::getCameraTargetNode()->getAbsCoor();
531
532  for (int i = 0; i < curBrush->n_brushsides; i++) {
533    brushside& curBrushSide =   this->bspFile->brushSides[curBrush->brushside + i]   ;
534    plane& curPlane  =   this->bspFile->planes[curBrushSide.plane] ;
535
536    startDistance = inputStart.x * curPlane.x + inputStart.y * curPlane.y+ inputStart.z * curPlane.z - curPlane.d;
537    endDistance = inputEnd.x * curPlane.x +inputEnd.y * curPlane.y +inputEnd.z * curPlane.z -curPlane.d;
538
539    if (startDistance > 0)
540      startsOut = true;
541    if (endDistance > 0)
542      endsOut = true;
543
544    // make sure the trace isn't completely on one side of the brush
545    if (startDistance > 0 && endDistance > 0) {   // both are in front of the plane, its outside of this brush
546      return;
547    }
548    if (startDistance <= 0 && endDistance <= 0) {   // both are behind this plane, it will get clipped by another one
549      continue;
550    }
551
552    // MMM... BEEFY
553    if (startDistance > endDistance) {   // line is entering into the brush
554      float fraction = (startDistance - EPSILON) / (startDistance - endDistance);  // *
555      if (fraction > startFraction)
556        startFraction = fraction;
557      // don't store plane
558      // this->collPlane = &curPlane;
559
560    } else {   // line is leaving the brush
561      float fraction = (startDistance + EPSILON) / (startDistance - endDistance);  // *
562      if (fraction < endFraction)
563        endFraction = fraction;
564      // don't store plane
565      //this->collPlane = & curPlane;
566
567    }
568
569  }
570  if (startsOut == false) {
571    this->outputStartsOut = false;
572    if (endsOut == false)
573      this->outputAllSolid = true;
574    return;
575  }
576
577  if (startFraction < endFraction) {
578    if (startFraction > -1.0f && startFraction < outputFraction) {
579      if (startFraction < 0)
580        startFraction = 0;
581      this->outputFraction = startFraction;
582    }
583  }
584
585}
586
587void BspManager::checkBrushRayN(brush* curBrush)
588{
589  float EPSILON = 0.000001;
590  float startDistance;
591  float endDistance;
592
593  float startFraction = -1.0f;
594  float endFraction = 1.0f;
595  bool  startsOut = false;
596  bool  endsOut = false;
597
598 // Vector inputStart = State::getCameraTargetNode()->getLastAbsCoor();
599 // Vector inputEnd   = State::getCameraTargetNode()->getAbsCoor();
600
601  for (int i = 0; i < curBrush->n_brushsides; i++) {
602    brushside& curBrushSide =   this->bspFile->brushSides[curBrush->brushside + i]   ;
603    plane& curPlane  =   this->bspFile->planes[curBrushSide.plane] ;
604
605    startDistance = inputStart.x * curPlane.x + inputStart.y * curPlane.y+ inputStart.z * curPlane.z - curPlane.d;
606    endDistance = inputEnd.x * curPlane.x +inputEnd.y * curPlane.y +inputEnd.z * curPlane.z -curPlane.d;
607
608    if (startDistance > 0)
609      startsOut = true;
610    if (endDistance > 0)
611      endsOut = true;
612
613    // make sure the trace isn't completely on one side of the brush
614    if (startDistance > 0 && endDistance > 0) {   // both are in front of the plane, its outside of this brush
615      return;
616    }
617    if (startDistance <= 0 && endDistance <= 0) {   // both are behind this plane, it will get clipped by another one
618      continue;
619    }
620
621    // MMM... BEEFY
622    if (startDistance > endDistance) {   // line is entering into the brush
623      float fraction = (startDistance - EPSILON) / (startDistance - endDistance);  // *
624      if (fraction > startFraction)
625        startFraction = fraction;
626      // store plane
627      this->collPlane = &curPlane;
628
629    } else {   // line is leaving the brush
630      float fraction = (startDistance + EPSILON) / (startDistance - endDistance);  // *
631      if (fraction < endFraction)
632        endFraction = fraction;
633      // store plane
634      this->collPlane = & curPlane;
635
636    }
637
638  }
639  if (startsOut == false) {
640    this->outputStartsOut = false;
641    if (endsOut == false)
642      this->outputAllSolid = true;
643    return;
644  }
645
646  if (startFraction < endFraction) {
647    if (startFraction > -1.0f && startFraction < outputFraction) {
648      if (startFraction < 0)
649        startFraction = 0;
650      this->outputFraction = startFraction;
651    }
652  }
653
654}
655
656void BspManager::checkBrushRayN(brush* curBrush, Vector& inputStart, Vector& inputEnd)
657{
658  float EPSILON = 0.000001;
659  float startDistance;
660  float endDistance;
661
662  float startFraction = -1.0f;
663  float endFraction = 1.0f;
664  bool  startsOut = false;
665  bool  endsOut = false;
666
667  //Vector inputStart = State::getCameraTargetNode()->getLastAbsCoor();
668  //Vector inputEnd   = State::getCameraTargetNode()->getAbsCoor();
669
670  for (int i = 0; i < curBrush->n_brushsides; i++) {
671    brushside& curBrushSide =   this->bspFile->brushSides[curBrush->brushside + i]   ;
672    plane& curPlane  =   this->bspFile->planes[curBrushSide.plane] ;
673
674    startDistance = inputStart.x * curPlane.x + inputStart.y * curPlane.y+ inputStart.z * curPlane.z - curPlane.d;
675    endDistance = inputEnd.x * curPlane.x +inputEnd.y * curPlane.y +inputEnd.z * curPlane.z -curPlane.d;
676
677    if (startDistance > 0)
678      startsOut = true;
679    if (endDistance > 0)
680      endsOut = true;
681
682    // make sure the trace isn't completely on one side of the brush
683    if (startDistance > 0 && endDistance > 0) {   // both are in front of the plane, its outside of this brush
684      return;
685    }
686    if (startDistance <= 0 && endDistance <= 0) {   // both are behind this plane, it will get clipped by another one
687      continue;
688    }
689
690    // MMM... BEEFY
691    if (startDistance > endDistance) {   // line is entering into the brush
692      float fraction = (startDistance - EPSILON) / (startDistance - endDistance);  // *
693      if (fraction > startFraction)
694        startFraction = fraction;
695      // store plane
696      this->collPlane = &curPlane;
697
698    } else {   // line is leaving the brush
699      float fraction = (startDistance + EPSILON) / (startDistance - endDistance);  // *
700      if (fraction < endFraction)
701        endFraction = fraction;
702      // store plane
703      this->collPlane = & curPlane;
704
705    }
706
707  }
708  if (startsOut == false) {
709    this->outputStartsOut = false;
710    if (endsOut == false)
711      this->outputAllSolid = true;
712    return;
713  }
714
715  if (startFraction < endFraction) {
716    if (startFraction > -1.0f && startFraction < outputFraction) {
717      if (startFraction < 0)
718        startFraction = 0;
719      this->outputFraction = startFraction;
720    }
721  }
722
723}
724
725
726void BspManager::checkCollisionRay(BspTreeNode* node, float startFraction, float endFraction, Vector* start, Vector* end)
727{
728
729
730  float EPSILON = 0.000001;
731  float  endDistance = (end)->x * (node->plane.x) +(end)->y * (node->plane.y) +(end)->z * (node->plane.z)  - node->d;
732  float  startDistance = (start)->x * (node->plane.x)+ (start)->y * (node->plane.y)+ (start)->z * (node->plane.z)- node->d;
733
734
735  if(node->isLeaf) {
736    leaf& curLeaf = this->bspFile->leaves[node->leafIndex];
737    for (int i = 0; i <  curLeaf.n_leafbrushes ; i++) {
738      brush& curBrush = this->bspFile->brushes[((int*)(this->bspFile->leafBrushes))[curLeaf.leafbrush_first+i]];
739      //object *brush = &BSP.brushes[BSP.leafBrushes[leaf->firstLeafBrush + i]];
740      if (curBrush.n_brushsides > 0   &&
741          ((((BspTexture*)(this->bspFile->textures))[curBrush.texture]).contents & 1))
742        // CheckBrush( brush );
743        this->checkBrushRay(&curBrush);
744      if(curBrush.n_brushsides <=0) this->outputAllSolid = true;
745    }
746    return;
747  }
748
749
750  if (startDistance >= 0 && endDistance >= 0)     // A
751  {   // both points are in front of the plane
752    // so check the front child
753    this->checkCollisionRay(node->left,0,0,start,end);
754  } else if (startDistance < 0 && endDistance < 0)  // B
755  {   // both points are behind the plane
756    // so check the back child
757    this->checkCollisionRay(node->right,0,0,start,end);
758  } else                                            // C
759  {   // the line spans the splitting plane
760    int side;
761    float fraction1, fraction2, middleFraction;
762    Vector middle;
763
764    // STEP 1: split the segment into two
765    if (startDistance < endDistance) {
766      side = 1; // back
767      float inverseDistance = 1.0f / (startDistance - endDistance);
768      fraction1 = (startDistance + EPSILON) * inverseDistance;
769      fraction2 = (startDistance + EPSILON) * inverseDistance;
770    } else if (endDistance < startDistance) {
771      side = 0; // front(start)->x * (node->plane.x)+
772      float inverseDistance = 1.0f / (startDistance - endDistance);
773      fraction1 = (startDistance + EPSILON) * inverseDistance;
774      fraction2 = (startDistance - EPSILON) * inverseDistance;
775    } else {
776      side = 0; // front
777      fraction1 = 1.0f;
778      fraction2 = 0.0f;
779    }
780
781    // STEP 2: make sure the numbers are valid
782    if (fraction1 < 0.0f) fraction1 = 0.0f;
783    else if (fraction1 > 1.0f) fraction1 = 1.0f;
784    if (fraction2 < 0.0f) fraction2 = 0.0f;
785    else if (fraction2 > 1.0f) fraction2 = 1.0f;
786
787    // STEP 3: calculate the middle point for the first side
788    middleFraction = startFraction +
789                     (endFraction - startFraction) * fraction1;
790
791    middle.x = start->x + fraction1 * (end->x - start->x);
792    middle.y = start->y + fraction1 * (end->y - start->y);
793    middle.z = start->z + fraction1 * (end->z - start->z);
794
795    // STEP 4: check the first side
796    //CheckNode( node->children[side], startFraction, middleFraction, start, middle );
797    if(side == 0) this->checkCollisionRay(node->left,startFraction, middleFraction, start, &middle );
798
799    else this->checkCollisionRay(node->right,startFraction, middleFraction,
800                                   start, &middle );
801
802    // STEP 5: calculate the middle point for the second side
803    middleFraction = startFraction +
804                     (endFraction - startFraction) * fraction2;
805
806    middle.x = start->x + fraction2 * (end->x - start->x);
807    middle.y = start->y + fraction2 * (end->y - start->y);
808    middle.z = start->z + fraction2 * (end->z - start->z);
809
810    // STEP 6: check the second side
811    if(side == 1)this->checkCollisionRay(node->left,middleFraction, endFraction, &middle, end);
812
813    else this->checkCollisionRay(node->right,middleFraction, endFraction,&middle, end );
814
815
816  }
817
818}
819
820
821
822void BspManager::checkCollisionRayN(BspTreeNode* node, float startFraction, float endFraction, Vector* start, Vector* end)
823{
824
825
826  float EPSILON = 0.000001;
827
828  float endDistance = end->dot(node->plane) - node->d;
829  float startDistance = start->dot(node->plane) - node->d;
830
831
832  if( node->isLeaf) {
833    leaf& curLeaf = this->bspFile->leaves[node->leafIndex];
834    for (int i = 0; i <  curLeaf.n_leafbrushes ; i++) {
835      brush& curBrush = this->bspFile->brushes[((int*)(this->bspFile->leafBrushes))[curLeaf.leafbrush_first+i]];
836      //object *brush = &BSP.brushes[BSP.leafBrushes[leaf->firstLeafBrush + i]];
837      if (curBrush.n_brushsides > 0   &&
838          ((((BspTexture*)(this->bspFile->textures))[curBrush.texture]).contents & 1))
839        // CheckBrush( brush );
840        this->checkBrushRayN(&curBrush);
841      if(curBrush.n_brushsides <=0) this->outputAllSolid = true;
842    }
843    return;
844  }
845
846
847  if (startDistance >= 0 && endDistance >= 0)     // A
848  {   // both points are in front of the plane
849    // so check the front child
850    this->checkCollisionRayN(node->left,0,0,start,end);
851  } else if (startDistance < 0 && endDistance < 0)  // B
852  {   // both points are behind the plane
853    // so check the back child
854    this->checkCollisionRayN(node->right,0,0,start,end);
855  } else                                            // C
856  {   // the line spans the splitting plane
857    int side;
858    float fraction1, fraction2, middleFraction;
859    Vector middle;
860
861    // STEP 1: split the segment into two
862    if (startDistance < endDistance) {
863      side = 1; // back
864      float inverseDistance = 1.0f / (startDistance - endDistance);
865      fraction1 = (startDistance + EPSILON) * inverseDistance;
866      fraction2 = (startDistance + EPSILON) * inverseDistance;
867    } else if (endDistance < startDistance) {
868      side = 0; // front(start)->x * (node->plane.x)+
869      float inverseDistance = 1.0f / (startDistance - endDistance);
870      fraction1 = (startDistance + EPSILON) * inverseDistance;
871      fraction2 = (startDistance - EPSILON) * inverseDistance;
872    } else {
873      side = 0; // front
874      fraction1 = 1.0f;
875      fraction2 = 0.0f;
876    }
877
878    // STEP 2: make sure the numbers are valid
879    if (fraction1 < 0.0f) fraction1 = 0.0f;
880    else if (fraction1 > 1.0f) fraction1 = 1.0f;
881    if (fraction2 < 0.0f) fraction2 = 0.0f;
882    else if (fraction2 > 1.0f) fraction2 = 1.0f;
883
884    // STEP 3: calculate the middle point for the first side
885    middleFraction = startFraction + (endFraction - startFraction) * fraction1;
886    middle = (*start) + ((*end) - (*start)) * fraction1;
887
888
889    // STEP 4: check the first side
890    //CheckNode( node->children[side], startFraction, middleFraction, start, middle );
891    if(side == 0) this->checkCollisionRayN(node->left,startFraction, middleFraction, start, &middle );
892
893    else this->checkCollisionRayN(node->right,startFraction, middleFraction,
894                                    start, &middle );
895
896    // STEP 5: calculate the middle point for the second side
897    middleFraction = startFraction + (endFraction - startFraction) * fraction2;
898    middle = (*start) + ((*end) - (*start)) * fraction2;
899
900    // STEP 6: check the second side
901    if(side == 1)this->checkCollisionRayN(node->left,middleFraction, endFraction, &middle, end);
902
903    else this->checkCollisionRayN(node->right,middleFraction, endFraction,&middle, end );
904
905
906  }
907
908}
909void BspManager::checkCollisionBox(void)
910{
911
912};
913
914void BspManager::TraceBox( Vector& inputStart, Vector& inputEnd,
915               Vector& inputMins, Vector& inputMaxs )
916{
917  if (inputMins.x == 0 && inputMins.y == 0 && inputMins.z == 0 &&
918      inputMaxs.x == 0 && inputMaxs.y == 0 && inputMaxs.z == 0)
919  {   // the user called TraceBox, but this is actually a ray
920   //!> FIXME TraceRay( inputStart, inputEnd );
921  }
922  else
923  {   // setup for a box
924    //traceType = TT_BOX;
925    this->traceMins = inputMins;
926    this->traceMaxs = inputMaxs;
927    this->traceExtents.x = -traceMins.x > traceMaxs.x ?
928        -traceMins.x : traceMaxs.x;
929    this->traceExtents.y = -traceMins.y > traceMaxs.y ?
930        -traceMins.y : traceMaxs.y;
931    this->traceExtents.z = -traceMins.z > traceMaxs.z ?
932        -traceMins.z : traceMaxs.z;
933   //!> FIXME Trace( inputStart, inputEnd );
934  }
935}
936
937void BspManager::checkCollision(WorldEntity* worldEntity)
938{
939 
940  this->outputStartsOut = true;
941  this->outputAllSolid = false;
942  this->outputFraction = 1.0f;
943 
944  Vector position = worldEntity->getAbsCoor();
945
946
947  Vector forwardDir = worldEntity->getAbsDirX();
948  forwardDir = forwardDir * 8.0f;
949
950  Vector upDir = worldEntity->getAbsDirY();
951  upDir.x = 0.0;
952  upDir.y = 1.0;
953  upDir.z = 0.0;
954  Vector dest;
955  /*
956  dest.x  += forwardDir.x;
957  dest.y  += forwardDir.y;
958  dest.z  += forwardDir.z;
959  */
960
961  dest = worldEntity->getAbsCoor() - upDir*40.0;
962  Vector out = dest;
963
964
965
966
967  bool collision = false;
968  Vector position1 = position + Vector(0.0,0.1,0.0);
969  Vector position2 = position + Vector(0.0,0.2,0.0);
970  Vector dest1 = position1 + forwardDir;
971  Vector dest2 = position2 + forwardDir;
972  dest = position - Vector(0.0, 40.0,0.0);
973  Vector out1;
974  Vector out2;
975
976
977  float height = 40;
978 
979  this->inputStart =  position;
980  this->inputEnd =   dest;
981  this->checkCollisionRayN(this->root,0.0f,1.0f, &position, &dest );
982
983  PRINTF(0)(" checking collision: %s, solid = %i, fraction = %f\n", worldEntity->getClassName(), this->outputAllSolid, this->outputFraction);
984  PRINTF(0)("checking collision!! Pos.Coords: %f , %f , %f\n", position.x , position.y, position.z);
985  PRINTF(0)("checking collision!! Dest.Coords: %f , %f , %f\n", dest.x , dest.y, dest.z); 
986//   position1.debug();
987
988  if( this->outputFraction == 1.0f)
989  {
990    if(this->outputAllSolid)
991    {
992      this->collPlane = new plane;
993      this->collPlane->x = 1.0f;
994      this->collPlane->y = 0.0f;
995      this->collPlane->z = 0.0f;
996      collision = true;
997    }
998    else
999      collision = false;
1000
1001
1002    out = dest;
1003  }
1004  else {
1005
1006    collision = true;
1007    out.x = position.x + (dest.x -position.x) * this->outputFraction;
1008    out.y = position.y + (dest.y -position.y) * this->outputFraction;
1009    out.z = position.z + (dest.z -position.z) * this->outputFraction;
1010
1011    Vector out3 = out + Vector(height*this->collPlane->x,height*this->collPlane->y,height*this->collPlane->z);
1012    this->out = out;
1013  }
1014
1015  // Return the normal here: Normal's stored in this->collPlane;
1016  if( collision) {
1017    PRINTF(0)("We got a collision!! Are you sure: outputFraction = %f\n", this->outputFraction);
1018    worldEntity->registerCollision(this->parent, worldEntity, Vector(this->collPlane->x, this->collPlane->y, this->collPlane->z), out);
1019  }
1020
1021}
1022
1023
1024void  BspManager::checkCollision(BspTreeNode* node, Vector* cam)
1025{
1026  Vector next = this->cam;
1027  next.x =   (State::getCameraTargetNode()->getLastAbsCoor()).x ;
1028  next.y =   (State::getCameraTargetNode()->getLastAbsCoor()).y ;
1029  next.z =   (State::getCameraTargetNode()->getLastAbsCoor()).z ;
1030
1031  float dist = 0;
1032  if(!(node->isLeaf)) {
1033    dist = (node->plane.x * this->cam.x + node->plane.y*this->cam.y + node->plane.z*this->cam.z) - node->d;
1034    if(dist > 4.0f) {
1035      checkCollision(node->left,cam);
1036      return;
1037    }
1038    if(dist < -4.0f) {
1039      checkCollision(node->right,cam);
1040      return;
1041    }
1042    if(dist<=4.0f && dist >= -4.0f) {
1043      checkCollision(node->left,cam);
1044      checkCollision(node->right,cam);
1045      return;
1046    }
1047    return;
1048  } else {
1049
1050    leaf& camLeaf =  ((leaf *)(this->bspFile->leaves))[(node->leafIndex ) ];
1051
1052    if (camLeaf.cluster < 0) {
1053      this->drawDebugCube(&this->cam);
1054      this->drawDebugCube(&next);
1055     // State::getPlayer()->getPlayable()->setRelCoor(-100,-100,-100);
1056      //State::getPlayer()->getPlayable()->collidesWith(NULL, State::getCameraTargetNode()->getLastAbsCoor());
1057    }
1058
1059
1060    /*
1061        for(int i = 0; i < camLeaf.n_leafbrushes && i < 10; i++ )
1062        {
1063                brush& curBrush = ((brush*)(this->bspFile->brushes))[(camLeaf.leafbrush_first +i)%this->bspFile->numLeafBrushes];
1064                if(curBrush.n_brushsides < 0) return;
1065                for(int j = 0; j < curBrush.n_brushsides; j++)
1066                {
1067                float dist = -0.1;
1068                brushside& curBrushSide = ((brushside*)(this->bspFile->brushSides))[(curBrush.brushside +j)%this->bspFile->numBrushSides];
1069                plane&      testPlane = ((plane*)(this->bspFile->planes))[curBrushSide.plane % this->bspFile->numPlanes];
1070                dist = testPlane.x * this->cam.x +  testPlane.y * this->cam.y  +  testPlane.z * this->cam.z   -testPlane.d ;
1071
1072                if(dist < -0.01f) dist = -1.0f *dist;
1073                if(dist < 1.0f){
1074                                this->drawDebugCube(&this->cam);
1075                                return;
1076                              }
1077                }
1078
1079        } */
1080
1081  }
1082  return;
1083}
1084
1085void BspManager::drawDebugCube(Vector* cam)
1086{
1087  glBegin(GL_QUADS);
1088
1089  // Bottom Face.  Red, 75% opaque, magnified texture
1090
1091  glNormal3f( 0.0f, -1.0f, 0.0f); // Needed for lighting
1092  glColor4f(0.9,0.2,0.2,.75); // Basic polygon color
1093
1094  glTexCoord2f(0.800f, 0.800f); glVertex3f(cam->x-1.0f, cam->y-1.0f,cam->z -1.0f);
1095  glTexCoord2f(0.200f, 0.800f); glVertex3f(cam->x+1.0f, cam->y-1.0f,cam->z -1.0f);
1096  glTexCoord2f(0.200f, 0.200f); glVertex3f(cam->x+ 1.0f,cam->y -1.0f,cam->z +  1.0f);
1097  glTexCoord2f(0.800f, 0.200f); glVertex3f(cam->x-1.0f, cam->y-1.0f, cam->z + 1.0f);
1098
1099
1100  // Top face; offset.  White, 50% opaque.
1101
1102  glNormal3f( 0.0f, 1.0f, 0.0f);  glColor4f(0.5,0.5,0.5,.5);
1103
1104  glTexCoord2f(0.005f, 1.995f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f, cam->z -1.0f);
1105  glTexCoord2f(0.005f, 0.005f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f,  cam->z +1.0f);
1106  glTexCoord2f(1.995f, 0.005f); glVertex3f(cam->x+ 1.0f,  cam->y+1.0f,  cam->z +1.0f);
1107  glTexCoord2f(1.995f, 1.995f); glVertex3f(cam->x+ 1.0f, cam->y+ 1.0f, cam->z -1.0f);
1108
1109
1110  // Far face.  Green, 50% opaque, non-uniform texture cooridinates.
1111
1112  glNormal3f( 0.0f, 0.0f,-1.0f);  glColor4f(0.2,0.9,0.2,.5);
1113
1114  glTexCoord2f(0.995f, 0.005f); glVertex3f(cam->x-1.0f, cam->y-1.0f, cam->z -1.3f);
1115  glTexCoord2f(2.995f, 2.995f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f, cam->z -1.3f);
1116  glTexCoord2f(0.005f, 0.995f); glVertex3f(cam->x+ 1.0f,cam->y+  1.0f, cam->z -1.3f);
1117  glTexCoord2f(0.005f, 0.005f); glVertex3f( cam->x+1.0f,cam->y -1.0f, cam->z -1.3f);
1118
1119
1120  // Right face.  Blue; 25% opaque
1121
1122  glNormal3f( 1.0f, 0.0f, 0.0f);  glColor4f(0.2,0.2,0.9,.25);
1123
1124  glTexCoord2f(0.995f, 0.005f); glVertex3f(cam->x+ 1.0f, cam->y -1.0f, cam->z -1.0f);
1125  glTexCoord2f(0.995f, 0.995f); glVertex3f(cam->x+ 1.0f, cam->y+ 1.0f, cam->z -1.0f);
1126  glTexCoord2f(0.005f, 0.995f); glVertex3f(cam->x+ 1.0f, cam->y+ 1.0f, cam->z + 1.0f);
1127  glTexCoord2f(0.005f, 0.005f); glVertex3f(cam->x+ 1.0f, cam->y-1.0f,  cam->z +1.0f);
1128
1129
1130  // Front face; offset.  Multi-colored, 50% opaque.
1131
1132  glNormal3f( 0.0f, 0.0f, 1.0f);
1133
1134  glColor4f( 0.9f, 0.2f, 0.2f, 0.5f);
1135  glTexCoord2f( 0.005f, 0.005f); glVertex3f(cam->x-1.0f, cam->y-1.0f,  cam->z +1.0f);
1136  glColor4f( 0.2f, 0.9f, 0.2f, 0.5f);
1137  glTexCoord2f( 0.995f, 0.005f); glVertex3f(cam->x+ 1.0f, cam->y-1.0f,  cam->z +1.0f);
1138  glColor4f( 0.2f, 0.2f, 0.9f, 0.5f);
1139  glTexCoord2f( 0.995f, 0.995f); glVertex3f( cam->x+1.0f,  cam->y+1.0f,  cam->z +1.0f);
1140  glColor4f( 0.1f, 0.1f, 0.1f, 0.5f);
1141  glTexCoord2f( 0.005f, 0.995f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f,  cam->z +1.0f);
1142
1143
1144  // Left Face; offset.  Yellow, varying levels of opaque.
1145
1146  glNormal3f(-1.0f, 0.0f, 0.0f);
1147
1148  glColor4f(0.9,0.9,0.2,0.0);
1149  glTexCoord2f(0.005f, 0.005f); glVertex3f(cam->x-1.0f, cam->y-1.0f, cam->z -1.0f);
1150  glColor4f(0.9,0.9,0.2,0.66);
1151  glTexCoord2f(0.995f, 0.005f); glVertex3f(cam->x-1.0f,cam->y -1.0f,  cam->z +1.0f);
1152  glColor4f(0.9,0.9,0.2,1.0);
1153  glTexCoord2f(0.995f, 0.995f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f,  cam->z +1.0f);
1154  glColor4f(0.9,0.9,0.2,0.33);
1155  glTexCoord2f(0.005f, 0.995f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f, cam->z -1.0f);
1156
1157  glEnd();
1158}
1159
1160void BspManager::addFace(int f)
1161{
1162  face& curFace =  ((face *)(this->bspFile->faces))[f];
1163  if(this->bspFile->Materials[curFace.texture].alpha) this->trasparent.push_back(f);
1164  else this->opal.push_back(f);
1165}
Note: See TracBrowser for help on using the repository browser.