src/Scenery/tileentry.cxx

   1 // tileentry.cxx -- routines to handle a scenery tile
   2 //
   3 // Written by Curtis Olson, started May 1998.
   4 //
   5 // Copyright (C) 1998 - 2001  Curtis L. Olson  - curt@flightgear.org
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License as
   9 // published by the Free Software Foundation; either version 2 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 // General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 //
  21 // $Id$
  22
  23
  24 #ifdef HAVE_CONFIG_H
  25 #  include <config.h>
  26 #endif
  27
  28 #include <simgear/compiler.h>
  29
  30 #include <simgear/bucket/newbucket.hxx>
  31 #include <simgear/debug/logstream.hxx>
  32 #include <simgear/math/sg_geodesy.hxx>
  33 #include <simgear/math/sg_random.h>
  34 #include <simgear/misc/sgstream.hxx>
  35
  36 #include <Aircraft/aircraft.hxx>
  37 #include <Include/general.hxx>
  38 #include <Main/globals.hxx>
  39 #include <Main/viewer.hxx>
  40 #include <Scenery/scenery.hxx>
  41 #include <Time/light.hxx>
  42 #include <Objects/apt_signs.hxx>
  43 #include <Objects/matlib.hxx>
  44 #include <Objects/newmat.hxx>
  45 #include <Objects/obj.hxx>
  46
  47 #include "tileentry.hxx"
  48 #include "tilemgr.hxx"
  49
  50
  51 // Constructor
  52 FGTileEntry::FGTileEntry ( const SGBucket& b )
  53     : ncount( 0 ),
  54       center( Point3D( 0.0 ) ),
  55       tile_bucket( b ),
  56       terra_transform( new ssgTransform ),
  57       rwy_lights_transform( new ssgTransform ),
  58       terra_range( new ssgRangeSelector ),
  59       rwy_lights_range( new ssgRangeSelector ),
  60       loaded(false),
  61       pending_models(0),
  62       free_tracker(0)
  63 {
  64     nodes.clear();
  65
  66     // update the contents
  67     // if ( vec3_ptrs.size() || vec2_ptrs.size() || index_ptrs.size() ) {
  68     //     SG_LOG( SG_TERRAIN, SG_ALERT,
  69     //             "Attempting to overwrite existing or"
  70     //             << " not properly freed leaf data." );
  71     //     exit(-1);
  72     // }
  73 }
  74
  75
  76 // Destructor
  77 FGTileEntry::~FGTileEntry () {
  78     // cout << "nodes = " << nodes.size() << endl;;
  79     // delete[] nodes;
  80 }
  81
  82
  83 #if 0
  84 // Please keep this for reference.  We use Norman's optimized routine,
  85 // but here is what the routine really is doing.
  86 void
  87 FGTileEntry::WorldCoordinate( sgCoord *obj_pos, Point3D center,
  88                               double lat, double lon, double elev, double hdg)
  89 {
  90     // setup transforms
  91     Point3D geod( lon * SGD_DEGREES_TO_RADIANS,
  92                   lat * SGD_DEGREES_TO_RADIANS,
  93                   elev );
  94
  95     Point3D world_pos = sgGeodToCart( geod );
  96     Point3D offset = world_pos - center;
  97
  98     sgMat4 POS;
  99     sgMakeTransMat4( POS, offset.x(), offset.y(), offset.z() );
 100
 101     sgVec3 obj_rt, obj_up;
 102     sgSetVec3( obj_rt, 0.0, 1.0, 0.0); // Y axis
 103     sgSetVec3( obj_up, 0.0, 0.0, 1.0); // Z axis
 104
 105     sgMat4 ROT_lon, ROT_lat, ROT_hdg;
 106     sgMakeRotMat4( ROT_lon, lon, obj_up );
 107     sgMakeRotMat4( ROT_lat, 90 - lat, obj_rt );
 108     sgMakeRotMat4( ROT_hdg, hdg, obj_up );
 109
 110     sgMat4 TUX;
 111     sgCopyMat4( TUX, ROT_hdg );
 112     sgPostMultMat4( TUX, ROT_lat );
 113     sgPostMultMat4( TUX, ROT_lon );
 114     sgPostMultMat4( TUX, POS );
 115
 116     sgSetCoord( obj_pos, TUX );
 117 }
 118 #endif
 119
 120
 121 // Norman's 'fast hack' for above
 122 static void WorldCoordinate( sgCoord *obj_pos, Point3D center, double lat,
 123                              double lon, double elev, double hdg )
 124 {
 125     double lon_rad = lon * SGD_DEGREES_TO_RADIANS;
 126     double lat_rad = lat * SGD_DEGREES_TO_RADIANS;
 127     double hdg_rad = hdg * SGD_DEGREES_TO_RADIANS;
 128
 129     // setup transforms
 130     Point3D geod( lon_rad, lat_rad, elev );
 131
 132     Point3D world_pos = sgGeodToCart( geod );
 133     Point3D offset = world_pos - center;
 134
 135     sgMat4 mat;
 136
 137     SGfloat sin_lat = (SGfloat)sin( lat_rad );
 138     SGfloat cos_lat = (SGfloat)cos( lat_rad );
 139     SGfloat cos_lon = (SGfloat)cos( lon_rad );
 140     SGfloat sin_lon = (SGfloat)sin( lon_rad );
 141     SGfloat sin_hdg = (SGfloat)sin( hdg_rad ) ;
 142     SGfloat cos_hdg = (SGfloat)cos( hdg_rad ) ;
 143
 144     mat[0][0] =  cos_hdg * (SGfloat)sin_lat * (SGfloat)cos_lon - sin_hdg * (SGfloat)sin_lon;
 145     mat[0][1] =  cos_hdg * (SGfloat)sin_lat * (SGfloat)sin_lon + sin_hdg * (SGfloat)cos_lon;
 146     mat[0][2] = -cos_hdg * (SGfloat)cos_lat;
 147     mat[0][3] =  SG_ZERO;
 148
 149     mat[1][0] = -sin_hdg * (SGfloat)sin_lat * (SGfloat)cos_lon - cos_hdg * (SGfloat)sin_lon;
 150     mat[1][1] = -sin_hdg * (SGfloat)sin_lat * (SGfloat)sin_lon + cos_hdg * (SGfloat)cos_lon;
 151     mat[1][2] =  sin_hdg * (SGfloat)cos_lat;
 152     mat[1][3] =  SG_ZERO;
 153
 154     mat[2][0] = (SGfloat)cos_lat * (SGfloat)cos_lon;
 155     mat[2][1] = (SGfloat)cos_lat * (SGfloat)sin_lon;
 156     mat[2][2] = (SGfloat)sin_lat;
 157     mat[2][3] =  SG_ZERO;
 158
 159     mat[3][0] = offset.x();
 160     mat[3][1] = offset.y();
 161     mat[3][2] = offset.z();
 162     mat[3][3] = SG_ONE ;
 163
 164     sgSetCoord( obj_pos, mat );
 165 }
 166
 167
 168 // recurse an ssg tree and call removeKid() on every node from the
 169 // bottom up.  Leaves the original branch in existance, but empty so
 170 // it can be removed by the calling routine.
 171 static void my_remove_branch( ssgBranch * branch ) {
 172     for ( ssgEntity *k = branch->getKid( 0 );
 173           k != NULL;
 174           k = branch->getNextKid() )
 175     {
 176         if ( k -> isAKindOf ( ssgTypeBranch() ) ) {
 177             my_remove_branch( (ssgBranch *)k );
 178             branch -> removeKid ( k );
 179         } else if ( k -> isAKindOf ( ssgTypeLeaf() ) ) {
 180             branch -> removeKid ( k ) ;
 181         }
 182     }
 183 }
 184
 185 // ADA
 186 #define TEXRES_X 256
 187 #define TEXRES_Y 256
 188 unsigned char env_map[TEXRES_X][TEXRES_Y][4];
 189 // SetColor & SetColor2 functions were provided by Christian Mayer (26 April 2001) - used without change
 190 void setColor(float x, float y, float z, float angular_size, float r,
 191 float g, float b, float a)
 192 {
 193     //normalize
 194     float inv_length = 1.0 / sqrt(x*x + y*y + z*z);
 195     x *= inv_length; y *= inv_length; z *= inv_length;
 196
 197     float cos_angular_size = cos(angular_size*SG_DEGREES_TO_RADIANS);
 198
 199     for( int s = 0; s < TEXRES_X; s++) {
 200         for( int t = 0; t < TEXRES_Y; t++) {
 201
 202             float s_2 = (float)s/TEXRES_X - 0.5; // centre of texture 0,0
 203             float t_2 = (float)t/TEXRES_Y - 0.5; // elev
 204
 205             float rx, ry, rz;
 206
 207             if ((1.0 - 4.0*s_2*s_2 - 4.0*t_2*t_2) >= 0.0) {
 208                 // sphere
 209                 float m = 4.0 * sqrt(1.0 - 4.0*s_2*s_2 - 4.0*t_2*t_2);
 210                 rx = m * s_2;
 211                 ry = m * t_2;
 212                 rz = m*m / 8.0 - 1.0;
 213             } else {
 214                 // singularity
 215                 rx = 0.0;
 216                 ry = 0.0;
 217                 rz = -1.0;
 218             }
 219
 220             float tx = rx;  //mirroring on the z=0 plane
 221             float ty = ry;  //assumes that the normal is allways
 222             float tz = -rz; //n(0.0, 0.0, 1.0)
 223
 224             if ( cos_angular_size < (x*tx + y*ty + z*tz) ) {
 225                 env_map[s][t][0] = (unsigned char) r * 255;
 226                 env_map[s][t][1] = (unsigned char) g * 255;
 227                 env_map[s][t][2] = (unsigned char) b * 255;
 228                 env_map[s][t][3] = (unsigned char) a * 255;
 229             }
 230         }
 231     }
 232 }
 233
 234 // elevation_size, float azimuth_size are the *total* angular size of the light
 235 void setColor2(float elevation_size,float azimuth_size, float r, float g, float b, float a)
 236 {
 237     for( int s = 0; s < TEXRES_X; s++) {
 238         for( int t = 0; t < TEXRES_Y; t++) {
 239             float s_2 = (float)s/TEXRES_X - 0.5;
 240             float t_2 = (float)t/TEXRES_Y - 0.5;
 241
 242             float rx, ry, rz;
 243
 244             if ((1.0 - 4.0*s_2*s_2 - 4.0*t_2*t_2) >= 0.0) {
 245
 246                 float m = 4.0 * sqrt(1.0 - 4.0*s_2*s_2 - 4.0*t_2*t_2);
 247                 rx = m * s_2;
 248                 ry = m * t_2;
 249                 rz = m*m / 8.0 - 1.0;
 250             } else {
 251                 rx = 0.0;
 252                 ry = 0.0;
 253                 rz = -1.0;
 254             }
 255
 256             float tx = rx;  //mirroring on the z=0 plane to reverse
 257             float ty = ry;  //OpenGLs automatic mirroring
 258             float tz = -rz;
 259
 260             //get elevation => project t onto the x-z-plane
 261             float tz_proj1 = tz / sqrt(tx*tx + tz*tz);
 262             float televation = acos( -tz_proj1 ) * SG_RADIANS_TO_DEGREES;
 263
 264             //get azi => project t onto the y-z-plane
 265             float tz_proj2 = tz / sqrt(ty*ty + tz*tz);
 266             float tazimuth = acos( -tz_proj2 ) * SG_RADIANS_TO_DEGREES;
 267
 268             //note televation and tazimuth are the angles *between* the
 269             //temporary vector and the normal (0,0,-1). They are *NOT*
 270             //the elevation and azimuth angles
 271
 272             //square:
 273             //if (((elevation_size > televation) || (elevation_size < -televation)) &&
 274             //    ((azimuth_size   > tazimuth  ) || (azimuth_size   < -tazimuth  )))
 275             //elliptical
 276             if (((televation*televation) / (elevation_size*elevation_size / 4.0) +
 277                  (tazimuth  *tazimuth  ) / (azimuth_size  *azimuth_size   / 4.0)) <= 1.0)
 278             {
 279                 env_map[s][t][0] = (unsigned char) r * 255;
 280                 env_map[s][t][1] = (unsigned char) g * 255;
 281                 env_map[s][t][2] = (unsigned char) b * 255;
 282                 env_map[s][t][3] = (unsigned char) a * 255;
 283             }
 284         }
 285     }
 286 }
 287
 288 // 23 March 2001
 289 // This function performs billboarding of polygons drawn using the UP and RIGHT vectors obtained
 290 // from the transpose of the MODEL_VIEW_MATRIX of the ssg_current_context. Each polygon is drawn
 291 // at the coordinate array and material state as passed thro arguments.
 292 void *fgBillboard( ssgBranch *lightmaps, ssgVertexArray *light_maps, ssgSimpleState *lightmap_state, float size) {
 293     sgMat4 tmat;
 294     sgVec3 rt, up, nrt, nup, pt, quads[4], lmaps[4];
 295
 296     ssgGetModelviewMatrix ( tmat );
 297     sgSetVec3 (rt, tmat[0][0], tmat[1][0], tmat[2][0]);
 298     sgSetVec3 (up, tmat[0][1], tmat[1][1], tmat[2][1]);
 299     sgSetVec3 (nrt, tmat[0][0], tmat[1][0], tmat[2][0]);
 300     sgSetVec3 (nup, tmat[0][1], tmat[1][1], tmat[2][1]);
 301     sgNegateVec3 (nrt);
 302     sgNegateVec3 (nup);
 303
 304     sgAddVec3 (quads[0], nrt, nup);
 305     sgAddVec3 (quads[1],  rt, nup);
 306     sgAddVec3 (quads[2],  rt,  up);
 307     sgAddVec3 (quads[3], nrt,  up);
 308
 309     sgScaleVec3 (quads[0], size);
 310     sgScaleVec3 (quads[1], size);
 311     sgScaleVec3 (quads[2], size);
 312     sgScaleVec3 (quads[3], size);
 313
 314     sgVec4 color;
 315     sgSetVec4( color, 1.0, 1.0, 0.0, 1.0 );
 316
 317     sgVec2 texcoords[4];
 318     sgSetVec2( texcoords[0], 1.0, 1.0 );
 319     sgSetVec2( texcoords[1], 0.0, 1.0 );
 320     sgSetVec2( texcoords[2], 0.0, 0.0 );
 321     sgSetVec2( texcoords[3], 1.0, 0.0 );
 322
 323     for (int j = 0; j < 4; j++ ) {
 324         sgCopyVec3(lmaps[j]     ,quads[j]);
 325     }
 326
 327     for ( int i = 0; i < light_maps->getNum(); ++i ) {
 328         // Allocate ssg structure
 329         ssgVertexArray   *vl = new ssgVertexArray( 1 );
 330         ssgTexCoordArray *tl = new ssgTexCoordArray( 1 );
 331         ssgColourArray   *cl = new ssgColourArray( 1 );
 332
 333         float *temp = light_maps->get(i);
 334         sgSetVec3(pt,temp[0],temp[1],temp[2]);
 335
 336         for (int k=0; k<4; k++) {
 337             sgAddVec3( quads[k],lmaps[k], pt );
 338             vl->add(quads[k]);
 339             tl->add(texcoords[k]);
 340             cl->add(color);
 341         }
 342
 343         ssgLeaf *leaf = NULL;
 344         leaf = new ssgVtxTable ( GL_TRIANGLE_FAN, vl, NULL, tl, cl );
 345         leaf->setState( lightmap_state );
 346         lightmaps->addKid( leaf );
 347     }
 348
 349     return NULL;
 350 }
 351
 352 ssgBranch* FGTileEntry::gen_runway_lights( ssgVertexArray *points,ssgVertexArray *normal,
 353                                            ssgVertexArray *dir, int type[])
 354 {
 355
 356     //************** HARD CODED RUNWAY LIGHT TEXTURES BEGIN ************************
 357     GLuint texEdge, texTaxi, texTouchdown;
 358     GLuint texThreshold;
 359     GLuint texVasi, texWhite, texRed, texGreen, texYellow;
 360
 361     //VASI lights
 362     setColor(0.0,0.0,1.0,360.0, 0, 0, 0, 0);
 363     setColor2(10.0, 40.0, 1, 1, 1, 1);
 364     setColor2(6.0, 40.0, 1, 0.5, 0.5, 1);
 365     setColor2(5.0, 40.0, 1, 0, 0, 1);
 366     glGenTextures(1, &texVasi);
 367     glBindTexture(GL_TEXTURE_2D, texVasi);
 368     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 369     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 370     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXRES_X, TEXRES_Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, env_map);
 371     ssgSimpleState *vasi_state;
 372     vasi_state = new ssgSimpleState();
 373     vasi_state->ref();
 374     vasi_state->setTexture( texVasi );
 375     vasi_state->disable( GL_LIGHTING );
 376     vasi_state->enable( GL_TEXTURE_2D );
 377     vasi_state->setShadeModel( GL_SMOOTH );
 378
 379     //EDGE
 380     setColor(0.0,0.0,-1.0,180.0, 1, 1, 0.5, 1);
 381     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 382     glGenTextures(1, &texEdge);
 383     glBindTexture(GL_TEXTURE_2D, texEdge);
 384     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 385     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 386     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXRES_X, TEXRES_Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, env_map);
 387     ssgSimpleState *edge_state;
 388     edge_state = new ssgSimpleState();
 389     edge_state->ref();
 390     edge_state->setTexture( texEdge );
 391     edge_state->disable( GL_LIGHTING );
 392     edge_state->enable( GL_TEXTURE_2D );
 393     edge_state->setShadeModel( GL_SMOOTH );
 394
 395     //TOUCHDOWN
 396     setColor(0.0,0.0,-1.0,180.0, 0, 1, 0, 1);
 397     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 398     glGenTextures(1, &texTouchdown);
 399     glBindTexture(GL_TEXTURE_2D, texTouchdown);
 400     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 401     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 402     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXRES_X, TEXRES_Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, env_map);
 403     ssgSimpleState *touchdown_state;
 404     touchdown_state = new ssgSimpleState();
 405     touchdown_state->ref();
 406     touchdown_state->setTexture( texTouchdown );
 407     touchdown_state->disable( GL_LIGHTING );
 408     touchdown_state->enable( GL_TEXTURE_2D );
 409     touchdown_state->setShadeModel( GL_SMOOTH );
 410
 411     //THRESHOLD
 412     setColor(0.0,0.0,-1.0,180.0, 1, 0, 0, 1);
 413     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 414     glGenTextures(1, &texThreshold);
 415     glBindTexture(GL_TEXTURE_2D, texThreshold);
 416     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 417     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 418     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXRES_X, TEXRES_Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, env_map);
 419     ssgSimpleState *threshold_state;
 420     threshold_state = new ssgSimpleState();
 421     threshold_state->ref();
 422     threshold_state->setTexture( texThreshold );
 423     threshold_state->disable( GL_LIGHTING );
 424     threshold_state->enable( GL_TEXTURE_2D );
 425     threshold_state->setShadeModel( GL_SMOOTH );
 426
 427     //TAXI
 428     setColor(0.0,0.0,-1.0,180.0, 0, 0, 1, 1);
 429     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 430     glGenTextures(1, &texTaxi);
 431     glBindTexture(GL_TEXTURE_2D, texTaxi);
 432     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 433     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 434     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXRES_X, TEXRES_Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, env_map);
 435     ssgSimpleState *taxi_state;
 436     taxi_state = new ssgSimpleState();
 437     taxi_state->ref();
 438     taxi_state->setTexture( texTaxi );
 439     taxi_state->disable( GL_LIGHTING );
 440     taxi_state->enable( GL_TEXTURE_2D );
 441     taxi_state->setShadeModel( GL_SMOOTH );
 442
 443     //WHITE
 444     setColor(0.0,0.0,-1.0,180.0, 1, 1, 1, 1);
 445     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 446     glGenTextures(1, &texWhite);
 447     glBindTexture(GL_TEXTURE_2D, texWhite);
 448     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 449     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 450     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXRES_X, TEXRES_Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, env_map);
 451     ssgSimpleState *white_state;
 452     white_state = new ssgSimpleState();
 453     white_state->ref();
 454     white_state->setTexture( texWhite );
 455     white_state->disable( GL_LIGHTING );
 456     white_state->enable( GL_TEXTURE_2D );
 457     white_state->setShadeModel( GL_SMOOTH );
 458
 459     //RED
 460     setColor(0.0,0.0,-1.0,180.0, 1, 0, 0, 1);
 461     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 462     glGenTextures(1, &texRed);
 463     glBindTexture(GL_TEXTURE_2D, texRed);
 464     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 465     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 466     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXRES_X, TEXRES_Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, env_map);
 467     ssgSimpleState *red_state;
 468     red_state = new ssgSimpleState();
 469     red_state->ref();
 470     red_state->setTexture( texRed );
 471     red_state->disable( GL_LIGHTING );
 472     red_state->enable( GL_TEXTURE_2D );
 473     red_state->setShadeModel( GL_SMOOTH );
 474
 475     //GREEN
 476     setColor(0.0,0.0,-1.0,180.0, 0, 1, 0, 1);
 477     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 478     glGenTextures(1, &texGreen);
 479     glBindTexture(GL_TEXTURE_2D, texGreen);
 480     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 481     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 482     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXRES_X, TEXRES_Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, env_map);
 483     ssgSimpleState *green_state;
 484     green_state = new ssgSimpleState();
 485     green_state->ref();
 486     green_state->setTexture( texGreen );
 487     green_state->disable( GL_LIGHTING );
 488     green_state->enable( GL_TEXTURE_2D );
 489     green_state->setShadeModel( GL_SMOOTH );
 490
 491     //YELLOW
 492     setColor(0.0,0.0,-1.0,180.0, 1, 1, 0, 1);
 493     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 494     glGenTextures(1, &texYellow);
 495     glBindTexture(GL_TEXTURE_2D, texYellow);
 496     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 497     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 498     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXRES_X, TEXRES_Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, env_map);
 499     ssgSimpleState *yellow_state;
 500     yellow_state = new ssgSimpleState();
 501     yellow_state->ref();
 502     yellow_state->setTexture( texYellow );
 503     yellow_state->disable( GL_LIGHTING );
 504     yellow_state->enable( GL_TEXTURE_2D );
 505     yellow_state->setShadeModel( GL_SMOOTH );
 506 //************** HARD CODED RUNWAY LIGHT TEXTURES END ************************
 507
 508     ssgBranch *runway_lights = new ssgBranch;
 509     sgVec3 v2,v3,inf,side;
 510
 511     ssgLeaf *leaf1 = NULL;
 512     ssgLeaf *leaf2 = NULL;
 513     ssgLeaf *leaf7 = NULL;
 514     ssgLeaf *leaf8 = NULL;
 515     ssgLeaf *leaf9 = NULL;
 516
 517     ssgVertexArray   *vlw = new ssgVertexArray( 1 );
 518     ssgNormalArray   *nlw = new ssgNormalArray( 1 );
 519     ssgVertexArray   *vlt = new ssgVertexArray( 1 );
 520     ssgNormalArray   *nlt = new ssgNormalArray( 1 );
 521     ssgVertexArray   *vlr = new ssgVertexArray( 1 );
 522     ssgNormalArray   *nlr = new ssgNormalArray( 1 );
 523     ssgVertexArray   *vlg = new ssgVertexArray( 1 );
 524     ssgNormalArray   *nlg = new ssgNormalArray( 1 );
 525     ssgVertexArray   *vly = new ssgVertexArray( 1 );
 526     ssgNormalArray   *nly = new ssgNormalArray( 1 );
 527
 528     for ( int i = 0; i < points->getNum()-1; i=i++ ) {
 529
 530         // Allocate ssg structure
 531         ssgVertexArray   *vl = new ssgVertexArray( 1 );
 532         ssgNormalArray   *nl = new ssgNormalArray( 1 );
 533         ssgVertexArray   *vl1 = new ssgVertexArray( 1 );
 534         ssgNormalArray   *nl1 = new ssgNormalArray( 1 );
 535
 536         float *n1 = normal->get(i);
 537         float *d1 = dir->get(i);
 538
 539         /* TEMPORARY CODE BEGIN
 540            // calculate normal using 1st, 2nd & last vertices of the group
 541            sgVec3 n1;
 542            sgMakeNormal (n1, points->get(0), points->get(1), points->get(points->getNum()-1) );
 543            sgVec3 d1;
 544            sgSubVec3(d1,points->get(1),points->get(0));
 545            printf("%f %f %f\n",n1[0],n1[1],n1[2]);
 546            printf("%f %f %f\n",d1[0],d1[1],d1[2]);
 547            type[i] = 2;
 548            ----TEMPORARY CODE END */
 549
 550
 551         sgNormaliseVec3 ( n1 );
 552         sgNormaliseVec3 ( d1 );
 553         sgVec3 d2;
 554         d2[0] = -d1[0];
 555         d2[1] = -d1[1];
 556         d2[2] = -d1[2];
 557
 558         sgVectorProductVec3(side,n1,d1);
 559         sgScaleVec3 (inf,n1,-50);
 560         sgScaleVec3 (side,5);
 561
 562         float *v1 = points->get(i);
 563         sgAddVec3(v2,v1,inf);
 564         sgAddVec3(v3,v2,side);
 565
 566         if ( type[i] == 1) {        //POINT,WHITE
 567
 568             vlw->add(v1);
 569             nlw->add(d1);
 570
 571         } else if (type[i] == 2) {  //POINT,TAXI
 572
 573             vlt->add(v1);
 574             nlt->add(d1);
 575
 576         } else if (type[i] == 3) {  //SINGLE POLYGON,VASI
 577
 578             vl->add(v1);
 579             nl->add(d1);
 580             vl->add(v3);
 581             nl->add(d1);
 582             vl->add(v2);
 583             nl->add(d1);
 584
 585             ssgLeaf *leaf3 = NULL;
 586             leaf3 = new ssgVtxTable ( GL_POLYGON, vl, nl, NULL, NULL );
 587             leaf3->setState( vasi_state );
 588             runway_lights->addKid( leaf3 );
 589
 590         } else if (type[i] == 4) {  //BACK-TO-BACK POLYGONS,TOUCHDOWN/THRESHOLD
 591
 592             vl->add(v1);
 593             nl->add(d1);
 594             vl->add(v3);
 595             nl->add(d1);
 596             vl->add(v2);
 597             nl->add(d1);
 598
 599             vl1->add(v3);
 600             nl1->add(d2);
 601             vl1->add(v1);
 602             nl1->add(d2);
 603             vl1->add(v2);
 604             nl1->add(d2);
 605
 606             ssgLeaf *leaf41 = NULL;
 607             leaf41 = new ssgVtxTable ( GL_POLYGON, vl, nl, NULL, NULL );
 608             leaf41->setState( touchdown_state );
 609             runway_lights->addKid( leaf41 );
 610
 611             ssgLeaf *leaf42 = NULL;
 612             leaf42 = new ssgVtxTable ( GL_POLYGON, vl1, nl1, NULL, NULL );
 613             leaf42->setState( threshold_state );
 614             runway_lights->addKid( leaf42 );
 615
 616         } else if ( type[i] == 5) {        //POINT,WHITE, SEQUENCE LIGHTS (RABBIT)
 617
 618             vl->add(v1);
 619             nl->add(d1);
 620             ssgLeaf *leaf5 = NULL;
 621             leaf5 = new ssgVtxTable ( GL_POINTS, vl, nl, NULL, NULL );
 622             leaf5->setState( white_state );
 623             lightmaps_sequence->addKid (leaf5);
 624
 625         } else if ( type[i] == 6) {        //POINT,WHITE, SEQUENCE LIGHTS (RABBIT)
 626
 627             vl->add(v1);
 628             nl->add(d1);
 629             ssgLeaf *leaf6 = NULL;
 630             leaf6 = new ssgVtxTable ( GL_POINTS, vl, nl, NULL, NULL );
 631             leaf6->setState( yellow_state );
 632             ols_transform->addKid (leaf6);
 633             // DO NOT DELETE THIS CODE - This is to compare a discrete FLOLS (without LOD) with analog FLOLS
 634             //                  lightmaps_sequence->addKid (leaf6);
 635             // DO NOT DELETE THIS CODE - This is to compare a discrete FLOLS (without LOD) with analog FLOLS
 636
 637         } else if (type[i] == 7) {  //POINT,RED
 638
 639             vlr->add(v1);
 640             nlr->add(d1);
 641
 642         } else if (type[i] == 8) {  //POINT,GREEN
 643
 644             vlg->add(v1);
 645             nlg->add(d1);
 646
 647         } else if (type[i] == 9) {  //POINT,YELLOW
 648
 649             vly->add(v1);
 650             nly->add(d1);
 651
 652         }
 653
 654     }
 655
 656     leaf1 = new ssgVtxTable ( GL_POINTS, vlw, nlw, NULL, NULL );
 657     leaf1->setState( white_state );
 658     runway_lights->addKid( leaf1 );
 659
 660     leaf2 = new ssgVtxTable ( GL_POINTS, vlt, nlt, NULL, NULL );
 661     leaf2->setState( taxi_state );
 662     runway_lights->addKid( leaf2 );
 663
 664     leaf7 = new ssgVtxTable ( GL_POINTS, vlr, nlr, NULL, NULL );
 665     leaf7->setState( red_state );
 666     runway_lights->addKid( leaf7 );
 667
 668     leaf8 = new ssgVtxTable ( GL_POINTS, vlg, nlg, NULL, NULL );
 669     leaf8->setState( green_state );
 670     // DO NOT DELETE THIS CODE - This is to compare a discrete FLOLS (without LOD) with analog FLOLS
 671     ols_transform->ref();
 672     lightmaps_sequence->addKid (ols_transform);
 673     // DO NOT DELETE THIS CODE - This is to compare a discrete FLOLS (without LOD) with analog FLOLS
 674     lightmaps_sequence->addKid (leaf8);
 675
 676     leaf9 = new ssgVtxTable ( GL_POINTS, vly, nly, NULL, NULL );
 677     leaf9->setState( yellow_state );
 678     runway_lights->addKid( leaf9 );
 679
 680     lightmaps_sequence->select(0xFFFFFF);
 681     return runway_lights;
 682 }
 683 // ADA
 684
 685 #ifdef WISH_PLIB_WAS_THREADED // but it isn't
 686
 687 // Schedule tile to be freed/removed
 688 void FGTileEntry::sched_removal() {
 689     global_tile_mgr.ready_to_delete( this );
 690 }
 691
 692 #endif
 693
 694
 695 // Free "n" leaf elements of an ssg tree.  returns the number of
 696 // elements freed.  An empty branch node is considered a leaf.  This
 697 // is intended to spread the load of freeing a complex tile out over
 698 // several frames.
 699 static int fgPartialFreeSSGtree( ssgBranch *b, int n ) {
 700     if ( n > 0 ) {
 701         // we still have some delete budget left
 702         int num_deletes = 0;
 703         for ( int i = 0; i < b->getNumKids(); ++i ) {
 704             ssgEntity *kid = b->getKid(i);
 705             if ( kid->isAKindOf( ssgTypeBranch() ) && kid->getRef() <= 1 ) {
 706                 int result = fgPartialFreeSSGtree( (ssgBranch *)kid, n );
 707                 num_deletes += result;
 708                 n -= result;
 709                 if ( kid->getNumKids() == 0 ) {
 710                     b->removeKid(i);
 711                     num_deletes++;
 712                     n--;
 713                 }
 714                 if ( n < 0 ) {
 715                     break;
 716                 }
 717             } else {
 718                 b->removeKid(i);
 719                 num_deletes++;
 720             }
 721         }
 722         return num_deletes;
 723     } else {
 724         return 0;
 725     }
 726 }
 727
 728
 729 // Clean up the memory used by this tile and delete the arrays used by
 730 // ssg as well as the whole ssg branch
 731 bool FGTileEntry::free_tile() {
 732     int i;
 733     int delete_size = 100;
 734     SG_LOG( SG_TERRAIN, SG_DEBUG,
 735             "FREEING TILE = (" << tile_bucket << ")" );
 736
 737     if ( !(free_tracker & NODES) ) {
 738         SG_LOG( SG_TERRAIN, SG_DEBUG,
 739                 "  deleting " << nodes.size() << " nodes" );
 740         nodes.clear();
 741
 742         free_tracker |= NODES;
 743     } else if ( !(free_tracker & VEC_PTRS) ) {
 744         // delete the vector pointers
 745         SG_LOG( SG_TERRAIN, SG_DEBUG,
 746                 "  deleting (leaf data) vertex, normal, and "
 747                 << " texture coordinate arrays" );
 748
 749         for ( i = 0; i < (int)vec3_ptrs.size(); ++i ) {
 750             delete [] vec3_ptrs[i];
 751         }
 752         vec3_ptrs.clear();
 753
 754         for ( i = 0; i < (int)vec2_ptrs.size(); ++i ) {
 755             delete [] vec2_ptrs[i];
 756         }
 757         vec2_ptrs.clear();
 758
 759         for ( i = 0; i < (int)index_ptrs.size(); ++i ) {
 760             delete index_ptrs[i];
 761         }
 762         index_ptrs.clear();
 763
 764         free_tracker |= VEC_PTRS;
 765     } else if ( !(free_tracker & TERRA_NODE) ) {
 766         // delete the terrain branch (this should already have been
 767         // disconnected from the scene graph)
 768         SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING terra_transform" );
 769         if ( fgPartialFreeSSGtree( terra_transform, delete_size ) == 0 ) {
 770             ssgDeRefDelete( terra_transform ); // polish off the parent
 771             free_tracker |= TERRA_NODE;
 772         }
 773     } else if ( !(free_tracker & GROUND_LIGHTS) && gnd_lights_transform ) {
 774         // delete the terrain lighting branch (this should already have been
 775         // disconnected from the scene graph)
 776         SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING gnd_lights_transform" );
 777         if ( fgPartialFreeSSGtree( gnd_lights_transform, delete_size ) == 0 ) {
 778             ssgDeRefDelete( gnd_lights_transform ); // polish off the parent
 779             free_tracker |= GROUND_LIGHTS;
 780         }
 781     } else if ( !(free_tracker & RWY_LIGHTS) && rwy_lights_transform ) {
 782         // delete the terrain lighting branch (this should already have been
 783         // disconnected from the scene graph)
 784         SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING rwy_lights_transform" );
 785         if ( fgPartialFreeSSGtree( rwy_lights_transform, delete_size ) == 0 ) {
 786             ssgDeRefDelete( rwy_lights_transform ); // polish off the parent
 787             free_tracker |= RWY_LIGHTS;
 788         }
 789     } else if ( !(free_tracker & LIGHTMAPS) && lightmaps_transform ) {
 790         // ADA
 791         // delete the terrain lighting branch (this should already have been
 792         // disconnected from the scene graph)
 793         SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING lightmaps_transform" );
 794         if ( fgPartialFreeSSGtree( lightmaps_transform, delete_size ) == 0 ) {
 795             ssgDeRefDelete( lightmaps_transform ); // polish off the parent
 796             free_tracker |= LIGHTMAPS;
 797         }
 798     } else {
 799         return true;
 800     }
 801
 802     // if we fall down to here, we still have work todo, return false
 803     return false;
 804 }
 805
 806
 807 // Update the ssg transform node for this tile so it can be
 808 // properly drawn relative to our (0,0,0) point
 809 void FGTileEntry::prep_ssg_node( const Point3D& p, sgVec3 up, float vis) {
 810     if ( !loaded ) return;
 811
 812     SetOffset( p );
 813
 814 // #define USE_UP_AND_COMING_PLIB_FEATURE
 815 #ifdef USE_UP_AND_COMING_PLIB_FEATURE
 816     terra_range->setRange( 0, SG_ZERO );
 817     terra_range->setRange( 1, vis + bounding_radius );
 818     if ( gnd_lights_range ) {
 819     gnd_lights_range->setRange( 0, SG_ZERO );
 820     gnd_lights_range->setRange( 1, vis * 1.5 + bounding_radius );
 821     }
 822     if ( rwy_lights_range ) {
 823       rwy_lights_range->setRange( 0, SG_ZERO );
 824       rwy_lights_range->setRange( 1, vis * 1.5 + bounding_radius );
 825     }
 826 #else
 827     float ranges[2];
 828     ranges[0] = SG_ZERO;
 829     ranges[1] = vis + bounding_radius;
 830     terra_range->setRanges( ranges, 2 );
 831     if ( gnd_lights_range ) {
 832         ranges[1] = vis * 1.5 + bounding_radius;
 833         gnd_lights_range->setRanges( ranges, 2 );
 834     }
 835     if ( rwy_lights_range ) {
 836         ranges[1] = vis * 1.5 + bounding_radius;
 837         rwy_lights_range->setRanges( ranges, 2 );
 838     }
 839 #endif
 840     sgVec3 sgTrans;
 841     sgSetVec3( sgTrans, offset.x(), offset.y(), offset.z() );
 842     terra_transform->setTransform( sgTrans );
 843
 844     if ( gnd_lights_transform ) {
 845         // we need to lift the lights above the terrain to avoid
 846         // z-buffer fighting.  We do this based on our altitude and
 847         // the distance this tile is away from scenery center.
 848
 849         // we expect 'up' to be a unit vector coming in, but since we
 850         // modify the value of lift_vec, we need to create a local
 851         // copy.
 852         sgVec3 lift_vec;
 853         sgCopyVec3( lift_vec, up );
 854
 855         double agl;
 856         agl = globals->get_current_view()->getAltitudeASL_ft()
 857             * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev();
 858
 859         // sgTrans just happens to be the
 860         // vector from scenery center to the center of this tile which
 861         // is what we want to calculate the distance of
 862         sgVec3 to;
 863         sgCopyVec3( to, sgTrans );
 864         double dist = sgLengthVec3( to );
 865
 866         if ( general.get_glDepthBits() > 16 ) {
 867             sgScaleVec3( lift_vec, 10.0 + agl / 100.0 + dist / 10000 );
 868         } else {
 869             sgScaleVec3( lift_vec, 10.0 + agl / 20.0 + dist / 5000 );
 870         }
 871
 872         sgVec3 lt_trans;
 873         sgCopyVec3( lt_trans, sgTrans );
 874
 875         sgAddVec3( lt_trans, lift_vec );
 876         gnd_lights_transform->setTransform( lt_trans );
 877
 878         // select which set of lights based on sun angle
 879         float sun_angle = cur_light_params.sun_angle * SGD_RADIANS_TO_DEGREES;
 880         if ( sun_angle > 95 ) {
 881             gnd_lights_brightness->select(0x04);
 882         } else if ( sun_angle > 92 ) {
 883             gnd_lights_brightness->select(0x02);
 884         } else if ( sun_angle > 89 ) {
 885             gnd_lights_brightness->select(0x01);
 886         } else {
 887             gnd_lights_brightness->select(0x00);
 888         }
 889     }
 890
 891     if ( rwy_lights_transform ) {
 892         // we need to lift the lights above the terrain to avoid
 893         // z-buffer fighting.  We do this based on our altitude and
 894         // the distance this tile is away from scenery center.
 895
 896         sgVec3 lift_vec;
 897         sgCopyVec3( lift_vec, up );
 898
 899         double agl;
 900         agl = globals->get_current_view()->getAltitudeASL_ft()
 901             * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev();
 902
 903         // sgTrans just happens to be the
 904         // vector from scenery center to the center of this tile which
 905         // is what we want to calculate the distance of
 906         sgVec3 to;
 907         sgCopyVec3( to, sgTrans );
 908         double dist = sgLengthVec3( to );
 909
 910         if ( general.get_glDepthBits() > 16 ) {
 911             sgScaleVec3( lift_vec, 0.0 + agl / 100.0 + dist / 10000 );
 912         } else {
 913             sgScaleVec3( lift_vec, 1.0 + agl / 20.0 + dist / 5000 );
 914         }
 915
 916         sgVec3 lt_trans;
 917         sgCopyVec3( lt_trans, sgTrans );
 918
 919         sgAddVec3( lt_trans, lift_vec );
 920         rwy_lights_transform->setTransform( lt_trans );
 921
 922         // select which set of lights based on sun angle
 923         // float sun_angle = cur_light_params.sun_angle * SGD_RADIANS_TO_DEGREES;
 924         // if ( sun_angle > 95 ) {
 925         //     gnd_lights_brightness->select(0x04);
 926         // } else if ( sun_angle > 92 ) {
 927         //     gnd_lights_brightness->select(0x02);
 928         // } else if ( sun_angle > 89 ) {
 929         //     gnd_lights_brightness->select(0x01);
 930         // } else {
 931         //     gnd_lights_brightness->select(0x00);
 932         // }
 933     }
 934
 935     // ADA
 936     // Transform & Render runway lights - 23 Mar 2001
 937     sgSetVec3( sgTrans, offset.x(), offset.y(), offset.z() );
 938     if ( lightmaps_transform ) {
 939         static unsigned int selectnode = 0;
 940         // Run-time extension check.
 941         if (!glutExtensionSupported("GL_EXT_point_parameters")) {
 942             //use lightmaps on billboarded polygons
 943         } else {
 944             // using GL_EXT_point_parameters
 945
 946             // This part is same as ground-lights code above by Curt
 947             sgVec3 lift_vec;
 948             sgCopyVec3( lift_vec, up );
 949
 950             double agl1;
 951             agl1 = globals->get_current_view()->getAltitudeASL_ft()
 952                 * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev();
 953
 954             // sgTrans just happens to be the
 955             // vector from scenery center to the center of this tile which
 956             // is what we want to calculate the distance of
 957             sgVec3 to1;
 958             sgCopyVec3( to1, sgTrans );
 959             double dist1 = sgLengthVec3( to1 );
 960
 961             if ( general.get_glDepthBits() > 16 ) {
 962                 sgScaleVec3( lift_vec, 0.0 + agl1 / 2000.0 + dist1 / 10000 );
 963             } else {
 964                 sgScaleVec3( lift_vec, 0.0 + agl1 / 20.0 + dist1 / 5000 );
 965             }
 966             sgAddVec3( sgTrans, lift_vec );
 967             lightmaps_transform->setTransform( sgTrans );
 968
 969             float sun_angle1 = cur_light_params.sun_angle * SGD_RADIANS_TO_DEGREES;
 970             if ( (sun_angle1 > 89) ) {
 971                 lightmaps_brightness->select(0x01);
 972                 selectnode *=2;
 973                 selectnode = selectnode | 0x000001;
 974                 if (selectnode > 0xFFFFFF) selectnode = 1;
 975                 lightmaps_sequence->select(selectnode);
 976             } else {
 977                 lightmaps_brightness->select(0x00);
 978                 lightmaps_sequence->select(0x000000);
 979             }
 980         } // end of GL_EXT_point_parameters section
 981
 982     } // end of runway lights section
 983     // ADA
 984
 985 }
 986
 987
 988 // Set up lights rendering call backs
 989 static int fgLightsPredraw( ssgEntity *e ) {
 990 #if 0
 991 #ifdef GL_EXT_point_parameters
 992     if (glutExtensionSupported("GL_EXT_point_parameters")) {
 993         static float quadratic[3] = {1.0, 0.01, 0.0001};
 994         glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, quadratic);
 995         glPointParameterfEXT(GL_POINT_SIZE_MIN_EXT, 1.0);
 996         glPointSize(4.0);
 997     }
 998 #endif
 999 #endif
