1 // tileentry.cxx -- routines to handle a scenery tile
3 // Written by Curtis Olson, started May 1998.
5 // Copyright (C) 1998 - 2001 Curtis L. Olson - curt@flightgear.org
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.
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.
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.
28 #include <simgear/compiler.h>
30 #include <Main/main.hxx>
35 #include <simgear/bucket/newbucket.hxx>
36 #include <simgear/debug/logstream.hxx>
37 #include <simgear/math/polar3d.hxx>
38 #include <simgear/math/sg_geodesy.hxx>
39 #include <simgear/math/sg_random.h>
40 #include <simgear/misc/sgstream.hxx>
41 #include <simgear/scene/material/mat.hxx>
42 #include <simgear/scene/material/matlib.hxx>
43 #include <simgear/scene/tgdb/apt_signs.hxx>
44 #include <simgear/scene/tgdb/obj.hxx>
45 #include <simgear/scene/tgdb/vasi.hxx>
47 #include <Aircraft/aircraft.hxx>
48 #include <Include/general.hxx>
49 #include <Main/fg_props.hxx>
50 #include <Main/globals.hxx>
51 #include <Main/viewer.hxx>
52 #include <Scenery/scenery.hxx>
53 #include <Time/light.hxx>
55 #include "tileentry.hxx"
56 #include "tilemgr.hxx"
62 FGTileEntry::FGTileEntry ( const SGBucket& b )
63 : center( Point3D( 0.0 ) ),
65 terra_transform( new ssgTransform ),
66 vasi_lights_transform( new ssgTransform ),
67 rwy_lights_transform( new ssgTransform ),
68 taxi_lights_transform( new ssgTransform ),
69 terra_range( new ssgRangeSelector ),
70 vasi_lights_selector( new ssgSelector ),
71 rwy_lights_selector( new ssgSelector ),
72 taxi_lights_selector( new ssgSelector ),
78 // update the contents
79 // if ( vec3_ptrs.size() || vec2_ptrs.size() || index_ptrs.size() ) {
80 // SG_LOG( SG_TERRAIN, SG_ALERT,
81 // "Attempting to overwrite existing or"
82 // << " not properly freed leaf data." );
89 FGTileEntry::~FGTileEntry () {
90 // cout << "nodes = " << nodes.size() << endl;;
96 // Please keep this for reference. We use Norman's optimized routine,
97 // but here is what the routine really is doing.
99 FGTileEntry::WorldCoordinate( sgCoord *obj_pos, Point3D center,
100 double lat, double lon, double elev, double hdg)
103 Point3D geod( lon * SGD_DEGREES_TO_RADIANS,
104 lat * SGD_DEGREES_TO_RADIANS,
107 Point3D world_pos = sgGeodToCart( geod );
108 Point3D offset = world_pos - center;
111 sgMakeTransMat4( POS, offset.x(), offset.y(), offset.z() );
113 sgVec3 obj_rt, obj_up;
114 sgSetVec3( obj_rt, 0.0, 1.0, 0.0); // Y axis
115 sgSetVec3( obj_up, 0.0, 0.0, 1.0); // Z axis
117 sgMat4 ROT_lon, ROT_lat, ROT_hdg;
118 sgMakeRotMat4( ROT_lon, lon, obj_up );
119 sgMakeRotMat4( ROT_lat, 90 - lat, obj_rt );
120 sgMakeRotMat4( ROT_hdg, hdg, obj_up );
123 sgCopyMat4( TUX, ROT_hdg );
124 sgPostMultMat4( TUX, ROT_lat );
125 sgPostMultMat4( TUX, ROT_lon );
126 sgPostMultMat4( TUX, POS );
128 sgSetCoord( obj_pos, TUX );
133 // Norman's 'fast hack' for above
134 static void WorldCoordinate( sgCoord *obj_pos, Point3D center, double lat,
135 double lon, double elev, double hdg )
137 double lon_rad = lon * SGD_DEGREES_TO_RADIANS;
138 double lat_rad = lat * SGD_DEGREES_TO_RADIANS;
139 double hdg_rad = hdg * SGD_DEGREES_TO_RADIANS;
142 Point3D geod( lon_rad, lat_rad, elev );
144 Point3D world_pos = sgGeodToCart( geod );
145 Point3D offset = world_pos - center;
149 SGfloat sin_lat = (SGfloat)sin( lat_rad );
150 SGfloat cos_lat = (SGfloat)cos( lat_rad );
151 SGfloat cos_lon = (SGfloat)cos( lon_rad );
152 SGfloat sin_lon = (SGfloat)sin( lon_rad );
153 SGfloat sin_hdg = (SGfloat)sin( hdg_rad ) ;
154 SGfloat cos_hdg = (SGfloat)cos( hdg_rad ) ;
156 mat[0][0] = cos_hdg * (SGfloat)sin_lat * (SGfloat)cos_lon - sin_hdg * (SGfloat)sin_lon;
157 mat[0][1] = cos_hdg * (SGfloat)sin_lat * (SGfloat)sin_lon + sin_hdg * (SGfloat)cos_lon;
158 mat[0][2] = -cos_hdg * (SGfloat)cos_lat;
161 mat[1][0] = -sin_hdg * (SGfloat)sin_lat * (SGfloat)cos_lon - cos_hdg * (SGfloat)sin_lon;
162 mat[1][1] = -sin_hdg * (SGfloat)sin_lat * (SGfloat)sin_lon + cos_hdg * (SGfloat)cos_lon;
163 mat[1][2] = sin_hdg * (SGfloat)cos_lat;
166 mat[2][0] = (SGfloat)cos_lat * (SGfloat)cos_lon;
167 mat[2][1] = (SGfloat)cos_lat * (SGfloat)sin_lon;
168 mat[2][2] = (SGfloat)sin_lat;
171 mat[3][0] = offset.x();
172 mat[3][1] = offset.y();
173 mat[3][2] = offset.z();
176 sgSetCoord( obj_pos, mat );
180 // recurse an ssg tree and call removeKid() on every node from the
181 // bottom up. Leaves the original branch in existance, but empty so
182 // it can be removed by the calling routine.
183 static void my_remove_branch( ssgBranch * branch ) {
184 for ( ssgEntity *k = branch->getKid( 0 );
186 k = branch->getNextKid() )
188 if ( k -> isAKindOf ( ssgTypeBranch() ) ) {
189 my_remove_branch( (ssgBranch *)k );
190 branch -> removeKid ( k );
191 } else if ( k -> isAKindOf ( ssgTypeLeaf() ) ) {
192 branch -> removeKid ( k ) ;
198 // Free "n" leaf elements of an ssg tree. returns the number of
199 // elements freed. An empty branch node is considered a leaf. This
200 // is intended to spread the load of freeing a complex tile out over
202 static int fgPartialFreeSSGtree( ssgBranch *b, int n ) {
205 // for testing: we could call the following two lines and replace
206 // the functionality of this entire function and everything will
207 // get properly freed, but it will happen all at once and could
208 // cause a huge frame rate hit.
216 // we still have some delete budget left
217 // if ( b->getNumKids() > 100 ) {
218 // cout << "large family = " << b->getNumKids() << endl;
220 // deleting in reverse would help if my plib patch get's
221 // applied, but for now it will make things slower.
222 // for ( int i = b->getNumKids() - 1; i >= 0 ; --i ) {
223 for ( int i = 0; i < b->getNumKids(); ++i ) {
224 ssgEntity *kid = b->getKid(i);
225 if ( kid->isAKindOf( ssgTypeBranch() ) && kid->getRef() <= 1 ) {
226 int result = fgPartialFreeSSGtree( (ssgBranch *)kid, n );
227 num_deletes += result;
233 // remove the kid if (a) it is now empty -or- (b) it's ref
234 // count is > zero at which point we don't care if it's
235 // empty, we don't want to touch it's contents.
236 if ( kid->getNumKids() == 0 || kid->getRef() > 1 ) {
248 // Clean up the memory used by this tile and delete the arrays used by
249 // ssg as well as the whole ssg branch
250 bool FGTileEntry::free_tile() {
251 int delete_size = 100;
252 SG_LOG( SG_TERRAIN, SG_DEBUG,
253 "FREEING TILE = (" << tile_bucket << ")" );
255 SG_LOG( SG_TERRAIN, SG_DEBUG, "(start) free_tracker = " << free_tracker );
257 if ( !(free_tracker & NODES) ) {
258 free_tracker |= NODES;
259 } else if ( !(free_tracker & VEC_PTRS) ) {
260 free_tracker |= VEC_PTRS;
261 } else if ( !(free_tracker & TERRA_NODE) ) {
262 // delete the terrain branch (this should already have been
263 // disconnected from the scene graph)
264 SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING terra_transform" );
265 if ( fgPartialFreeSSGtree( terra_transform, delete_size ) == 0 ) {
266 ssgDeRefDelete( terra_transform );
267 free_tracker |= TERRA_NODE;
269 } else if ( !(free_tracker & GROUND_LIGHTS) && gnd_lights_transform ) {
270 // delete the terrain lighting branch (this should already have been
271 // disconnected from the scene graph)
272 SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING gnd_lights_transform" );
273 if ( fgPartialFreeSSGtree( gnd_lights_transform, delete_size ) == 0 ) {
274 ssgDeRefDelete( gnd_lights_transform );
275 free_tracker |= GROUND_LIGHTS;
277 } else if ( !(free_tracker & VASI_LIGHTS) && vasi_lights_selector ) {
278 // delete the runway lighting branch (this should already have
279 // been disconnected from the scene graph)
280 SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING vasi_lights_selector" );
281 if ( fgPartialFreeSSGtree( vasi_lights_selector, delete_size ) == 0 ) {
282 ssgDeRefDelete( vasi_lights_selector );
283 free_tracker |= VASI_LIGHTS;
285 } else if ( !(free_tracker & RWY_LIGHTS) && rwy_lights_selector ) {
286 // delete the runway lighting branch (this should already have
287 // been disconnected from the scene graph)
288 SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING rwy_lights_selector" );
289 if ( fgPartialFreeSSGtree( rwy_lights_selector, delete_size ) == 0 ) {
290 ssgDeRefDelete( rwy_lights_selector );
291 free_tracker |= RWY_LIGHTS;
293 } else if ( !(free_tracker & TAXI_LIGHTS) && taxi_lights_selector ) {
294 // delete the taxi lighting branch (this should already have been
295 // disconnected from the scene graph)
296 SG_LOG( SG_TERRAIN, SG_DEBUG, "FREEING taxi_lights_selector" );
297 if ( fgPartialFreeSSGtree( taxi_lights_selector, delete_size ) == 0 ) {
298 ssgDeRefDelete( taxi_lights_selector );
299 free_tracker |= TAXI_LIGHTS;
301 } else if ( !(free_tracker & LIGHTMAPS) ) {
302 free_tracker |= LIGHTMAPS;
307 SG_LOG( SG_TERRAIN, SG_DEBUG, "(end) free_tracker = " << free_tracker );
309 // if we fall down to here, we still have work todo, return false
314 // Update the ssg transform node for this tile so it can be
315 // properly drawn relative to our (0,0,0) point
316 void FGTileEntry::prep_ssg_node( const Point3D& p, sgVec3 up, float vis) {
317 if ( !loaded ) return;
321 // visibility can change from frame to frame so we update the
322 // range selector cutoff's each time.
323 terra_range->setRange( 0, SG_ZERO );
324 terra_range->setRange( 1, vis + bounding_radius );
326 if ( gnd_lights_range ) {
327 gnd_lights_range->setRange( 0, SG_ZERO );
328 gnd_lights_range->setRange( 1, vis * 1.5 + bounding_radius );
332 sgSetVec3( sgTrans, offset.x(), offset.y(), offset.z() );
333 terra_transform->setTransform( sgTrans );
335 FGLight *l = (FGLight *)(globals->get_subsystem("lighting"));
336 if ( gnd_lights_transform ) {
337 // we need to lift the lights above the terrain to avoid
338 // z-buffer fighting. We do this based on our altitude and
339 // the distance this tile is away from scenery center.
341 // we expect 'up' to be a unit vector coming in, but since we
342 // modify the value of lift_vec, we need to create a local
345 sgCopyVec3( lift_vec, up );
348 agl = globals->get_current_view()->getAltitudeASL_ft()
349 * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev();
351 // sgTrans just happens to be the
352 // vector from scenery center to the center of this tile which
353 // is what we want to calculate the distance of
355 sgCopyVec3( to, sgTrans );
356 double dist = sgLengthVec3( to );
358 if ( general.get_glDepthBits() > 16 ) {
359 sgScaleVec3( lift_vec, 10.0 + agl / 100.0 + dist / 10000 );
361 sgScaleVec3( lift_vec, 10.0 + agl / 20.0 + dist / 5000 );
365 sgCopyVec3( lt_trans, sgTrans );
367 sgAddVec3( lt_trans, lift_vec );
368 gnd_lights_transform->setTransform( lt_trans );
370 // select which set of lights based on sun angle
371 float sun_angle = l->get_sun_angle() * SGD_RADIANS_TO_DEGREES;
372 if ( sun_angle > 95 ) {
373 gnd_lights_brightness->select(0x04);
374 } else if ( sun_angle > 92 ) {
375 gnd_lights_brightness->select(0x02);
376 } else if ( sun_angle > 89 ) {
377 gnd_lights_brightness->select(0x01);
379 gnd_lights_brightness->select(0x00);
383 if ( vasi_lights_transform ) {
384 // we need to lift the lights above the terrain to avoid
385 // z-buffer fighting. We do this based on our altitude and
386 // the distance this tile is away from scenery center.
389 sgCopyVec3( lift_vec, up );
391 // we fudge agl by 30 meters so that the lifting function
392 // doesn't phase in until we are > 30m agl.
394 agl = globals->get_current_view()->getAltitudeASL_ft()
395 * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev()
401 if ( general.get_glDepthBits() > 16 ) {
402 sgScaleVec3( lift_vec, 0.25 + agl / 400.0 + agl*agl / 5000000.0 );
404 sgScaleVec3( lift_vec, 0.25 + agl / 150.0 );
408 sgCopyVec3( lt_trans, sgTrans );
410 sgAddVec3( lt_trans, lift_vec );
411 vasi_lights_transform->setTransform( lt_trans );
413 // generally, vasi lights are always on
414 vasi_lights_selector->select(0x01);
417 if ( rwy_lights_transform ) {
418 // we need to lift the lights above the terrain to avoid
419 // z-buffer fighting. We do this based on our altitude and
420 // the distance this tile is away from scenery center.
423 sgCopyVec3( lift_vec, up );
425 // we fudge agl by 30 meters so that the lifting function
426 // doesn't phase in until we are > 30m agl.
428 agl = globals->get_current_view()->getAltitudeASL_ft()
429 * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev()
435 if ( general.get_glDepthBits() > 16 ) {
436 sgScaleVec3( lift_vec, 0.01 + agl / 400.0 + agl*agl / 5000000.0 );
438 sgScaleVec3( lift_vec, 0.25 + agl / 150.0 );
442 sgCopyVec3( lt_trans, sgTrans );
444 sgAddVec3( lt_trans, lift_vec );
445 rwy_lights_transform->setTransform( lt_trans );
447 // turn runway lights on/off based on sun angle and visibility
448 float sun_angle = l->get_sun_angle() * SGD_RADIANS_TO_DEGREES;
449 if ( sun_angle > 85 ||
450 (fgGetDouble("/environment/visibility-m") < 5000.0) ) {
451 rwy_lights_selector->select(0x01);
453 rwy_lights_selector->select(0x00);
457 if ( taxi_lights_transform ) {
458 // we need to lift the lights above the terrain to avoid
459 // z-buffer fighting. We do this based on our altitude and
460 // the distance this tile is away from scenery center.
463 sgCopyVec3( lift_vec, up );
465 // we fudge agl by 30 meters so that the lifting function
466 // doesn't phase in until we are > 30m agl.
468 agl = globals->get_current_view()->getAltitudeASL_ft()
469 * SG_FEET_TO_METER - globals->get_scenery()->get_cur_elev()
475 if ( general.get_glDepthBits() > 16 ) {
476 sgScaleVec3( lift_vec, 0.01 + agl / 400.0 + agl*agl / 5000000.0 );
478 sgScaleVec3( lift_vec, 0.25 + agl / 150.0 );
482 sgCopyVec3( lt_trans, sgTrans );
484 sgAddVec3( lt_trans, lift_vec );
485 taxi_lights_transform->setTransform( lt_trans );
487 // turn taxi lights on/off based on sun angle and visibility
488 float sun_angle = l->get_sun_angle() * SGD_RADIANS_TO_DEGREES;
489 if ( sun_angle > 85 ||
490 (fgGetDouble("/environment/visibility-m") < 5000.0) ) {
491 taxi_lights_selector->select(0x01);
493 taxi_lights_selector->select(0x00);
497 if ( vasi_lights_transform && is_inner_ring ) {
498 // now we need to traverse the list of vasi lights and update
499 // their coloring (but only for the inner ring, no point in
500 // doing this extra work for tiles that are relatively far
502 for ( int i = 0; i < vasi_lights_transform->getNumKids(); ++i ) {
503 // cout << "vasi root = " << i << endl;
504 ssgBranch *v = (ssgBranch *)vasi_lights_transform->getKid(i);
505 for ( int j = 0; j < v->getNumKids(); ++j ) {
506 // cout << " vasi branch = " << j << endl;
507 ssgTransform *kid = (ssgTransform *)v->getKid(j);
508 SGVASIUserData *vasi = (SGVASIUserData *)kid->getUserData();
510 if ( vasi != NULL ) {
512 sgdCopyVec3( s, vasi->get_abs_pos() );
513 Point3D start(s[0], s[1], s[2]);
516 sgdCopyVec3( d, globals->get_current_view()->get_absolute_view_pos() );
518 double dist = sgdDistanceVec3( s, d );
520 if ( dist < 10000 ) {
522 = globals->get_current_view()->getAltitudeASL_ft()
525 double y = cur_alt - vasi->get_alt_m();
529 angle = asin( y / dist );
534 vasi->set_color(angle * SG_RADIANS_TO_DEGREES);
536 // cout << " dist = " << dist
537 // << " angle = " << angle * SG_RADIANS_TO_DEGREES
540 SG_LOG( SG_TERRAIN, SG_ALERT, "no vasi data!" );
548 // Set up lights rendering call backs
549 static int fgLightsPredraw( ssgEntity *e ) {
551 if (glPointParameterIsSupported) {
552 static float quadratic[3] = {1.0, 0.01, 0.0001};
553 glPointParameterfvProc(GL_DISTANCE_ATTENUATION_EXT, quadratic);
554 glPointParameterfProc(GL_POINT_SIZE_MIN_EXT, 1.0);
561 static int fgLightsPostdraw( ssgEntity *e ) {
563 if (glPointParameterIsSupported) {
564 static float default_attenuation[3] = {1.0, 0.0, 0.0};
565 glPointParameterfvProc(GL_DISTANCE_ATTENUATION_EXT,
566 default_attenuation);
574 ssgLeaf* FGTileEntry::gen_lights( SGMaterialLib *matlib, ssgVertexArray *lights,
575 int inc, float bright )
577 // generate a repeatable random seed
578 float *p1 = lights->get( 0 );
579 unsigned int *seed = (unsigned int *)p1;
582 int size = lights->getNum() / inc;
584 // Allocate ssg structure
585 ssgVertexArray *vl = new ssgVertexArray( size + 1 );
586 ssgNormalArray *nl = NULL;
587 ssgTexCoordArray *tl = NULL;
588 ssgColourArray *cl = new ssgColourArray( size + 1 );
591 for ( int i = 0; i < lights->getNum(); ++i ) {
592 // this loop is slightly less efficient than it otherwise
593 // could be, but we want a red light to always be red, and a
594 // yellow light to always be yellow, etc. so we are trying to
595 // preserve the random sequence.
596 float zombie = sg_random();
597 if ( i % inc == 0 ) {
598 vl->add( lights->get(i) );
600 // factor = sg_random() ^ 2, range = 0 .. 1 concentrated towards 0
601 float factor = sg_random();
604 if ( zombie > 0.5 ) {
605 // 50% chance of yellowish
606 sgSetVec4( color, 0.9, 0.9, 0.3, bright - factor * 0.2 );
607 } else if ( zombie > 0.15 ) {
608 // 35% chance of whitish
609 sgSetVec4( color, 0.9, 0.9, 0.8, bright - factor * 0.2 );
610 } else if ( zombie > 0.05 ) {
611 // 10% chance of orangish
612 sgSetVec4( color, 0.9, 0.6, 0.2, bright - factor * 0.2 );
614 // 5% chance of redish
615 sgSetVec4( color, 0.9, 0.2, 0.2, bright - factor * 0.2 );
623 new ssgVtxTable ( GL_POINTS, vl, nl, tl, cl );
626 SGMaterial *mat = matlib->find( "GROUND_LIGHTS" );
627 leaf->setState( mat->get_state() );
628 leaf->setCallback( SSG_CALLBACK_PREDRAW, fgLightsPredraw );
629 leaf->setCallback( SSG_CALLBACK_POSTDRAW, fgLightsPostdraw );
635 bool FGTileEntry::obj_load( const string& path,
637 ssgBranch *vasi_lights,
638 ssgBranch *rwy_lights,
639 ssgBranch *taxi_lights,
640 ssgVertexArray *ground_lights, bool is_base )
642 Point3D c; // returned center point
643 double br; // returned bounding radius
645 bool use_random_objects =
646 fgGetBool("/sim/rendering/random-objects", true);
648 // try loading binary format
649 if ( sgBinObjLoad( path, is_base,
650 &c, &br, globals->get_matlib(), use_random_objects,
651 geometry, vasi_lights, rwy_lights, taxi_lights,
656 bounding_radius = br;
660 return (geometry != NULL);
665 FGTileEntry::load( const string &base_path, bool is_base )
667 SG_LOG( SG_TERRAIN, SG_INFO, "load() base search path = "
670 bool found_tile_base = false;
672 string_list search = sgPathSplit( base_path );
674 // obj_load() will generate ground lighting for us ...
675 ssgVertexArray *light_pts = new ssgVertexArray( 100 );
677 ssgBranch* new_tile = new ssgBranch;
680 while ( i < search.size() ) {
682 bool has_base = false;
684 // Generate names for later use
685 string index_str = tile_bucket.gen_index_str();
687 SGPath tile_path = search[i];
688 tile_path.append( tile_bucket.gen_base_path() );
690 SGPath basename = tile_path;
691 basename.append( index_str );
692 // string path = basename.str();
694 SG_LOG( SG_TERRAIN, SG_INFO, "Loading tile " << basename.str() );
696 #define FG_MAX_LIGHTS 1000
698 // Check for master .stg (scene terra gear) file
699 SGPath stg_name = basename;
700 stg_name.concat( ".stg" );
702 sg_gzifstream in( stg_name.str() );
704 if ( in.is_open() ) {
707 while ( ! in.eof() ) {
710 // Load only once (first found)
711 if ( token == "OBJECT_BASE" ) {
712 in >> name >> ::skipws;
713 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
714 << " name = " << name );
716 if (!found_tile_base) {
717 found_tile_base = true;
720 SGPath custom_path = tile_path;
721 custom_path.append( name );
723 ssgBranch *geometry = new ssgBranch;
724 if ( obj_load( custom_path.str(),
725 geometry, NULL, NULL, NULL, light_pts,
728 geometry->getKid( 0 )->setTravCallback(
729 SSG_CALLBACK_PRETRAV,
730 &FGTileMgr::tile_filter_cb );
731 new_tile -> addKid( geometry );
736 SG_LOG( SG_TERRAIN, SG_INFO, " (skipped)" );
739 // Load only if base is not in another file
740 } else if ( token == "OBJECT" ) {
741 if (!found_tile_base || has_base) {
742 in >> name >> ::skipws;
743 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
744 << " name = " << name );
746 SGPath custom_path = tile_path;
747 custom_path.append( name );
749 ssgBranch *geometry = new ssgBranch;
750 ssgBranch *vasi_lights = new ssgBranch;
751 ssgBranch *rwy_lights = new ssgBranch;
752 ssgBranch *taxi_lights = new ssgBranch;
753 if ( obj_load( custom_path.str(),
754 geometry, vasi_lights, rwy_lights,
755 taxi_lights, NULL, false ) )
757 if ( geometry -> getNumKids() > 0 ) {
758 geometry->getKid( 0 )->setTravCallback(
759 SSG_CALLBACK_PRETRAV,
760 &FGTileMgr::tile_filter_cb );
761 new_tile -> addKid( geometry );
765 if ( vasi_lights -> getNumKids() > 0 ) {
766 vasi_lights_transform -> addKid( vasi_lights );
770 if ( rwy_lights -> getNumKids() > 0 ) {
771 rwy_lights_transform -> addKid( rwy_lights );
775 if ( taxi_lights -> getNumKids() > 0 ) {
776 taxi_lights_transform -> addKid( taxi_lights );
789 } else if ( token == "OBJECT_STATIC" ||
790 token == "OBJECT_SHARED" ) {
792 double lon, lat, elev, hdg;
793 in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
794 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
795 << " name = " << name
796 << " pos = " << lon << ", " << lat
797 << " elevation = " << elev
798 << " heading = " << hdg );
800 // object loading is deferred to main render thread,
801 // but lets figure out the paths right now.
803 if ( token == "OBJECT_STATIC" ) {
804 custom_path= tile_path;
806 custom_path = globals->get_fg_root();
808 custom_path.append( name );
811 WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
813 ssgTransform *obj_trans = new ssgTransform;
814 obj_trans->setTransform( &obj_pos );
816 // wire as much of the scene graph together as we can
817 new_tile->addKid( obj_trans );
819 // bump up the pending models count
822 // push an entry onto the model load queue
824 = new FGDeferredModel( custom_path.str(),
827 FGTileMgr::model_ready( dm );
829 // Do we even use this one?
830 } else if ( token == "OBJECT_TAXI_SIGN" ) {
832 double lon, lat, elev, hdg;
833 in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
834 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
835 << " name = " << name
836 << " pos = " << lon << ", " << lat
837 << " elevation = " << elev
838 << " heading = " << hdg );
840 // load the object itself
841 SGPath custom_path = tile_path;
842 custom_path.append( name );
845 WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
847 ssgTransform *obj_trans = new ssgTransform;
848 obj_trans->setTransform( &obj_pos );
850 ssgBranch *custom_obj
851 = sgMakeTaxiSign( globals->get_matlib(),
852 custom_path.str(), name );
854 // wire the pieces together
855 if ( custom_obj != NULL ) {
856 obj_trans -> addKid( custom_obj );
858 new_tile->addKid( obj_trans );
860 // Do we even use this one?
861 } else if ( token == "OBJECT_RUNWAY_SIGN" ) {
863 double lon, lat, elev, hdg;
864 in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
865 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
866 << " name = " << name
867 << " pos = " << lon << ", " << lat
868 << " elevation = " << elev
869 << " heading = " << hdg );
871 // load the object itself
872 SGPath custom_path = tile_path;
873 custom_path.append( name );
876 WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
878 ssgTransform *obj_trans = new ssgTransform;
879 obj_trans->setTransform( &obj_pos );
881 ssgBranch *custom_obj
882 = sgMakeRunwaySign( globals->get_matlib(),
883 custom_path.str(), name );
885 // wire the pieces together
886 if ( custom_obj != NULL ) {
887 obj_trans -> addKid( custom_obj );
889 new_tile->addKid( obj_trans );
891 // I don't think we use this, either
892 } else if ( token == "RWY_LIGHTS" ) {
893 double lon, lat, hdg, len, width;
894 string common, end1, end2;
895 in >> lon >> lat >> hdg >> len >> width
896 >> common >> end1 >> end2;
897 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
898 << " pos = " << lon << ", " << lat
900 << " size = " << len << ", " << width
901 << " codes = " << common << " "
902 << end1 << " " << end2 );
904 SG_LOG( SG_TERRAIN, SG_DEBUG,
905 "Unknown token " << token << " in "
915 if ( !found_tile_base ) {
916 // no tile base found, generate an ocean tile on the fly for
918 ssgBranch *geometry = new ssgBranch;
921 if ( sgGenTile( search[0], tile_bucket, &c, &br,
922 globals->get_matlib(), geometry ) )
925 bounding_radius = br;
926 new_tile -> addKid( geometry );
929 SG_LOG( SG_TERRAIN, SG_ALERT,
930 "Warning: failed to generate ocean tile!" );
934 if ( new_tile != NULL ) {
935 terra_range->addKid( new_tile );
938 terra_transform->addKid( terra_range );
940 // calculate initial tile offset
941 SetOffset( globals->get_scenery()->get_center() );
943 sgSetCoord( &sgcoord,
944 offset.x(), offset.y(), offset.z(),
946 terra_transform->setTransform( &sgcoord );
947 // terrain->addKid( terra_transform );
949 // Add ground lights to scene graph if any exist
950 gnd_lights_transform = NULL;
951 gnd_lights_range = NULL;
952 if ( light_pts->getNum() ) {
953 SG_LOG( SG_TERRAIN, SG_DEBUG, "generating lights" );
954 gnd_lights_transform = new ssgTransform;
955 gnd_lights_range = new ssgRangeSelector;
956 gnd_lights_brightness = new ssgSelector;
959 lights = gen_lights( globals->get_matlib(), light_pts, 4, 0.7 );
960 gnd_lights_brightness->addKid( lights );
962 lights = gen_lights( globals->get_matlib(), light_pts, 2, 0.85 );
963 gnd_lights_brightness->addKid( lights );
965 lights = gen_lights( globals->get_matlib(), light_pts, 1, 1.0 );
966 gnd_lights_brightness->addKid( lights );
968 gnd_lights_range->addKid( gnd_lights_brightness );
969 gnd_lights_transform->addKid( gnd_lights_range );
970 gnd_lights_transform->setTransform( &sgcoord );
973 // Update vasi lights transform
974 if ( vasi_lights_transform->getNumKids() > 0 ) {
975 vasi_lights_transform->setTransform( &sgcoord );
978 // Update runway lights transform
979 if ( rwy_lights_transform->getNumKids() > 0 ) {
980 rwy_lights_transform->setTransform( &sgcoord );
983 // Update taxi lights transform
984 if ( taxi_lights_transform->getNumKids() > 0 ) {
985 taxi_lights_transform->setTransform( &sgcoord );
991 FGTileEntry::add_ssg_nodes( ssgBranch *terrain_branch,
992 ssgBranch *gnd_lights_branch,
993 ssgBranch *vasi_lights_branch,
994 ssgBranch *rwy_lights_branch,
995 ssgBranch *taxi_lights_branch )
997 // bump up the ref count so we can remove this later without
998 // having ssg try to free the memory.
999 terra_transform->ref();
1000 terrain_branch->addKid( terra_transform );
1002 SG_LOG( SG_TERRAIN, SG_DEBUG,
1003 "connected a tile into scene graph. terra_transform = "
1004 << terra_transform );
1005 SG_LOG( SG_TERRAIN, SG_DEBUG, "num parents now = "
1006 << terra_transform->getNumParents() );
1008 if ( gnd_lights_transform != NULL ) {
1009 // bump up the ref count so we can remove this later without
1010 // having ssg try to free the memory.
1011 gnd_lights_transform->ref();
1012 gnd_lights_branch->addKid( gnd_lights_transform );
1015 if ( vasi_lights_transform != NULL ) {
1016 // bump up the ref count so we can remove this later without
1017 // having ssg try to free the memory.
1018 vasi_lights_selector->ref();
1019 vasi_lights_selector->addKid( vasi_lights_transform );
1020 vasi_lights_branch->addKid( vasi_lights_selector );
1023 if ( rwy_lights_transform != NULL ) {
1024 // bump up the ref count so we can remove this later without
1025 // having ssg try to free the memory.
1026 rwy_lights_selector->ref();
1027 rwy_lights_selector->addKid( rwy_lights_transform );
1028 rwy_lights_branch->addKid( rwy_lights_selector );
1031 if ( taxi_lights_transform != NULL ) {
1032 // bump up the ref count so we can remove this later without
1033 // having ssg try to free the memory.
1034 taxi_lights_selector->ref();
1035 taxi_lights_selector->addKid( taxi_lights_transform );
1036 taxi_lights_branch->addKid( taxi_lights_selector );
1044 FGTileEntry::disconnect_ssg_nodes()
1046 SG_LOG( SG_TERRAIN, SG_DEBUG, "disconnecting ssg nodes" );
1049 SG_LOG( SG_TERRAIN, SG_DEBUG, "removing a not-fully loaded tile!" );
1051 SG_LOG( SG_TERRAIN, SG_DEBUG, "removing a fully loaded tile! terra_transform = " << terra_transform );
1054 // find the terrain branch parent
1055 int pcount = terra_transform->getNumParents();
1057 // find the first parent (should only be one)
1058 ssgBranch *parent = terra_transform->getParent( 0 ) ;
1060 // disconnect the tile (we previously ref()'d it so it
1061 // won't get freed now)
1062 parent->removeKid( terra_transform );
1064 SG_LOG( SG_TERRAIN, SG_ALERT,
1065 "parent pointer is NULL! Dying" );
1069 SG_LOG( SG_TERRAIN, SG_ALERT,
1070 "Parent count is zero for an ssg tile! Dying" );
1074 // find the ground lighting branch
1075 if ( gnd_lights_transform ) {
1076 pcount = gnd_lights_transform->getNumParents();
1078 // find the first parent (should only be one)
1079 ssgBranch *parent = gnd_lights_transform->getParent( 0 ) ;
1081 // disconnect the light branch (we previously ref()'d
1082 // it so it won't get freed now)
1083 parent->removeKid( gnd_lights_transform );
1085 SG_LOG( SG_TERRAIN, SG_ALERT,
1086 "parent pointer is NULL! Dying" );
1090 SG_LOG( SG_TERRAIN, SG_ALERT,
1091 "Parent count is zero for an ssg light tile! Dying" );
1096 // find the vasi lighting branch
1097 if ( vasi_lights_transform ) {
1098 pcount = vasi_lights_transform->getNumParents();
1100 // find the first parent (should only be one)
1101 ssgBranch *parent = vasi_lights_transform->getParent( 0 ) ;
1103 // disconnect the light branch (we previously ref()'d
1104 // it so it won't get freed now)
1105 parent->removeKid( vasi_lights_transform );
1107 SG_LOG( SG_TERRAIN, SG_ALERT,
1108 "parent pointer is NULL! Dying" );
1112 SG_LOG( SG_TERRAIN, SG_ALERT,
1113 "Parent count is zero for an ssg light tile! Dying" );
1118 // find the runway lighting branch
1119 if ( rwy_lights_transform ) {
1120 pcount = rwy_lights_transform->getNumParents();
1122 // find the first parent (should only be one)
1123 ssgBranch *parent = rwy_lights_transform->getParent( 0 ) ;
1125 // disconnect the light branch (we previously ref()'d
1126 // it so it won't get freed now)
1127 parent->removeKid( rwy_lights_transform );
1129 SG_LOG( SG_TERRAIN, SG_ALERT,
1130 "parent pointer is NULL! Dying" );
1134 SG_LOG( SG_TERRAIN, SG_ALERT,
1135 "Parent count is zero for an ssg light tile! Dying" );
1140 // find the taxi lighting branch
1141 if ( taxi_lights_transform ) {
1142 pcount = taxi_lights_transform->getNumParents();
1144 // find the first parent (should only be one)
1145 ssgBranch *parent = taxi_lights_transform->getParent( 0 ) ;
1147 // disconnect the light branch (we previously ref()'d
1148 // it so it won't get freed now)
1149 parent->removeKid( taxi_lights_transform );
1151 SG_LOG( SG_TERRAIN, SG_ALERT,
1152 "parent pointer is NULL! Dying" );
1156 SG_LOG( SG_TERRAIN, SG_ALERT,
1157 "Parent count is zero for an ssg light tile! Dying" );