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 <Main/main.hxx>
  31
  32
  33 #include STL_STRING
  34
  35 #include <simgear/bucket/newbucket.hxx>
  36 #include <simgear/debug/logstream.hxx>
  37 #include <simgear/math/sg_geodesy.hxx>
  38 #include <simgear/math/sg_random.h>
  39 #include <simgear/misc/sgstream.hxx>
  40 #include <simgear/scene/material/mat.hxx>
  41 #include <simgear/scene/material/matlib.hxx>
  42 #include <simgear/scene/tgdb/apt_signs.hxx>
  43 #include <simgear/scene/tgdb/obj.hxx>
  44
  45 #include <Aircraft/aircraft.hxx>
  46 #include <Include/general.hxx>
  47 #include <Main/fg_props.hxx>
  48 #include <Main/globals.hxx>
  49 #include <Main/viewer.hxx>
  50 #include <Scenery/scenery.hxx>
  51 #include <Time/light.hxx>
  52
  53 #include "tileentry.hxx"
  54 #include "tilemgr.hxx"
  55
  56 SG_USING_STD(string);
  57
  58
  59 // Constructor
  60 FGTileEntry::FGTileEntry ( const SGBucket& b )
  61     : center( Point3D( 0.0 ) ),
  62       tile_bucket( b ),
  63       terra_transform( new ssgTransform ),
  64       vasi_lights_transform( new ssgTransform ),
  65       rwy_lights_transform( new ssgTransform ),
  66       taxi_lights_transform( new ssgTransform ),
  67       terra_range( new ssgRangeSelector ),
  68       vasi_lights_selector( new ssgSelector ),
  69       rwy_lights_selector( new ssgSelector ),
  70       taxi_lights_selector( new ssgSelector ),
  71       loaded(false),
  72       pending_models(0),
  73       free_tracker(0)
  74 {
  75     // update the contents
  76     // if ( vec3_ptrs.size() || vec2_ptrs.size() || index_ptrs.size() ) {
  77     //     SG_LOG( SG_TERRAIN, SG_ALERT,
  78     //             "Attempting to overwrite existing or"
  79     //             << " not properly freed leaf data." );
  80     //     exit(-1);
  81     // }
  82 }
  83
  84
  85 // Destructor
  86 FGTileEntry::~FGTileEntry () {
  87     // cout << "nodes = " << nodes.size() << endl;;
  88     // delete[] nodes;
  89 }
  90
  91
  92 #if 0
  93 // Please keep this for reference.  We use Norman's optimized routine,
  94 // but here is what the routine really is doing.
  95 void
  96 FGTileEntry::WorldCoordinate( sgCoord *obj_pos, Point3D center,
  97                               double lat, double lon, double elev, double hdg)
  98 {
  99     // setup transforms
 100     Point3D geod( lon * SGD_DEGREES_TO_RADIANS,
 101                   lat * SGD_DEGREES_TO_RADIANS,
 102                   elev );
 103
 104     Point3D world_pos = sgGeodToCart( geod );
 105     Point3D offset = world_pos - center;
 106
 107     sgMat4 POS;
 108     sgMakeTransMat4( POS, offset.x(), offset.y(), offset.z() );
 109
 110     sgVec3 obj_rt, obj_up;
 111     sgSetVec3( obj_rt, 0.0, 1.0, 0.0); // Y axis
 112     sgSetVec3( obj_up, 0.0, 0.0, 1.0); // Z axis
 113
 114     sgMat4 ROT_lon, ROT_lat, ROT_hdg;
 115     sgMakeRotMat4( ROT_lon, lon, obj_up );
 116     sgMakeRotMat4( ROT_lat, 90 - lat, obj_rt );
 117     sgMakeRotMat4( ROT_hdg, hdg, obj_up );
 118
 119     sgMat4 TUX;
 120     sgCopyMat4( TUX, ROT_hdg );
 121     sgPostMultMat4( TUX, ROT_lat );
 122     sgPostMultMat4( TUX, ROT_lon );
 123     sgPostMultMat4( TUX, POS );
 124
 125     sgSetCoord( obj_pos, TUX );
 126 }
 127 #endif
 128
 129
 130 // Norman's 'fast hack' for above
 131 static void WorldCoordinate( sgCoord *obj_pos, Point3D center, double lat,
 132                              double lon, double elev, double hdg )
 133 {
 134     double lon_rad = lon * SGD_DEGREES_TO_RADIANS;
 135     double lat_rad = lat * SGD_DEGREES_TO_RADIANS;
 136     double hdg_rad = hdg * SGD_DEGREES_TO_RADIANS;
 137
 138     // setup transforms
 139     Point3D geod( lon_rad, lat_rad, elev );
 140
 141     Point3D world_pos = sgGeodToCart( geod );
 142     Point3D offset = world_pos - center;
 143
 144     sgMat4 mat;
 145
 146     SGfloat sin_lat = (SGfloat)sin( lat_rad );
 147     SGfloat cos_lat = (SGfloat)cos( lat_rad );
 148     SGfloat cos_lon = (SGfloat)cos( lon_rad );
 149     SGfloat sin_lon = (SGfloat)sin( lon_rad );
 150     SGfloat sin_hdg = (SGfloat)sin( hdg_rad ) ;
 151     SGfloat cos_hdg = (SGfloat)cos( hdg_rad ) ;
 152
 153     mat[0][0] =  cos_hdg * (SGfloat)sin_lat * (SGfloat)cos_lon - sin_hdg * (SGfloat)sin_lon;
 154     mat[0][1] =  cos_hdg * (SGfloat)sin_lat * (SGfloat)sin_lon + sin_hdg * (SGfloat)cos_lon;
 155     mat[0][2] = -cos_hdg * (SGfloat)cos_lat;
 156     mat[0][3] =  SG_ZERO;
 157
 158     mat[1][0] = -sin_hdg * (SGfloat)sin_lat * (SGfloat)cos_lon - cos_hdg * (SGfloat)sin_lon;
 159     mat[1][1] = -sin_hdg * (SGfloat)sin_lat * (SGfloat)sin_lon + cos_hdg * (SGfloat)cos_lon;
 160     mat[1][2] =  sin_hdg * (SGfloat)cos_lat;
 161     mat[1][3] =  SG_ZERO;
 162
 163     mat[2][0] = (SGfloat)cos_lat * (SGfloat)cos_lon;
 164     mat[2][1] = (SGfloat)cos_lat * (SGfloat)sin_lon;
 165     mat[2][2] = (SGfloat)sin_lat;
 166     mat[2][3] =  SG_ZERO;
 167
 168     mat[3][0] = offset.x();
 169     mat[3][1] = offset.y();
 170     mat[3][2] = offset.z();
 171     mat[3][3] = SG_ONE ;
 172
 173     sgSetCoord( obj_pos, mat );
 174 }
 175
 176
 177 // recurse an ssg tree and call removeKid() on every node from the
 178 // bottom up.  Leaves the original branch in existance, but empty so
 179 // it can be removed by the calling routine.
 180 static void my_remove_branch( ssgBranch * branch ) {
 181     for ( ssgEntity *k = branch->getKid( 0 );
 182           k != NULL;
 183           k = branch->getNextKid() )
 184     {
 185         if ( k -> isAKindOf ( ssgTypeBranch() ) ) {
 186             my_remove_branch( (ssgBranch *)k );
 187             branch -> removeKid ( k );
 188         } else if ( k -> isAKindOf ( ssgTypeLeaf() ) ) {
 189             branch -> removeKid ( k ) ;
 190         }
 191     }
 192 }
 193
 194
 195 // Free "n" leaf elements of an ssg tree.  returns the number of
 196 // elements freed.  An empty branch node is considered a leaf.  This
 197 // is intended to spread the load of freeing a complex tile out over
 198 // several frames.
 199 static int fgPartialFreeSSGtree( ssgBranch *b, int n ) {
 200
 201 #if 0
 202     // for testing: we could call the following two lines and replace
 203     // the functionality of this entire function and everything will
 204     // get properly freed, but it will happen all at once and could
 205     // cause a huge frame rate hit.
 206     ssgDeRefDelete( b );
 207     return 0;
 208 #endif
 209
 210     int num_deletes = 0;
 211
 212     if ( n > 0 ) {
 213         // we still have some delete budget left
 214         // if ( b->getNumKids() > 100 ) {
 215         //     cout << "large family = " << b->getNumKids() << endl;
 216         // }
 217         // deleting in reverse would help if my plib patch get's
 218         // applied, but for now it will make things slower.
 219         // for ( int i = b->getNumKids() - 1; i >= 0 ; --i ) {
 220         for ( int i = 0; i < b->getNumKids(); ++i ) {
 221             ssgEntity *kid = b->getKid(i);
 222             if ( kid->isAKindOf( ssgTypeBranch() ) && kid->getRef() <= 1 ) {
 223                 int result = fgPartialFreeSSGtree( (ssgBranch *)kid, n );
 224                 num_deletes += result;
 225                 n -= result;
 226                 if ( n < 0 ) {
 227                     break;
 228                 }
 229             }
 230             // remove the kid if (a) it is now empty -or- (b) it's ref
 231             // count is > zero at which point we don't care if it's
 232             // empty, we don't want to touch it's contents.
 233             if ( kid->getNumKids() == 0 || kid->getRef() > 1 ) {
 234                 b->removeKid( kid );
 235                 num_deletes++;
 236                 n--;
 237             }
 238         }
 239     }
 240
 241     return num_deletes;
 242 }
 243
 244
 245 // Clean up the memory used by this tile and delete the arrays used by
 246 // ssg as well as the whole ssg branch
 247 bool FGTileEntry::free_tile() {
 248     int delete_size = 100;
 249     SG_LOG( SG_TERRAIN, SG_DEBUG,
 250             "FREEING TILE = (" << tile_bucket << ")" );
 251
 252     SG_LOG( SG_TERRAIN, SG_DEBUG, "(start) free_tracker = " << free_tracker );
 253
 254     if ( !(free_tracker & NODES) ) {
 255         free_tracker |= NODES;
 256     } else if ( !(free_tracker & VEC_PTRS) ) {
 257         free_tracker |= VEC_PTRS;
 258     } else if ( !(free_tracker & TERRA_NODE) ) {
 259         // delete the terrain branch (this should already have been
 260         // disconnected from the scene graph)
 261         SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING terra_transform" );
 262         if ( fgPartialFreeSSGtree( terra_transform, delete_size ) == 0 ) {
 263             ssgDeRefDelete( terra_transform );
 264             free_tracker |= TERRA_NODE;
 265         }
 266     } else if ( !(free_tracker & GROUND_LIGHTS) && gnd_lights_transform ) {
 267         // delete the terrain lighting branch (this should already have been
 268         // disconnected from the scene graph)
 269         SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING gnd_lights_transform" );
 270         if ( fgPartialFreeSSGtree( gnd_lights_transform, delete_size ) == 0 ) {
 271             ssgDeRefDelete( gnd_lights_transform );
 272             free_tracker |= GROUND_LIGHTS;
 273         }
 274     } else if ( !(free_tracker & VASI_LIGHTS) && vasi_lights_selector ) {
 275         // delete the runway lighting branch (this should already have
 276         // been disconnected from the scene graph)
 277         SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING vasi_lights_selector" );
 278         if ( fgPartialFreeSSGtree( vasi_lights_selector, delete_size ) == 0 ) {
 279             ssgDeRefDelete( vasi_lights_selector );
 280             free_tracker |= VASI_LIGHTS;
 281         }
 282     } else if ( !(free_tracker & RWY_LIGHTS) && rwy_lights_selector ) {
 283         // delete the runway lighting branch (this should already have
 284         // been disconnected from the scene graph)
 285         SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING rwy_lights_selector" );
 286         if ( fgPartialFreeSSGtree( rwy_lights_selector, delete_size ) == 0 ) {
 287             ssgDeRefDelete( rwy_lights_selector );
 288             free_tracker |= RWY_LIGHTS;
 289         }
 290     } else if ( !(free_tracker & TAXI_LIGHTS) && taxi_lights_selector ) {
 291         // delete the taxi lighting branch (this should already have been
 292         // disconnected from the scene graph)
 293         SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING taxi_lights_selector" );
 294         if ( fgPartialFreeSSGtree( taxi_lights_selector, delete_size ) == 0 ) {
 295             ssgDeRefDelete( taxi_lights_selector );
 296             free_tracker |= TAXI_LIGHTS;
 297         }
 298     } else if ( !(free_tracker & LIGHTMAPS) ) {
 299         free_tracker |= LIGHTMAPS;
 300     } else {
 301         return true;
 302     }
 303
 304     SG_LOG( SG_TERRAIN, SG_DEBUG, "(end) free_tracker = " << free_tracker );
 305
 306     // if we fall down to here, we still have work todo, return false
 307     return false;
 308 }
 309
 310
 311 // Update the ssg transform node for this tile so it can be
 312 // properly drawn relative to our (0,0,0) point
 313 void FGTileEntry::prep_ssg_node( const Point3D& p, sgVec3 up, float vis) {
 314     if ( !loaded ) return;
 315
 316     SetOffset( p );
 317
 318     // visibility can change from frame to frame so we update the
 319     // range selector cutoff's each time.
 320     terra_range->setRange( 0, SG_ZERO );
 321     terra_range->setRange( 1, vis + bounding_radius );
 322
 323     if ( gnd_lights_range ) {
 324         gnd_lights_range->setRange( 0, SG_ZERO );
 325         gnd_lights_range->setRange( 1, vis * 1.5 + bounding_radius );
 326     }
 327
 328     sgVec3 sgTrans;
 329     sgSetVec3( sgTrans, offset.x(), offset.y(), offset.z() );
 330     terra_transform->setTransform( sgTrans );
 331
 332     FGLight *l = (FGLight *)(globals->get_subsystem("lighting"));
 333     if ( gnd_lights_transform ) {
 334         // we need to lift the lights above the terrain to avoid
 335         // z-buffer fighting.  We do this based on our altitude and
 336         // the distance this tile is away from scenery center.
 337
 338         // we expect 'up' to be a unit vector coming in, but since we
 339         // modify the value of lift_vec, we need to create a local
 340         // copy.
 341         sgVec3 lift_vec;
 342         sgCopyVec3( lift_vec, up );
 343
 344         double agl;
 345         agl = globals->get_current_view()->getAltitudeASL_ft()
 346             * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev();
 347
 348         // sgTrans just happens to be the
 349         // vector from scenery center to the center of this tile which
 350         // is what we want to calculate the distance of
 351         sgVec3 to;
 352         sgCopyVec3( to, sgTrans );
 353         double dist = sgLengthVec3( to );
 354
 355         if ( general.get_glDepthBits() > 16 ) {
 356             sgScaleVec3( lift_vec, 10.0 + agl / 100.0 + dist / 10000 );
 357         } else {
 358             sgScaleVec3( lift_vec, 10.0 + agl / 20.0 + dist / 5000 );
 359         }
 360
 361         sgVec3 lt_trans;
 362         sgCopyVec3( lt_trans, sgTrans );
 363
 364         sgAddVec3( lt_trans, lift_vec );
 365         gnd_lights_transform->setTransform( lt_trans );
 366
 367         // select which set of lights based on sun angle
 368         float sun_angle = l->get_sun_angle() * SGD_RADIANS_TO_DEGREES;
 369         if ( sun_angle > 95 ) {
 370             gnd_lights_brightness->select(0x04);
 371         } else if ( sun_angle > 92 ) {
 372             gnd_lights_brightness->select(0x02);
 373         } else if ( sun_angle > 89 ) {
 374             gnd_lights_brightness->select(0x01);
 375         } else {
 376             gnd_lights_brightness->select(0x00);
 377         }
 378     }
 379
 380     if ( vasi_lights_transform ) {
 381         // we need to lift the lights above the terrain to avoid
 382         // z-buffer fighting.  We do this based on our altitude and
 383         // the distance this tile is away from scenery center.
 384
 385         sgVec3 lift_vec;
 386         sgCopyVec3( lift_vec, up );
 387
 388         // we fudge agl by 30 meters so that the lifting function
 389         // doesn't phase in until we are > 30m agl.
 390         double agl;
 391         agl = globals->get_current_view()->getAltitudeASL_ft()
 392             * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev()
 393             - 30.0;
 394         if ( agl < 0.0 ) {
 395             agl = 0.0;
 396         }
 397
 398         if ( general.get_glDepthBits() > 16 ) {
 399             sgScaleVec3( lift_vec, 0.0 + agl / 500.0 );
 400         } else {
 401             sgScaleVec3( lift_vec, 0.0 + agl / 150.0 );
 402         }
 403
 404         sgVec3 lt_trans;
 405         sgCopyVec3( lt_trans, sgTrans );
 406
 407         sgAddVec3( lt_trans, lift_vec );
 408         vasi_lights_transform->setTransform( lt_trans );
 409
 410         // generally, vasi lights are always on
 411         vasi_lights_selector->select(0x01);
 412     }
 413
 414     if ( rwy_lights_transform ) {
 415         // we need to lift the lights above the terrain to avoid
 416         // z-buffer fighting.  We do this based on our altitude and
 417         // the distance this tile is away from scenery center.
 418
 419         sgVec3 lift_vec;
 420         sgCopyVec3( lift_vec, up );
 421
 422         // we fudge agl by 30 meters so that the lifting function
 423         // doesn't phase in until we are > 30m agl.
 424         double agl;
 425         agl = globals->get_current_view()->getAltitudeASL_ft()
 426             * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev()
 427             - 30.0;
 428         if ( agl < 0.0 ) {
 429             agl = 0.0;
 430         }
 431
 432         if ( general.get_glDepthBits() > 16 ) {
 433             sgScaleVec3( lift_vec, 0.0 + agl / 500.0 );
 434         } else {
 435             sgScaleVec3( lift_vec, 0.0 + agl / 150.0 );
 436         }
 437
 438         sgVec3 lt_trans;
 439         sgCopyVec3( lt_trans, sgTrans );
 440
 441         sgAddVec3( lt_trans, lift_vec );
 442         rwy_lights_transform->setTransform( lt_trans );
 443
 444         // turn runway lights on/off based on sun angle and visibility
 445         float sun_angle = l->get_sun_angle() * SGD_RADIANS_TO_DEGREES;
 446         if ( sun_angle > 85 ||
 447              (fgGetDouble("/environment/visibility-m") < 5000.0) ) {
 448             rwy_lights_selector->select(0x01);
 449         } else {
 450             rwy_lights_selector->select(0x00);
 451         }
 452     }
 453
 454     if ( taxi_lights_transform ) {
 455         // we need to lift the lights above the terrain to avoid
 456         // z-buffer fighting.  We do this based on our altitude and
 457         // the distance this tile is away from scenery center.
 458
 459         sgVec3 lift_vec;
 460         sgCopyVec3( lift_vec, up );
 461
 462         // we fudge agl by 30 meters so that the lifting function
 463         // doesn't phase in until we are > 30m agl.
 464         double agl;
 465         agl = globals->get_current_view()->getAltitudeASL_ft()
 466             * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev()
 467             - 30.0;
 468         if ( agl < 0.0 ) {
 469             agl = 0.0;
 470         }
 471
 472         if ( general.get_glDepthBits() > 16 ) {
 473             sgScaleVec3( lift_vec, 0.0 + agl / 500.0 );
 474         } else {
 475             sgScaleVec3( lift_vec, 0.0 + agl / 150.0 );
 476         }
 477
 478         sgVec3 lt_trans;
 479         sgCopyVec3( lt_trans, sgTrans );
 480
 481         sgAddVec3( lt_trans, lift_vec );
 482         taxi_lights_transform->setTransform( lt_trans );
 483
 484         // turn taxi lights on/off based on sun angle and visibility
 485         float sun_angle = l->get_sun_angle() * SGD_RADIANS_TO_DEGREES;
 486         if ( sun_angle > 85 ||
 487              (fgGetDouble("/environment/visibility-m") < 5000.0) ) {
 488             taxi_lights_selector->select(0x01);
 489         } else {
 490             taxi_lights_selector->select(0x00);
 491         }
 492     }
 493 }
 494
 495
 496 // Set up lights rendering call backs
 497 static int fgLightsPredraw( ssgEntity *e ) {
 498 #if 0
 499     if (glPointParameterIsSupported) {
 500         static float quadratic[3] = {1.0, 0.01, 0.0001};
 501         glPointParameterfvProc(GL_DISTANCE_ATTENUATION_EXT, quadratic);
 502         glPointParameterfProc(GL_POINT_SIZE_MIN_EXT, 1.0);
 503         glPointSize(4.0);
 504     }
 505 #endif
 506     return true;
 507 }
 508
 509 static int fgLightsPostdraw( ssgEntity *e ) {
 510 #if 0
 511     if (glPointParameterIsSupported) {
 512         static float default_attenuation[3] = {1.0, 0.0, 0.0};
 513         glPointParameterfvProc(GL_DISTANCE_ATTENUATION_EXT,
 514                               default_attenuation);
 515         glPointSize(1.0);
 516     }
 517 #endif
 518     return true;
 519 }
 520
 521
 522 ssgLeaf* FGTileEntry::gen_lights( SGMaterialLib *matlib, ssgVertexArray *lights,
 523                                   int inc, float bright )
 524 {
 525     // generate a repeatable random seed
 526     float *p1 = lights->get( 0 );
 527     unsigned int *seed = (unsigned int *)p1;
 528     sg_srandom( *seed );
 529
 530     int size = lights->getNum() / inc;
 531
 532     // Allocate ssg structure
 533     ssgVertexArray   *vl = new ssgVertexArray( size + 1 );
 534     ssgNormalArray   *nl = NULL;
 535     ssgTexCoordArray *tl = NULL;
 536     ssgColourArray   *cl = new ssgColourArray( size + 1 );
 537
 538     sgVec4 color;
 539     for ( int i = 0; i < lights->getNum(); ++i ) {
 540         // this loop is slightly less efficient than it otherwise
 541         // could be, but we want a red light to always be red, and a
 542         // yellow light to always be yellow, etc. so we are trying to
 543         // preserve the random sequence.
 544         float zombie = sg_random();
 545         if ( i % inc == 0 ) {
 546             vl->add( lights->get(i) );
 547
 548             // factor = sg_random() ^ 2, range = 0 .. 1 concentrated towards 0
 549             float factor = sg_random();
 550             factor *= factor;
 551
 552             if ( zombie > 0.5 ) {
 553                 // 50% chance of yellowish
 554                 sgSetVec4( color, 0.9, 0.9, 0.3, bright - factor * 0.2 );
 555             } else if ( zombie > 0.15 ) {
 556                 // 35% chance of whitish
 557                 sgSetVec4( color, 0.9, 0.9, 0.8, bright - factor * 0.2 );
 558             } else if ( zombie > 0.05 ) {
 559                 // 10% chance of orangish
 560                 sgSetVec4( color, 0.9, 0.6, 0.2, bright - factor * 0.2 );
 561             } else {
 562                 // 5% chance of redish
 563                 sgSetVec4( color, 0.9, 0.2, 0.2, bright - factor * 0.2 );
 564             }
 565             cl->add( color );
 566         }
 567     }
 568
 569     // create ssg leaf
 570     ssgLeaf *leaf =
 571         new ssgVtxTable ( GL_POINTS, vl, nl, tl, cl );
 572
 573     // assign state
 574     SGMaterial *mat = matlib->find( "GROUND_LIGHTS" );
 575     leaf->setState( mat->get_state() );
 576     leaf->setCallback( SSG_CALLBACK_PREDRAW, fgLightsPredraw );
 577     leaf->setCallback( SSG_CALLBACK_POSTDRAW, fgLightsPostdraw );
 578
 579     return leaf;
 580 }
 581
 582
 583 bool FGTileEntry::obj_load( const string& path,
 584                             ssgBranch *geometry,
 585                             ssgBranch *vasi_lights,
 586                             ssgBranch *rwy_lights,
 587                             ssgBranch *taxi_lights,
 588                             ssgVertexArray *ground_lights, bool is_base )
 589 {
 590     Point3D c;                  // returned center point
 591     double br;                  // returned bounding radius
 592
 593     bool use_random_objects =
 594         fgGetBool("/sim/rendering/random-objects", true);
 595
 596     // try loading binary format
 597     if ( sgBinObjLoad( path, is_base,
 598                        &c, &br, globals->get_matlib(), use_random_objects,
 599                        geometry, vasi_lights, rwy_lights, taxi_lights,
 600                        ground_lights ) )
 601     {
 602         if ( is_base ) {
 603             center = c;
 604             bounding_radius = br;
 605         }
 606     }
 607
 608     return (geometry != NULL);
 609 }
 610
 611
 612 void
 613 FGTileEntry::load( const string &base_path, bool is_base )
 614 {
 615     SG_LOG( SG_TERRAIN, SG_INFO, "load() base search path = "
 616             << base_path );
 617
 618     bool found_tile_base = false;
 619
 620     string_list search = sgPathSplit( base_path );
 621
 622     // obj_load() will generate ground lighting for us ...
 623     ssgVertexArray *light_pts = new ssgVertexArray( 100 );
 624
 625     ssgBranch* new_tile = new ssgBranch;
 626
 627     unsigned int i = 0;
 628     while ( i < search.size() ) {
 629
 630         bool has_base = false;
 631
 632         // Generate names for later use
 633         string index_str = tile_bucket.gen_index_str();
 634
 635         SGPath tile_path = search[i];
 636         tile_path.append( tile_bucket.gen_base_path() );
 637
 638         SGPath basename = tile_path;
 639         basename.append( index_str );
 640         // string path = basename.str();
 641
 642         SG_LOG( SG_TERRAIN, SG_INFO, "Loading tile " << basename.str() );
 643
 644 #define FG_MAX_LIGHTS 1000
 645
 646         // Check for master .stg (scene terra gear) file
 647         SGPath stg_name = basename;
 648         stg_name.concat( ".stg" );
 649
 650         sg_gzifstream in( stg_name.str() );
 651
 652         if ( in.is_open() ) {
 653             string token, name;
 654
 655             while ( ! in.eof() ) {
 656                 in >> token;
 657
 658                                 // Load only once (first found)
 659                 if ( token == "OBJECT_BASE" ) {
 660                     in >> name >> ::skipws;
 661                     SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
 662                             << " name = " << name );
 663
 664                     if (!found_tile_base) {
 665                         found_tile_base = true;
 666                         has_base = true;
 667
 668                         SGPath custom_path = tile_path;
 669                         custom_path.append( name );
 670
 671                         ssgBranch *geometry = new ssgBranch;
 672                         if ( obj_load( custom_path.str(),
 673                                        geometry, NULL, NULL, NULL, light_pts,
 674                                        true ) )
 675                             {
 676                                 new_tile -> addKid( geometry );
 677                             } else {
 678                                 delete geometry;
 679                             }
 680                     } else {
 681                         SG_LOG( SG_TERRAIN, SG_INFO, " (skipped)" );
 682                     }
 683
 684                                 // Load only if base is not in another file
 685                 } else if ( token == "OBJECT" ) {
 686                     if (!found_tile_base || has_base) {
 687                         in >> name >> ::skipws;
 688                         SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
 689                                 << " name = " << name );
 690
 691                         SGPath custom_path = tile_path;
 692                         custom_path.append( name );
 693
 694                         ssgBranch *geometry = new ssgBranch;
 695                         ssgBranch *vasi_lights = new ssgBranch;
 696                         ssgBranch *rwy_lights = new ssgBranch;
 697                         ssgBranch *taxi_lights = new ssgBranch;
 698                         if ( obj_load( custom_path.str(),
 699                                        geometry, vasi_lights, rwy_lights,
 700                                        taxi_lights, NULL, false ) )
 701                             {
 702                                 if ( geometry -> getNumKids() > 0 ) {
 703                                     new_tile -> addKid( geometry );
 704                                 } else {
 705                                     delete geometry;
 706                                 }
 707                                 if ( vasi_lights -> getNumKids() > 0 ) {
 708                                     vasi_lights_transform -> addKid( vasi_lights );
 709                                 } else {
 710                                     delete vasi_lights;
 711                                 }
 712                                 if ( rwy_lights -> getNumKids() > 0 ) {
 713                                     rwy_lights_transform -> addKid( rwy_lights );
 714                                 } else {
 715                                     delete rwy_lights;
 716                                 }
 717                                 if ( taxi_lights -> getNumKids() > 0 ) {
 718                                     taxi_lights_transform -> addKid( taxi_lights );
 719                                 } else {
 720                                     delete taxi_lights;
 721                                 }
 722                             } else {
 723                                 delete geometry;
 724                                 delete vasi_lights;
 725                                 delete rwy_lights;
 726                                 delete taxi_lights;
 727                             }
 728                     }
 729
 730                                 // Always OK to load
 731                 } else if ( token == "OBJECT_STATIC" ||
 732                             token == "OBJECT_SHARED" ) {
 733                     // load object info
 734                     double lon, lat, elev, hdg;
 735                     in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
 736                     SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
 737                             << " name = " << name
 738                             << " pos = " << lon << ", " << lat
 739                             << " elevation = " << elev
 740                             << " heading = " << hdg );
 741
 742                     // object loading is deferred to main render thread,
 743                     // but lets figure out the paths right now.
 744                     SGPath custom_path;
 745                     if ( token == "OBJECT_STATIC" ) {
 746                         custom_path= tile_path;
 747                     } else {
 748                         custom_path = globals->get_fg_root();
 749                     }
 750                     custom_path.append( name );
 751
 752                     sgCoord obj_pos;
 753                     WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
 754
 755                     ssgTransform *obj_trans = new ssgTransform;
 756                     obj_trans->setTransform( &obj_pos );
 757
 758                     // wire as much of the scene graph together as we can
 759                     new_tile->addKid( obj_trans );
 760
 761                     // bump up the pending models count
 762                     pending_models++;
 763
 764                     // push an entry onto the model load queue
 765                     FGDeferredModel *dm
 766                         = new FGDeferredModel( custom_path.str(),
 767                                                tile_path.str(),
 768                                                this, obj_trans );
 769                     FGTileMgr::model_ready( dm );
 770
 771                                 // Do we even use this one?
 772                 } else if ( token == "OBJECT_TAXI_SIGN" ) {
 773                     // load object info
 774                     double lon, lat, elev, hdg;
 775                     in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
 776                     SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
 777                             << " name = " << name
 778                             << " pos = " << lon << ", " << lat
 779                             << " elevation = " << elev
 780                             << " heading = " << hdg );
 781
 782                     // load the object itself
 783                     SGPath custom_path = tile_path;
 784                     custom_path.append( name );
 785
 786                     sgCoord obj_pos;
 787                     WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
 788
 789                     ssgTransform *obj_trans = new ssgTransform;
 790                     obj_trans->setTransform( &obj_pos );
 791
 792                     ssgBranch *custom_obj
 793                         = sgMakeTaxiSign( globals->get_matlib(),
 794                                           custom_path.str(), name );
 795
 796                     // wire the pieces together
 797                     if ( custom_obj != NULL ) {
 798                         obj_trans -> addKid( custom_obj );
 799                     }
 800                     new_tile->addKid( obj_trans );
 801
 802                                 // Do we even use this one?
 803                 } else if ( token == "OBJECT_RUNWAY_SIGN" ) {
 804                     // load object info
 805                     double lon, lat, elev, hdg;
 806                     in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
 807                     SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
 808                             << " name = " << name
 809                             << " pos = " << lon << ", " << lat
 810                             << " elevation = " << elev
 811                             << " heading = " << hdg );
 812
 813                     // load the object itself
 814                     SGPath custom_path = tile_path;
 815                     custom_path.append( name );
 816
 817                     sgCoord obj_pos;
 818                     WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
 819
 820                     ssgTransform *obj_trans = new ssgTransform;
 821                     obj_trans->setTransform( &obj_pos );
 822
 823                     ssgBranch *custom_obj
 824                         = sgMakeRunwaySign( globals->get_matlib(),
 825                                             custom_path.str(), name );
 826
 827                     // wire the pieces together
 828                     if ( custom_obj != NULL ) {
 829                         obj_trans -> addKid( custom_obj );
 830                     }
 831                     new_tile->addKid( obj_trans );
 832
 833                                 // I don't think we use this, either
 834                 } else if ( token == "RWY_LIGHTS" ) {
 835                     double lon, lat, hdg, len, width;
 836                     string common, end1, end2;
 837                     in >> lon >> lat >> hdg >> len >> width
 838                        >> common >> end1 >> end2;
 839                     SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
 840                             << " pos = " << lon << ", " << lat
 841                             << " hdg = " << hdg
 842                             << " size = " << len << ", " << width
 843                             << " codes = " << common << " "
 844                             << end1 << " " << end2 );
 845                 } else {
 846                     SG_LOG( SG_TERRAIN, SG_ALERT,
 847                             "Unknown token " << token << " in "
 848                             << stg_name.str() );
 849                     in >> ::skipws;
 850                 }
 851             }
 852         }
 853
 854         i++;
 855     }
 856
 857     if ( !found_tile_base ) {
 858         // no tile base found, generate an ocean tile on the fly for
 859         // this area
 860         ssgBranch *geometry = new ssgBranch;
 861         Point3D c;
 862         double br;
 863         if ( sgGenTile( search[0], tile_bucket, &c, &br,
 864                         globals->get_matlib(), geometry ) )
 865         {
 866             center = c;
 867             bounding_radius = br;
 868             new_tile -> addKid( geometry );
 869         } else {
 870             delete geometry;
 871             SG_LOG( SG_TERRAIN, SG_ALERT,
 872                     "Warning: failed to generate ocean tile!" );
 873         }
 874     }
 875
 876     if ( new_tile != NULL ) {
 877         terra_range->addKid( new_tile );
 878     }
 879
 880     terra_transform->addKid( terra_range );
 881
 882     // calculate initial tile offset
 883     SetOffset( globals->get_scenery()->get_center() );
 884     sgCoord sgcoord;
 885     sgSetCoord( &sgcoord,
 886                 offset.x(), offset.y(), offset.z(),
 887                 0.0, 0.0, 0.0 );
 888     terra_transform->setTransform( &sgcoord );
 889     // terrain->addKid( terra_transform );
 890
 891     // Add ground lights to scene graph if any exist
 892     gnd_lights_transform = NULL;
 893     gnd_lights_range = NULL;
 894     if ( light_pts->getNum() ) {
 895         SG_LOG( SG_TERRAIN, SG_DEBUG, "generating lights" );
 896         gnd_lights_transform = new ssgTransform;
 897         gnd_lights_range = new ssgRangeSelector;
 898         gnd_lights_brightness = new ssgSelector;
 899         ssgLeaf *lights;
 900
 901         lights = gen_lights( globals->get_matlib(), light_pts, 4, 0.7 );
 902         gnd_lights_brightness->addKid( lights );
 903
 904         lights = gen_lights( globals->get_matlib(), light_pts, 2, 0.85 );
 905         gnd_lights_brightness->addKid( lights );
 906
 907         lights = gen_lights( globals->get_matlib(), light_pts, 1, 1.0 );
 908         gnd_lights_brightness->addKid( lights );
 909
 910         gnd_lights_range->addKid( gnd_lights_brightness );
 911         gnd_lights_transform->addKid( gnd_lights_range );
 912         gnd_lights_transform->setTransform( &sgcoord );
 913     }
 914
 915     // Update vasi lights transform
 916     if ( vasi_lights_transform->getNumKids() > 0 ) {
 917         vasi_lights_transform->setTransform( &sgcoord );
 918     }
 919
 920     // Update runway lights transform
 921     if ( rwy_lights_transform->getNumKids() > 0 ) {
 922         rwy_lights_transform->setTransform( &sgcoord );
 923     }
 924
 925      // Update taxi lights transform
 926     if ( taxi_lights_transform->getNumKids() > 0 ) {
 927         taxi_lights_transform->setTransform( &sgcoord );
 928     }
 929 }
 930
 931
 932 void
 933 FGTileEntry::add_ssg_nodes( ssgBranch *terrain_branch,
 934                             ssgBranch *gnd_lights_branch,
 935                             ssgBranch *vasi_lights_branch,
 936                             ssgBranch *rwy_lights_branch,
 937                             ssgBranch *taxi_lights_branch )
 938 {
 939     // bump up the ref count so we can remove this later without
 940     // having ssg try to free the memory.
 941     terra_transform->ref();
 942     terrain_branch->addKid( terra_transform );
 943
 944     SG_LOG( SG_TERRAIN, SG_DEBUG,
 945             "connected a tile into scene graph.  terra_transform = "
 946             << terra_transform );
 947     SG_LOG( SG_TERRAIN, SG_DEBUG, "num parents now = "
 948             << terra_transform->getNumParents() );
 949
 950     if ( gnd_lights_transform != NULL ) {
 951         // bump up the ref count so we can remove this later without
 952         // having ssg try to free the memory.
 953         gnd_lights_transform->ref();
 954         gnd_lights_branch->addKid( gnd_lights_transform );
 955     }
 956
 957     if ( vasi_lights_transform != NULL ) {
 958         // bump up the ref count so we can remove this later without
 959         // having ssg try to free the memory.
 960         vasi_lights_selector->ref();
 961         vasi_lights_selector->addKid( vasi_lights_transform );
 962         vasi_lights_branch->addKid( vasi_lights_selector );
 963     }
 964
 965     if ( rwy_lights_transform != NULL ) {
 966         // bump up the ref count so we can remove this later without
 967         // having ssg try to free the memory.
 968         rwy_lights_selector->ref();
 969         rwy_lights_selector->addKid( rwy_lights_transform );
 970         rwy_lights_branch->addKid( rwy_lights_selector );
 971     }
 972
 973     if ( taxi_lights_transform != NULL ) {
 974         // bump up the ref count so we can remove this later without
 975         // having ssg try to free the memory.
 976         taxi_lights_selector->ref();
 977         taxi_lights_selector->addKid( taxi_lights_transform );
 978         taxi_lights_branch->addKid( taxi_lights_selector );
 979     }
 980
 981     loaded = true;
 982 }
 983
 984
 985 void
 986 FGTileEntry::disconnect_ssg_nodes()
 987 {
 988     SG_LOG( SG_TERRAIN, SG_DEBUG, "disconnecting ssg nodes" );
 989
 990     if ( ! loaded ) {
 991         SG_LOG( SG_TERRAIN, SG_DEBUG, "removing a not-fully loaded tile!" );
 992     } else {
 993         SG_LOG( SG_TERRAIN, SG_DEBUG, "removing a fully loaded tile!  terra_transform = " << terra_transform );
 994     }
 995
 996     // find the terrain branch parent
 997     int pcount = terra_transform->getNumParents();
 998     if ( pcount > 0 ) {
 999         // find the first parent (should only be one)
1000         ssgBranch *parent = terra_transform->getParent( 0 ) ;
1001         if( parent ) {
1002             // disconnect the tile (we previously ref()'d it so it
1003             // won't get freed now)
1004             parent->removeKid( terra_transform );
1005         } else {
1006             SG_LOG( SG_TERRAIN, SG_ALERT,
1007                     "parent pointer is NULL!  Dying" );
1008             exit(-1);
1009         }
1010     } else {
1011         SG_LOG( SG_TERRAIN, SG_ALERT,
1012                 "Parent count is zero for an ssg tile!  Dying" );
1013         exit(-1);
1014     }
1015
1016     // find the ground lighting branch
1017     if ( gnd_lights_transform ) {
1018         pcount = gnd_lights_transform->getNumParents();
1019         if ( pcount > 0 ) {
1020             // find the first parent (should only be one)
1021             ssgBranch *parent = gnd_lights_transform->getParent( 0 ) ;
1022             if( parent ) {
1023                 // disconnect the light branch (we previously ref()'d
1024                 // it so it won't get freed now)
1025                 parent->removeKid( gnd_lights_transform );
1026             } else {
1027                 SG_LOG( SG_TERRAIN, SG_ALERT,
1028                         "parent pointer is NULL!  Dying" );
1029                 exit(-1);
1030             }
1031         } else {
1032             SG_LOG( SG_TERRAIN, SG_ALERT,
1033                     "Parent count is zero for an ssg light tile!  Dying" );
1034             exit(-1);
1035         }
1036     }
1037
1038     // find the vasi lighting branch
1039     if ( vasi_lights_transform ) {
1040         pcount = vasi_lights_transform->getNumParents();
1041         if ( pcount > 0 ) {
1042             // find the first parent (should only be one)
1043             ssgBranch *parent = vasi_lights_transform->getParent( 0 ) ;
1044             if( parent ) {
1045                 // disconnect the light branch (we previously ref()'d
1046                 // it so it won't get freed now)
1047                 parent->removeKid( vasi_lights_transform );
1048             } else {
1049                 SG_LOG( SG_TERRAIN, SG_ALERT,
1050                         "parent pointer is NULL!  Dying" );
1051                 exit(-1);
1052             }
1053         } else {
1054             SG_LOG( SG_TERRAIN, SG_ALERT,
1055                     "Parent count is zero for an ssg light tile!  Dying" );
1056             exit(-1);
1057         }
1058     }
1059
1060     // find the runway lighting branch
1061     if ( rwy_lights_transform ) {
1062         pcount = rwy_lights_transform->getNumParents();
1063         if ( pcount > 0 ) {
1064             // find the first parent (should only be one)
1065             ssgBranch *parent = rwy_lights_transform->getParent( 0 ) ;
1066             if( parent ) {
1067                 // disconnect the light branch (we previously ref()'d
1068                 // it so it won't get freed now)
1069                 parent->removeKid( rwy_lights_transform );
1070             } else {
1071                 SG_LOG( SG_TERRAIN, SG_ALERT,
1072                         "parent pointer is NULL!  Dying" );
1073                 exit(-1);
1074             }
1075         } else {
1076             SG_LOG( SG_TERRAIN, SG_ALERT,
1077                     "Parent count is zero for an ssg light tile!  Dying" );
1078             exit(-1);
1079         }
1080     }
1081
1082     // find the taxi lighting branch
1083     if ( taxi_lights_transform ) {
1084         pcount = taxi_lights_transform->getNumParents();
1085         if ( pcount > 0 ) {
1086             // find the first parent (should only be one)
1087             ssgBranch *parent = taxi_lights_transform->getParent( 0 ) ;
1088             if( parent ) {
1089                 // disconnect the light branch (we previously ref()'d
1090                 // it so it won't get freed now)
1091                 parent->removeKid( taxi_lights_transform );
1092             } else {
1093                 SG_LOG( SG_TERRAIN, SG_ALERT,
1094                         "parent pointer is NULL!  Dying" );
1095                 exit(-1);
1096             }
1097         } else {
1098             SG_LOG( SG_TERRAIN, SG_ALERT,
1099                     "Parent count is zero for an ssg light tile!  Dying" );
1100             exit(-1);
1101         }
1102     }
1103 }