1000     return true;
1001 }
1002
1003 static int fgLightsPostdraw( ssgEntity *e ) {
1004 #if 0
1005 #ifdef GL_EXT_point_parameters
1006     if (glutExtensionSupported("GL_EXT_point_parameters")) {
1007         static float default_attenuation[3] = {1.0, 0.0, 0.0};
1008         glPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT,
1009                               default_attenuation);
1010         glPointSize(1.0);
1011     }
1012 #endif
1013 #endif
1014     return true;
1015 }
1016
1017
1018 ssgLeaf* FGTileEntry::gen_lights( ssgVertexArray *lights, int inc, float bright ) {
1019     // generate a repeatable random seed
1020     float *p1 = lights->get( 0 );
1021     unsigned int *seed = (unsigned int *)p1;
1022     sg_srandom( *seed );
1023
1024     int size = lights->getNum() / inc;
1025
1026     // Allocate ssg structure
1027     ssgVertexArray   *vl = new ssgVertexArray( size + 1 );
1028     ssgNormalArray   *nl = NULL;
1029     ssgTexCoordArray *tl = NULL;
1030     ssgColourArray   *cl = new ssgColourArray( size + 1 );
1031
1032     sgVec4 color;
1033     for ( int i = 0; i < lights->getNum(); ++i ) {
1034         // this loop is slightly less efficient than it otherwise
1035         // could be, but we want a red light to always be red, and a
1036         // yellow light to always be yellow, etc. so we are trying to
1037         // preserve the random sequence.
1038         float zombie = sg_random();
1039         if ( i % inc == 0 ) {
1040             vl->add( lights->get(i) );
1041
1042             // factor = sg_random() ^ 2, range = 0 .. 1 concentrated towards 0
1043             float factor = sg_random();
1044             factor *= factor;
1045
1046             if ( zombie > 0.5 ) {
1047                 // 50% chance of yellowish
1048                 sgSetVec4( color, 0.9, 0.9, 0.3, bright - factor * 0.2 );
1049             } else if ( zombie > 0.15 ) {
1050                 // 35% chance of whitish
1051                 sgSetVec4( color, 0.9, 0.9, 0.8, bright - factor * 0.2 );
1052             } else if ( zombie > 0.05 ) {
1053                 // 10% chance of orangish
1054                 sgSetVec4( color, 0.9, 0.6, 0.2, bright - factor * 0.2 );
1055             } else {
1056                 // 5% chance of redish
1057                 sgSetVec4( color, 0.9, 0.2, 0.2, bright - factor * 0.2 );
1058             }
1059             cl->add( color );
1060         }
1061     }
1062
1063     // create ssg leaf
1064     ssgLeaf *leaf =
1065         new ssgVtxTable ( GL_POINTS, vl, nl, tl, cl );
1066
1067     // assign state
1068     FGNewMat *newmat = material_lib.find( "LIGHTS" );
1069     leaf->setState( newmat->get_state() );
1070     leaf->setCallback( SSG_CALLBACK_PREDRAW, fgLightsPredraw );
1071     leaf->setCallback( SSG_CALLBACK_POSTDRAW, fgLightsPostdraw );
1072
1073     return leaf;
1074 }
1075
1076
1077 bool FGTileEntry::obj_load( const std::string& path,
1078                        ssgBranch* geometry,
1079                        ssgBranch* rwy_lights,
1080                        ssgVertexArray* ground_lights, bool is_base )
1081 {
1082     Point3D c;                  // returned center point
1083     double br;                  // returned bounding radius
1084
1085     // try loading binary format
1086     if ( fgBinObjLoad( path, is_base,
1087                        &c, &br, geometry, rwy_lights, ground_lights ) )
1088     {
1089         if ( is_base ) {
1090             center = c;
1091             bounding_radius = br;
1092         }
1093     } else {
1094         // next try the older ascii format, this is some ugly
1095         // weirdness because the ascii loader is *old* and hasn't been
1096         // updated, but hopefully we can can the ascii format soon.
1097         ssgBranch *tmp = fgAsciiObjLoad( path, this, ground_lights, is_base );
1098         if ( tmp ) {
1099             return (NULL != tmp);
1100         } else {
1101             // default to an ocean tile
1102             if ( fgGenTile( path, tile_bucket, &c, &br, geometry ) ) {
1103                 center = c;
1104                 bounding_radius = br;
1105             } else {
1106                 SG_LOG( SG_TERRAIN, SG_ALERT,
1107                         "Warning: failed to generate ocean tile!" );
1108             }
1109         }
1110     }
1111
1112     return (NULL != geometry);
1113 }
1114
1115
1116 void
1117 FGTileEntry::load( const SGPath& base, bool is_base )
1118 {
1119     SG_LOG( SG_TERRAIN, SG_INFO, "load() base = " << base.str() );
1120
1121     // Generate names for later use
1122     string index_str = tile_bucket.gen_index_str();
1123
1124     SGPath tile_path = base;
1125     tile_path.append( tile_bucket.gen_base_path() );
1126
1127     SGPath basename = tile_path;
1128     basename.append( index_str );
1129     // string path = basename.str();
1130
1131     SG_LOG( SG_TERRAIN, SG_INFO, "Loading tile " << basename.str() );
1132
1133 #define FG_MAX_LIGHTS 1000
1134
1135     // obj_load() will generate ground lighting for us ...
1136     ssgVertexArray *light_pts = new ssgVertexArray( 100 );
1137
1138     // ADA
1139     ssgVertexArray *lights_rway = new ssgVertexArray( 100 );
1140     ssgVertexArray *lights_dir = new ssgVertexArray( 100 );
1141     ssgVertexArray *lights_normal = new ssgVertexArray( 100 );
1142     int lights_type[FG_MAX_LIGHTS];
1143     // ADA
1144
1145     ssgBranch* new_tile = new ssgBranch;
1146
1147     // Check for master .stg (scene terra gear) file
1148     SGPath stg_name = basename;
1149     stg_name.concat( ".stg" );
1150
1151     sg_gzifstream in( stg_name.str() );
1152
1153     if ( in.is_open() ) {
1154         string token, name;
1155
1156         while ( ! in.eof() ) {
1157             in >> token;
1158
1159             if ( token == "OBJECT_BASE" ) {
1160                 in >> name >> ::skipws;
1161                 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
1162                         << " name = " << name );
1163
1164                 SGPath custom_path = tile_path;
1165                 custom_path.append( name );
1166
1167                 ssgBranch *geometry = new ssgBranch;
1168                 if ( obj_load( custom_path.str(),
1169                                geometry, NULL, light_pts, true ) )
1170                 {
1171                     new_tile -> addKid( geometry );
1172                 } else {
1173                     delete geometry;
1174                 }
1175             } else if ( token == "OBJECT" ) {
1176                 in >> name >> ::skipws;
1177                 SG_LOG( SG_TERRAIN, SG_DEBUG, "token = " << token
1178                         << " name = " << name );
1179
1180                 SGPath custom_path = tile_path;
1181                 custom_path.append( name );
1182
1183                 ssgBranch *geometry = new ssgBranch;
1184                 ssgBranch *rwy_lights = new ssgBranch;
1185                 if ( obj_load( custom_path.str(),
1186                                geometry, rwy_lights, NULL, false ) )
1187                 {
1188                     if ( geometry -> getNumKids() > 0 ) {
1189                         new_tile -> addKid( geometry );
1190                     } else {
1191                         delete geometry;
1192                     }
1193                     if ( rwy_lights -> getNumKids() > 0 ) {
1194                         rwy_lights_range -> addKid( rwy_lights );
1195                     } else {
1196                         delete rwy_lights;
1197                     }
1198                 } else {
1199                     delete geometry;
1200                     delete rwy_lights;
1201                 }
1202
1203             } else if ( token == "OBJECT_STATIC" ) {
1204                 // load object info
1205                 double lon, lat, elev, hdg;
1206                 in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
1207                 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
1208                         << " name = " << name
1209                         << " pos = " << lon << ", " << lat
1210                         << " elevation = " << elev
1211                         << " heading = " << hdg );
1212
1213                 // object loading is deferred to main render thread,
1214                 // but lets figure out the paths right now.
1215                 SGPath custom_path = tile_path;
1216                 custom_path.append( name );
1217
1218                 sgCoord obj_pos;
1219                 WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
1220
1221                 ssgTransform *obj_trans = new ssgTransform;
1222                 obj_trans->setTransform( &obj_pos );
1223
1224                 // wire as much of the scene graph together as we can
1225                 new_tile->addKid( obj_trans );
1226
1227                 // bump up the pending models count
1228                 pending_models++;
1229
1230                 // push an entry onto the model load queue
1231                 FGDeferredModel *dm
1232                     = new FGDeferredModel( custom_path.str(), tile_path.str(),
1233                                            this, obj_trans );
1234                 FGTileMgr::model_ready( dm );
1235             } else if ( token == "OBJECT_TAXI_SIGN" ) {
1236                 // load object info
1237                 double lon, lat, elev, hdg;
1238                 in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
1239                 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
1240                         << " name = " << name
1241                         << " pos = " << lon << ", " << lat
1242                         << " elevation = " << elev
1243                         << " heading = " << hdg );
1244
1245                 // load the object itself
1246                 SGPath custom_path = tile_path;
1247                 custom_path.append( name );
1248
1249                 sgCoord obj_pos;
1250                 WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
1251
1252                 ssgTransform *obj_trans = new ssgTransform;
1253                 obj_trans->setTransform( &obj_pos );
1254
1255                 ssgBranch *custom_obj
1256                     = gen_taxi_sign( custom_path.str(), name );
1257
1258                 // wire the pieces together
1259                 if ( custom_obj != NULL ) {
1260                     obj_trans -> addKid( custom_obj );
1261                 }
1262                 new_tile->addKid( obj_trans );
1263             } else if ( token == "OBJECT_RUNWAY_SIGN" ) {
1264                 // load object info
1265                 double lon, lat, elev, hdg;
1266                 in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
1267                 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
1268                         << " name = " << name
1269                         << " pos = " << lon << ", " << lat
1270                         << " elevation = " << elev
1271                         << " heading = " << hdg );
1272
1273                 // load the object itself
1274                 SGPath custom_path = tile_path;
1275                 custom_path.append( name );
1276
1277                 sgCoord obj_pos;
1278                 WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
1279
1280                 ssgTransform *obj_trans = new ssgTransform;
1281                 obj_trans->setTransform( &obj_pos );
1282
1283                 ssgBranch *custom_obj
1284                     = gen_runway_sign( custom_path.str(), name );
1285
1286                 // wire the pieces together
1287                 if ( custom_obj != NULL ) {
1288                     obj_trans -> addKid( custom_obj );
1289                 }
1290                 new_tile->addKid( obj_trans );
1291             } else if ( token == "RWY_LIGHTS" ) {
1292                 double lon, lat, hdg, len, width;
1293                 string common, end1, end2;
1294                 in >> lon >> lat >> hdg >> len >> width
1295                    >> common >> end1 >> end2;
1296                 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
1297                         << " pos = " << lon << ", " << lat
1298                         << " hdg = " << hdg
1299                         << " size = " << len << ", " << width
1300                         << " codes = " << common << " "
1301                         << end1 << " " << end2 );
1302             } else {
1303                 SG_LOG( SG_TERRAIN, SG_ALERT,
1304                         "Unknown token " << token << " in "
1305                         << stg_name.str() );
1306                 in >> ::skipws;
1307             }
1308         }
1309     } else {
1310         // no .stg file, generate an ocean tile on the fly for this
1311         // area
1312         ssgBranch *geometry = new ssgBranch;
1313         Point3D c;
1314         double br;
1315         if ( fgGenTile( basename.str(), tile_bucket, &c, &br, geometry ) ) {
1316             center = c;
1317             bounding_radius = br;
1318             new_tile -> addKid( geometry );
1319         } else {
1320             delete geometry;
1321             SG_LOG( SG_TERRAIN, SG_ALERT,
1322                     "Warning: failed to generate ocean tile!" );
1323         }
1324     }
1325
1326     if ( new_tile != NULL ) {
1327         terra_range->addKid( new_tile );
1328     }
1329
1330     terra_transform->addKid( terra_range );
1331
1332     // calculate initial tile offset
1333     SetOffset( globals->get_scenery()->get_center() );
1334     sgCoord sgcoord;
1335     sgSetCoord( &sgcoord,
1336                 offset.x(), offset.y(), offset.z(),
1337                 0.0, 0.0, 0.0 );
1338     terra_transform->setTransform( &sgcoord );
1339     // terrain->addKid( terra_transform );
1340
1341     // Add ground lights to scene graph if any exist
1342     gnd_lights_transform = NULL;
1343     gnd_lights_range = NULL;
1344     if ( light_pts->getNum() ) {
1345         SG_LOG( SG_TERRAIN, SG_DEBUG, "generating lights" );
1346         gnd_lights_transform = new ssgTransform;
1347         gnd_lights_range = new ssgRangeSelector;
1348         gnd_lights_brightness = new ssgSelector;
1349         ssgLeaf *lights;
1350
1351         lights = gen_lights( light_pts, 4, 0.7 );
1352         gnd_lights_brightness->addKid( lights );
1353
1354         lights = gen_lights( light_pts, 2, 0.85 );
1355         gnd_lights_brightness->addKid( lights );
1356
1357         lights = gen_lights( light_pts, 1, 1.0 );
1358         gnd_lights_brightness->addKid( lights );
1359
1360         gnd_lights_range->addKid( gnd_lights_brightness );
1361         gnd_lights_transform->addKid( gnd_lights_range );
1362         gnd_lights_transform->setTransform( &sgcoord );
1363     }
1364
1365     // Add runway lights to scene graph if any exist
1366     if ( rwy_lights_range->getNumKids() > 0 ) {
1367         SG_LOG( SG_TERRAIN, SG_INFO, "adding runway lights" );
1368         rwy_lights_transform->addKid( rwy_lights_range );
1369         rwy_lights_transform->setTransform( &sgcoord );
1370     }
1371
1372     // ADA
1373     // Create runway lights - 23 Mar 2001
1374     lightmaps_transform = NULL;
1375     lightmaps_sequence = NULL;
1376     ols_transform = NULL;
1377     //    lightmaps_range = NULL;
1378
1379     if ( lights_rway->getNum() ) {
1380         SG_LOG( SG_TERRAIN, SG_DEBUG, "generating airport lights" );
1381         lightmaps_transform = new ssgTransform;
1382         //      lightmaps_range = new ssgRangeSelector;
1383         lightmaps_brightness = new ssgSelector;
1384         lightmaps_sequence = new ssgSelector;
1385         ols_transform = new ssgTransform;
1386         ssgBranch *lightmaps_branch;
1387
1388         // call function to generate the runway lights
1389         lightmaps_branch = gen_runway_lights( lights_rway,
1390                                               lights_normal, lights_dir, lights_type);
1391         lightmaps_brightness->addKid( lightmaps_branch );
1392
1393         // build the runway lights' scene
1394         //    lightmaps_range->addKid( lightmaps_brightness ); //dont know why this doesnt work !!
1395         //      lightmaps_transform->addKid( lightmaps_range );    //dont know why this doesnt work !!
1396         lightmaps_transform->addKid( lightmaps_brightness );
1397         lightmaps_sequence->setTraversalMaskBits( SSGTRAV_HOT );
1398         lightmaps_transform->addKid( lightmaps_sequence );
1399         lightmaps_transform->setTransform( &sgcoord );
1400     }
1401     // ADA
1402 }
1403
1404
1405 void
1406 FGTileEntry::add_ssg_nodes( ssgBranch* terrain_branch,
1407                             ssgBranch* gnd_lights_branch,
1408                             ssgBranch* rwy_lights_branch )
1409 {
1410     // bump up the ref count so we can remove this later without
1411     // having ssg try to free the memory.
1412     terra_transform->ref();
1413     terrain_branch->addKid( terra_transform );
1414
1415     SG_LOG( SG_TERRAIN, SG_DEBUG,
1416             "connected a tile into scene graph.  terra_transform = "
1417             << terra_transform );
1418     SG_LOG( SG_TERRAIN, SG_DEBUG, "num parents now = "
1419             << terra_transform->getNumParents() );
1420
1421     if ( gnd_lights_transform != NULL ) {
1422         // bump up the ref count so we can remove this later without
1423         // having ssg try to free the memory.
1424         gnd_lights_transform->ref();
1425         gnd_lights_branch->addKid( gnd_lights_transform );
1426     }
1427
1428     if ( rwy_lights_transform != NULL ) {
1429         // bump up the ref count so we can remove this later without
1430         // having ssg try to free the memory.
1431         rwy_lights_transform->ref();
1432         rwy_lights_branch->addKid( rwy_lights_transform );
1433     }
1434
1435     // ADA
1436     if ( lightmaps_transform != 0 ) {
1437         // bump up the ref count so we can remove this later without
1438         // having ssg try to free the memory.
1439         lightmaps_transform->ref();
1440         gnd_lights_branch->addKid( lightmaps_transform );
1441     }
1442     // ADA
1443
1444     loaded = true;
1445 }
1446
1447
1448 void
1449 FGTileEntry::disconnect_ssg_nodes()
1450 {
1451     SG_LOG( SG_TERRAIN, SG_INFO, "disconnecting ssg nodes" );
1452
1453     if ( ! loaded ) {
1454         SG_LOG( SG_TERRAIN, SG_INFO, "removing a not-fully loaded tile!" );
1455     } else {
1456         SG_LOG( SG_TERRAIN, SG_INFO, "removing a fully loaded tile!  terra_transform = " << terra_transform );
1457     }
1458
1459     // find the terrain branch parent
1460     int pcount = terra_transform->getNumParents();
1461     if ( pcount > 0 ) {
1462         // find the first parent (should only be one)
1463         ssgBranch *parent = terra_transform->getParent( 0 ) ;
1464         if( parent ) {
1465             // disconnect the tile (we previously ref()'d it so it
1466             // won't get freed now)
1467             parent->removeKid( terra_transform );
1468         } else {
1469             SG_LOG( SG_TERRAIN, SG_ALERT,
1470                     "parent pointer is NULL!  Dying" );
1471             exit(-1);
1472         }
1473     } else {
1474         SG_LOG( SG_TERRAIN, SG_ALERT,
1475                 "Parent count is zero for an ssg tile!  Dying" );
1476         exit(-1);
1477     }
1478
1479     // find the ground lighting branch
1480     if ( gnd_lights_transform ) {
1481         pcount = gnd_lights_transform->getNumParents();
1482         if ( pcount > 0 ) {
1483             // find the first parent (should only be one)
1484             ssgBranch *parent = gnd_lights_transform->getParent( 0 ) ;
1485             if( parent ) {
1486                 // disconnect the light branch (we previously ref()'d
1487                 // it so it won't get freed now)
1488                 parent->removeKid( gnd_lights_transform );
1489             } else {
1490                 SG_LOG( SG_TERRAIN, SG_ALERT,
1491                         "parent pointer is NULL!  Dying" );
1492                 exit(-1);
1493             }
1494         } else {
1495             SG_LOG( SG_TERRAIN, SG_ALERT,
1496                     "Parent count is zero for an ssg light tile!  Dying" );
1497             exit(-1);
1498         }
1499     }
1500
1501     // find the runway lighting branch
1502     if ( rwy_lights_transform ) {
1503         pcount = rwy_lights_transform->getNumParents();
1504         if ( pcount > 0 ) {
1505             // find the first parent (should only be one)
1506             ssgBranch *parent = rwy_lights_transform->getParent( 0 ) ;
1507             if( parent ) {
1508                 // disconnect the light branch (we previously ref()'d
1509                 // it so it won't get freed now)
1510                 parent->removeKid( rwy_lights_transform );
1511             } else {
1512                 SG_LOG( SG_TERRAIN, SG_ALERT,
1513                         "parent pointer is NULL!  Dying" );
1514                 exit(-1);
1515             }
1516         } else {
1517             SG_LOG( SG_TERRAIN, SG_ALERT,
1518                     "Parent count is zero for an ssg light tile!  Dying" );
1519             exit(-1);
1520         }
1521     }
1522
1523     // ADA
1524     //runway lights - 23 Mar 2001
1525     // Delete runway lights and free memory
1526     if ( lightmaps_transform ) {
1527         // delete the runway lighting branch
1528         pcount = lightmaps_transform->getNumParents();
1529         if ( pcount > 0 ) {
1530             // find the first parent (should only be one)
1531             ssgBranch *parent = lightmaps_transform->getParent( 0 ) ;
1532             if( parent ) {
1533                 parent->removeKid( lightmaps_transform );
1534                 lightmaps_transform = NULL;
1535             } else {
1536                 SG_LOG( SG_TERRAIN, SG_ALERT,
1537                         "lightmaps parent pointer is NULL!  Dying" );
1538                 exit(-1);
1539             }
1540         } else {
1541             SG_LOG( SG_TERRAIN, SG_ALERT,
1542                     "Parent count is zero for an ssg lightmap tile!  Dying" );
1543             exit(-1);
1544         }
1545     }
1546     // ADA
1547 }