Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 8914 was 8894, checked in by patrick, 18 years ago

merged the branche single_player_map with the trunk

File size: 39.7 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#include "aabb.h"
47#include "cr_defs.h"
48
49
50//CREATE_FACTORY( BspManager, CL_BSP_MODEL);
51
52BspManager::BspManager(WorldEntity* parent)
53{
54
55  this->parent = parent;
56  /*// open a BSP file
57  this->bspFile = new BspFile();
58  this->bspFile->scale = 0.4f;
59  this->bspFile->read(ResourceManager::getFullName("test.bsp").c_str());
60  this->bspFile->build_tree();
61  this->root  = this->bspFile->get_root();
62  this->alreadyVisible = new bool [this->bspFile->numFaces];
63  */
64
65}
66
67
68/*
69BspManager::BspManager(const TiXmlElement* root)
70{
71 
72 
73  if( root != NULL)
74    this->loadParams(root);
75 
76  CDEngine::getInstance()->setBSPModel(this);
77} */
78
79void BspManager::load(const char* fileName, float scale)
80{
81  // open a BSP file
82  this->bspFile = new BspFile();
83  this->bspFile->scale =  scale;
84  this->bspFile->read(ResourceManager::getFullName(fileName).c_str());
85  this->bspFile->build_tree();
86  this->root  = this->bspFile->get_root();
87  this->alreadyVisible = new bool [this->bspFile->numFaces];
88
89  this->outputFraction = 1.0f;
90}
91/*
92BspManager::BspManager(const char* fileName, float scale)
93{
94  // open a BSP file
95  this->bspFile = new BspFile();
96  this->bspFile->scale =  scale;
97  this->bspFile->read(fileName);
98  this->bspFile->build_tree();
99  this->root  = this->bspFile->get_root();
100  this->alreadyVisible = new bool [this->bspFile->numFaces];
101 
102  CDEngine::getInstance()->setBSPModel(this);
103}
104*/
105
106const void BspManager::tick(float time)
107{
108
109  if(!this->bspFile->MovieMaterials.empty()) {
110    ::std::vector<MoviePlayer *>::iterator it = this->bspFile->MovieMaterials.begin() ;
111    while(it != this->bspFile->MovieMaterials.end()) {
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
844    return;
845  }
846
847
848  if (startDistance >= 0 && endDistance >= 0)     // A
849  {   // both points are in front of the plane
850    // so check the front child
851    this->checkCollisionRayN(node->left,0,0,start,end);
852  } else if (startDistance < 0 && endDistance < 0)  // B
853  {   // both points are behind the plane
854    // so check the back child
855    this->checkCollisionRayN(node->right,0,0,start,end);
856  } else                                            // C
857  {   // the line spans the splitting plane
858    int side;
859    float fraction1, fraction2, middleFraction;
860    Vector middle;
861
862    // STEP 1: split the segment into two
863    if (startDistance < endDistance) {
864      side = 1; // back
865      float inverseDistance = 1.0f / (startDistance - endDistance);
866      fraction1 = (startDistance + EPSILON) * inverseDistance;
867      fraction2 = (startDistance + EPSILON) * inverseDistance;
868    } else if (endDistance < startDistance) {
869      side = 0; // front(start)->x * (node->plane.x)+
870      float inverseDistance = 1.0f / (startDistance - endDistance);
871      fraction1 = (startDistance + EPSILON) * inverseDistance;
872      fraction2 = (startDistance - EPSILON) * inverseDistance;
873    } else {
874      side = 0; // front
875      fraction1 = 1.0f;
876      fraction2 = 0.0f;
877    }
878
879    // STEP 2: make sure the numbers are valid
880    if (fraction1 < 0.0f) fraction1 = 0.0f;
881    else if (fraction1 > 1.0f) fraction1 = 1.0f;
882    if (fraction2 < 0.0f) fraction2 = 0.0f;
883    else if (fraction2 > 1.0f) fraction2 = 1.0f;
884
885    // STEP 3: calculate the middle point for the first side
886    middleFraction = startFraction + (endFraction - startFraction) * fraction1;
887    middle = (*start) + ((*end) - (*start)) * fraction1;
888
889
890    // STEP 4: check the first side
891    //CheckNode( node->children[side], startFraction, middleFraction, start, middle );
892    if(side == 0) this->checkCollisionRayN(node->left,startFraction, middleFraction, start, &middle );
893
894    else this->checkCollisionRayN(node->right,startFraction, middleFraction,
895                                    start, &middle );
896
897    // STEP 5: calculate the middle point for the second side
898    middleFraction = startFraction + (endFraction - startFraction) * fraction2;
899    middle = (*start) + ((*end) - (*start)) * fraction2;
900
901    // STEP 6: check the second side
902    if(side == 1)this->checkCollisionRayN(node->left,middleFraction, endFraction, &middle, end);
903
904    else this->checkCollisionRayN(node->right,middleFraction, endFraction,&middle, end );
905
906
907  }
908
909}
910
911float BspManager::checkPatchAltitude(BspTreeNode* node)
912{
913  leaf& curLeaf = this->bspFile->leaves[node->leafIndex];
914  for(int i = 0; i < curLeaf.n_leaffaces ; i++) {}
915  return 10.0f;
916}
917
918void BspManager::checkCollisionBox(void)
919{}
920
921
922void BspManager::TraceBox( Vector& inputStart, Vector& inputEnd,
923                           Vector& inputMins, Vector& inputMaxs )
924{
925  if (inputMins.x == 0 && inputMins.y == 0 && inputMins.z == 0 &&
926      inputMaxs.x == 0 && inputMaxs.y == 0 && inputMaxs.z == 0) {   // the user called TraceBox, but this is actually a ray
927    //!> FIXME TraceRay( inputStart, inputEnd );
928  } else {   // setup for a box
929    //traceType = TT_BOX;
930    this->traceMins = inputMins;
931    this->traceMaxs = inputMaxs;
932    this->traceExtents.x = -traceMins.x > traceMaxs.x ?
933                           -traceMins.x : traceMaxs.x;
934    this->traceExtents.y = -traceMins.y > traceMaxs.y ?
935                           -traceMins.y : traceMaxs.y;
936    this->traceExtents.z = -traceMins.z > traceMaxs.z ?
937                           -traceMins.z : traceMaxs.z;
938    //!> FIXME Trace( inputStart, inputEnd );
939  }
940}
941
942void BspManager::checkCollision(WorldEntity* worldEntity)
943{
944
945  // Init  Collision Detection
946  this->outputStartsOut = true;
947  this->outputAllSolid = false;
948  this->outputFraction = 1.0f;
949
950  // Retrieve Bounding box
951  AABB* box = worldEntity->getModelAABB();
952
953
954  Vector forwardDir = Vector(0.0,0.0,1.0);
955  Vector upDir = Vector(0.0,1.0,0.0);
956  Vector position = worldEntity->getAbsCoor();
957
958  bool SolidFlag = false;
959  bool collision = false;
960  Vector position1 = position;
961  Vector position2 = position + Vector(0.0,1.0,0.0);
962  Vector dest = worldEntity->getAbsCoor() - upDir*40.0f; //
963  Vector dest1 = position + forwardDir*4.0f;
964  Vector dest2 = position2 + forwardDir;
965  dest = position - Vector(0.0, 40.0,0.0);
966  Vector out = dest;
967  Vector out1;
968  Vector out2;
969
970
971
972  float height = 40;
973
974
975  if( box != NULL) {
976    position = worldEntity->getAbsCoor() +  box->center; // + box->axis[1] * box->halfLength[1];
977    dest     = worldEntity->getAbsCoor() +  box->center - box->axis[1] * box->halfLength[1] * 40.0;
978
979    position1 = worldEntity->getAbsCoor() +  box->center + box->axis[0] * box->halfLength[0] * 2.0f;
980    dest1     = worldEntity->getAbsCoor() +  box->center - box->axis[0] * box->halfLength[0] *2.0f;
981
982
983    position2 = worldEntity->getAbsCoor() +  box->center + box->axis[2] * box->halfLength[2] * 2.0f;
984    dest2     = worldEntity->getAbsCoor() +  box->center - box->axis[2] * box->halfLength[2] * 2.0f;
985
986  } else {
987    // Init positions and destinations to anything useful!
988
989  }
990
991
992
993  // 1st Ray
994  this->inputStart =  position;
995  this->inputEnd =   dest;
996  this->checkCollisionRayN(this->root,0.0f,1.0f, &position, &dest );
997
998
999  //
1000  if(!this->outputStartsOut ) {
1001    this->collPlane = new plane;
1002    this->collPlane->x = 0.0f;
1003    this->collPlane->y = 0.0f;
1004    this->collPlane->z = 0.0f;
1005    collision = true;
1006  } else {
1007
1008    if( this->outputFraction == 1.0f) {
1009      if(this->outputAllSolid ) {
1010        this->collPlane = new plane;
1011        this->collPlane->x = 0.0f;
1012        this->collPlane->y = 0.0f;
1013        this->collPlane->z = 0.0f;
1014        collision = true;
1015        SolidFlag = true;
1016      } else
1017        collision = false;
1018
1019
1020      out = dest;
1021
1022    } else {
1023      collision = true;
1024      out.x = position.x + (dest.x -position.x) * this->outputFraction;
1025      out.y = position.y + (dest.y -position.y) * this->outputFraction;
1026      out.z = position.z + (dest.z -position.z) * this->outputFraction;
1027
1028      Vector out3 = out + Vector(height*this->collPlane->x,height*this->collPlane->y,height*this->collPlane->z);
1029      this->out = out;
1030    }
1031
1032
1033  }
1034
1035  plane* testPlane = this->collPlane;
1036
1037
1038  bool xCollision = false;
1039  bool zCollision = false;
1040  if(!SolidFlag) {
1041
1042    // 2nd Collision Detection
1043    this->outputStartsOut = true;
1044    this->outputAllSolid = false;
1045    this->outputFraction = 1.0f;
1046    this->inputStart =  position1;
1047    this->inputEnd =   dest1;
1048    this->checkCollisionRayN(this->root,0.0f,1.0f, &position1, &dest1 );
1049
1050    if(!this->outputAllSolid != 1.0f) {
1051      out.x = dest1.x + (dest1.x -position1.x) * this->outputFraction;
1052      xCollision = true;
1053      testPlane = this->collPlane;
1054    }
1055    if(this->outputAllSolid) {
1056      SolidFlag = true;
1057      xCollision = true; 
1058    }
1059    //out.z = this->outputFraction;
1060
1061    if(!SolidFlag) {
1062
1063      // 3rd Collision Detection
1064      this->outputStartsOut = true;
1065      this->outputAllSolid = false;
1066      this->outputFraction = 1.0f;
1067      this->inputStart =  position2;
1068      this->inputEnd =   dest2;
1069      this->checkCollisionRayN(this->root,0.0f,1.0f, &position2, &dest2 );
1070      //out.x = this->outputFraction;
1071
1072      if(this->outputFraction != 1.0f ) {
1073        out.z = out.z = dest2.z + (dest2.z -position2.z) * this->outputFraction;
1074        zCollision = true;
1075        testPlane = this->collPlane;
1076
1077      }
1078      if(this->outputAllSolid) {
1079          SolidFlag = true;
1080          zCollision = true;   
1081      }
1082    }
1083  }//end if
1084  /*
1085  This is how you would calculate the Coordinates where worldEntity Collided with the BSP world.
1086  out.x = position1.x + (dest.x -position1.x) * this->outputFraction;
1087  out.z = position1.z + (dest.z -position1.z) * this->outputFraction;
1088  */
1089
1090
1091  // Return the normal here: Normal's stored in this->collPlane;
1092  if( collision) {
1093    PRINTF(5)("We got a collision!! Are you sure: outputFraction = %f\n", this->outputFraction);
1094    worldEntity->registerCollision(COLLISION_TYPE_AXIS_Y || (xCollision ? COLLISION_TYPE_AXIS_X :0) | (zCollision ? COLLISION_TYPE_AXIS_Z :0), this->parent, worldEntity, Vector(testPlane->x, testPlane->y, testPlane->z), out, SolidFlag);
1095  } else {
1096    if(xCollision || zCollision) {
1097
1098      worldEntity->registerCollision((xCollision ? COLLISION_TYPE_AXIS_X :0) | (zCollision ? COLLISION_TYPE_AXIS_Z :0) , this->parent, worldEntity, Vector(testPlane->x, testPlane->y, testPlane->z), out, SolidFlag);
1099    }
1100
1101  }
1102  //else  worldEntity->registerCollision(COLLISION_TYPE_AXIS_Y, this->parent, worldEntity, Vector(0.0, 2.0, 0.0), dest, false);
1103
1104}
1105
1106
1107void  BspManager::checkCollision(BspTreeNode* node, Vector* cam)
1108{
1109  Vector next = this->cam;
1110  next.x =   (State::getCameraTargetNode()->getLastAbsCoor()).x ;
1111  next.y =   (State::getCameraTargetNode()->getLastAbsCoor()).y ;
1112  next.z =   (State::getCameraTargetNode()->getLastAbsCoor()).z ;
1113
1114  float dist = 0;
1115  if(!(node->isLeaf)) {
1116    dist = (node->plane.x * this->cam.x + node->plane.y*this->cam.y + node->plane.z*this->cam.z) - node->d;
1117    if(dist > 4.0f) {
1118      checkCollision(node->left,cam);
1119      return;
1120    }
1121    if(dist < -4.0f) {
1122      checkCollision(node->right,cam);
1123      return;
1124    }
1125    if(dist<=4.0f && dist >= -4.0f) {
1126      checkCollision(node->left,cam);
1127      checkCollision(node->right,cam);
1128      return;
1129    }
1130    return;
1131  } else {
1132
1133    leaf& camLeaf =  ((leaf *)(this->bspFile->leaves))[(node->leafIndex ) ];
1134
1135    if (camLeaf.cluster < 0) {
1136      this->drawDebugCube(&this->cam);
1137      this->drawDebugCube(&next);
1138      // State::getPlayer()->getPlayable()->setRelCoor(-100,-100,-100);
1139      //State::getPlayer()->getPlayable()->collidesWith(NULL, State::getCameraTargetNode()->getLastAbsCoor());
1140    }
1141
1142
1143    /*
1144        for(int i = 0; i < camLeaf.n_leafbrushes && i < 10; i++ )
1145        {
1146                brush& curBrush = ((brush*)(this->bspFile->brushes))[(camLeaf.leafbrush_first +i)%this->bspFile->numLeafBrushes];
1147                if(curBrush.n_brushsides < 0) return;
1148                for(int j = 0; j < curBrush.n_brushsides; j++)
1149                {
1150                float dist = -0.1;
1151                brushside& curBrushSide = ((brushside*)(this->bspFile->brushSides))[(curBrush.brushside +j)%this->bspFile->numBrushSides];
1152                plane&      testPlane = ((plane*)(this->bspFile->planes))[curBrushSide.plane % this->bspFile->numPlanes];
1153                dist = testPlane.x * this->cam.x +  testPlane.y * this->cam.y  +  testPlane.z * this->cam.z   -testPlane.d ;
1154
1155                if(dist < -0.01f) dist = -1.0f *dist;
1156                if(dist < 1.0f){
1157                                this->drawDebugCube(&this->cam);
1158                                return;
1159                              }
1160                }
1161
1162        } */
1163
1164  }
1165  return;
1166}
1167
1168void BspManager::drawDebugCube(Vector* cam)
1169{
1170  glBegin(GL_QUADS);
1171
1172  // Bottom Face.  Red, 75% opaque, magnified texture
1173
1174  glNormal3f( 0.0f, -1.0f, 0.0f); // Needed for lighting
1175  glColor4f(0.9,0.2,0.2,.75); // Basic polygon color
1176
1177  glTexCoord2f(0.800f, 0.800f); glVertex3f(cam->x-1.0f, cam->y-1.0f,cam->z -1.0f);
1178  glTexCoord2f(0.200f, 0.800f); glVertex3f(cam->x+1.0f, cam->y-1.0f,cam->z -1.0f);
1179  glTexCoord2f(0.200f, 0.200f); glVertex3f(cam->x+ 1.0f,cam->y -1.0f,cam->z +  1.0f);
1180  glTexCoord2f(0.800f, 0.200f); glVertex3f(cam->x-1.0f, cam->y-1.0f, cam->z + 1.0f);
1181
1182
1183  // Top face; offset.  White, 50% opaque.
1184
1185  glNormal3f( 0.0f, 1.0f, 0.0f);  glColor4f(0.5,0.5,0.5,.5);
1186
1187  glTexCoord2f(0.005f, 1.995f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f, cam->z -1.0f);
1188  glTexCoord2f(0.005f, 0.005f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f,  cam->z +1.0f);
1189  glTexCoord2f(1.995f, 0.005f); glVertex3f(cam->x+ 1.0f,  cam->y+1.0f,  cam->z +1.0f);
1190  glTexCoord2f(1.995f, 1.995f); glVertex3f(cam->x+ 1.0f, cam->y+ 1.0f, cam->z -1.0f);
1191
1192
1193  // Far face.  Green, 50% opaque, non-uniform texture cooridinates.
1194
1195  glNormal3f( 0.0f, 0.0f,-1.0f);  glColor4f(0.2,0.9,0.2,.5);
1196
1197  glTexCoord2f(0.995f, 0.005f); glVertex3f(cam->x-1.0f, cam->y-1.0f, cam->z -1.3f);
1198  glTexCoord2f(2.995f, 2.995f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f, cam->z -1.3f);
1199  glTexCoord2f(0.005f, 0.995f); glVertex3f(cam->x+ 1.0f,cam->y+  1.0f, cam->z -1.3f);
1200  glTexCoord2f(0.005f, 0.005f); glVertex3f( cam->x+1.0f,cam->y -1.0f, cam->z -1.3f);
1201
1202
1203  // Right face.  Blue; 25% opaque
1204
1205  glNormal3f( 1.0f, 0.0f, 0.0f);  glColor4f(0.2,0.2,0.9,.25);
1206
1207  glTexCoord2f(0.995f, 0.005f); glVertex3f(cam->x+ 1.0f, cam->y -1.0f, cam->z -1.0f);
1208  glTexCoord2f(0.995f, 0.995f); glVertex3f(cam->x+ 1.0f, cam->y+ 1.0f, cam->z -1.0f);
1209  glTexCoord2f(0.005f, 0.995f); glVertex3f(cam->x+ 1.0f, cam->y+ 1.0f, cam->z + 1.0f);
1210  glTexCoord2f(0.005f, 0.005f); glVertex3f(cam->x+ 1.0f, cam->y-1.0f,  cam->z +1.0f);
1211
1212
1213  // Front face; offset.  Multi-colored, 50% opaque.
1214
1215  glNormal3f( 0.0f, 0.0f, 1.0f);
1216
1217  glColor4f( 0.9f, 0.2f, 0.2f, 0.5f);
1218  glTexCoord2f( 0.005f, 0.005f); glVertex3f(cam->x-1.0f, cam->y-1.0f,  cam->z +1.0f);
1219  glColor4f( 0.2f, 0.9f, 0.2f, 0.5f);
1220  glTexCoord2f( 0.995f, 0.005f); glVertex3f(cam->x+ 1.0f, cam->y-1.0f,  cam->z +1.0f);
1221  glColor4f( 0.2f, 0.2f, 0.9f, 0.5f);
1222  glTexCoord2f( 0.995f, 0.995f); glVertex3f( cam->x+1.0f,  cam->y+1.0f,  cam->z +1.0f);
1223  glColor4f( 0.1f, 0.1f, 0.1f, 0.5f);
1224  glTexCoord2f( 0.005f, 0.995f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f,  cam->z +1.0f);
1225
1226
1227  // Left Face; offset.  Yellow, varying levels of opaque.
1228
1229  glNormal3f(-1.0f, 0.0f, 0.0f);
1230
1231  glColor4f(0.9,0.9,0.2,0.0);
1232  glTexCoord2f(0.005f, 0.005f); glVertex3f(cam->x-1.0f, cam->y-1.0f, cam->z -1.0f);
1233  glColor4f(0.9,0.9,0.2,0.66);
1234  glTexCoord2f(0.995f, 0.005f); glVertex3f(cam->x-1.0f,cam->y -1.0f,  cam->z +1.0f);
1235  glColor4f(0.9,0.9,0.2,1.0);
1236  glTexCoord2f(0.995f, 0.995f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f,  cam->z +1.0f);
1237  glColor4f(0.9,0.9,0.2,0.33);
1238  glTexCoord2f(0.005f, 0.995f); glVertex3f(cam->x-1.0f, cam->y+ 1.0f, cam->z -1.0f);
1239
1240  glEnd();
1241}
1242
1243void BspManager::addFace(int f)
1244{
1245  face& curFace =  ((face *)(this->bspFile->faces))[f];
1246  if(this->bspFile->Materials[curFace.texture].alpha) this->trasparent.push_back(f);
1247  else this->opal.push_back(f);
1248}
Note: See TracBrowser for help on using the repository browser.