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_list &path_list, bool is_base )
667 bool found_tile_base = false;
669 // obj_load() will generate ground lighting for us ...
670 ssgVertexArray *light_pts = new ssgVertexArray( 100 );
672 ssgBranch* new_tile = new ssgBranch;
675 while ( i < path_list.size() ) {
677 bool has_base = false;
679 // Generate names for later use
680 string index_str = tile_bucket.gen_index_str();
682 SGPath tile_path = path_list[i];
683 tile_path.append( tile_bucket.gen_base_path() );
685 SGPath basename = tile_path;
686 basename.append( index_str );
687 // string path = basename.str();
689 SG_LOG( SG_TERRAIN, SG_INFO, "Loading tile " << basename.str() );
691 #define FG_MAX_LIGHTS 1000
693 // Check for master .stg (scene terra gear) file
694 SGPath stg_name = basename;
695 stg_name.concat( ".stg" );
697 sg_gzifstream in( stg_name.str() );
699 if ( in.is_open() ) {
702 while ( ! in.eof() ) {
705 // Load only once (first found)
706 if ( token == "OBJECT_BASE" ) {
707 in >> name >> ::skipws;
708 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
709 << " name = " << name );
711 if (!found_tile_base) {
712 found_tile_base = true;
715 SGPath custom_path = tile_path;
716 custom_path.append( name );
718 ssgBranch *geometry = new ssgBranch;
719 if ( obj_load( custom_path.str(),
720 geometry, NULL, NULL, NULL, light_pts,
723 geometry->getKid( 0 )->setTravCallback(
724 SSG_CALLBACK_PRETRAV,
725 &FGTileMgr::tile_filter_cb );
726 new_tile -> addKid( geometry );
731 SG_LOG( SG_TERRAIN, SG_INFO, " (skipped)" );
734 // Load only if base is not in another file
735 } else if ( token == "OBJECT" ) {
736 if (!found_tile_base || has_base) {
737 in >> name >> ::skipws;
738 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
739 << " name = " << name );
741 SGPath custom_path = tile_path;
742 custom_path.append( name );
744 ssgBranch *geometry = new ssgBranch;
745 ssgBranch *vasi_lights = new ssgBranch;
746 ssgBranch *rwy_lights = new ssgBranch;
747 ssgBranch *taxi_lights = new ssgBranch;
748 if ( obj_load( custom_path.str(),
749 geometry, vasi_lights, rwy_lights,
750 taxi_lights, NULL, false ) )
752 if ( geometry -> getNumKids() > 0 ) {
753 geometry->getKid( 0 )->setTravCallback(
754 SSG_CALLBACK_PRETRAV,
755 &FGTileMgr::tile_filter_cb );
756 new_tile -> addKid( geometry );
760 if ( vasi_lights -> getNumKids() > 0 ) {
761 vasi_lights_transform -> addKid( vasi_lights );
765 if ( rwy_lights -> getNumKids() > 0 ) {
766 rwy_lights_transform -> addKid( rwy_lights );
770 if ( taxi_lights -> getNumKids() > 0 ) {
771 taxi_lights_transform -> addKid( taxi_lights );
784 } else if ( token == "OBJECT_STATIC" ||
785 token == "OBJECT_SHARED" ) {
787 double lon, lat, elev, hdg;
788 in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
789 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
790 << " name = " << name
791 << " pos = " << lon << ", " << lat
792 << " elevation = " << elev
793 << " heading = " << hdg );
795 // object loading is deferred to main render thread,
796 // but lets figure out the paths right now.
798 if ( token == "OBJECT_STATIC" ) {
799 custom_path= tile_path;
801 custom_path = globals->get_fg_root();
803 custom_path.append( name );
806 WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
808 ssgTransform *obj_trans = new ssgTransform;
809 obj_trans->setTransform( &obj_pos );
811 // wire as much of the scene graph together as we can
812 new_tile->addKid( obj_trans );
814 // bump up the pending models count
817 // push an entry onto the model load queue
819 = new FGDeferredModel( custom_path.str(),
823 FGTileMgr::model_ready( dm );
825 // Do we even use this one?
826 } else if ( token == "OBJECT_TAXI_SIGN" ) {
828 double lon, lat, elev, hdg;
829 in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
830 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
831 << " name = " << name
832 << " pos = " << lon << ", " << lat
833 << " elevation = " << elev
834 << " heading = " << hdg );
836 // load the object itself
837 SGPath custom_path = tile_path;
838 custom_path.append( name );
841 WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
843 ssgTransform *obj_trans = new ssgTransform;
844 obj_trans->setTransform( &obj_pos );
846 ssgBranch *custom_obj
847 = sgMakeTaxiSign( globals->get_matlib(),
848 custom_path.str(), name );
850 // wire the pieces together
851 if ( custom_obj != NULL ) {
852 obj_trans -> addKid( custom_obj );
854 new_tile->addKid( obj_trans );
856 // Do we even use this one?
857 } else if ( token == "OBJECT_RUNWAY_SIGN" ) {
859 double lon, lat, elev, hdg;
860 in >> name >> lon >> lat >> elev >> hdg >> ::skipws;
861 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
862 << " name = " << name
863 << " pos = " << lon << ", " << lat
864 << " elevation = " << elev
865 << " heading = " << hdg );
867 // load the object itself
868 SGPath custom_path = tile_path;
869 custom_path.append( name );
872 WorldCoordinate( &obj_pos, center, lat, lon, elev, hdg );
874 ssgTransform *obj_trans = new ssgTransform;
875 obj_trans->setTransform( &obj_pos );
877 ssgBranch *custom_obj
878 = sgMakeRunwaySign( globals->get_matlib(),
879 custom_path.str(), name );
881 // wire the pieces together
882 if ( custom_obj != NULL ) {
883 obj_trans -> addKid( custom_obj );
885 new_tile->addKid( obj_trans );
887 // I don't think we use this, either
888 } else if ( token == "RWY_LIGHTS" ) {
889 double lon, lat, hdg, len, width;
890 string common, end1, end2;
891 in >> lon >> lat >> hdg >> len >> width
892 >> common >> end1 >> end2;
893 SG_LOG( SG_TERRAIN, SG_INFO, "token = " << token
894 << " pos = " << lon << ", " << lat
896 << " size = " << len << ", " << width
897 << " codes = " << common << " "
898 << end1 << " " << end2 );
900 SG_LOG( SG_TERRAIN, SG_DEBUG,
901 "Unknown token " << token << " in "
911 if ( !found_tile_base ) {
912 // no tile base found, generate an ocean tile on the fly for
914 ssgBranch *geometry = new ssgBranch;
917 if ( sgGenTile( path_list[0], tile_bucket, &c, &br,
918 globals->get_matlib(), geometry ) )
921 bounding_radius = br;
922 new_tile -> addKid( geometry );
925 SG_LOG( SG_TERRAIN, SG_ALERT,
926 "Warning: failed to generate ocean tile!" );
930 if ( new_tile != NULL ) {
931 terra_range->addKid( new_tile );
934 terra_transform->addKid( terra_range );
936 // calculate initial tile offset
937 SetOffset( globals->get_scenery()->get_center() );
939 sgSetCoord( &sgcoord,
940 offset.x(), offset.y(), offset.z(),
942 terra_transform->setTransform( &sgcoord );
943 // terrain->addKid( terra_transform );
945 // Add ground lights to scene graph if any exist
946 gnd_lights_transform = NULL;
947 gnd_lights_range = NULL;
948 if ( light_pts->getNum() ) {
949 SG_LOG( SG_TERRAIN, SG_DEBUG, "generating lights" );
950 gnd_lights_transform = new ssgTransform;
951 gnd_lights_range = new ssgRangeSelector;
952 gnd_lights_brightness = new ssgSelector;
955 lights = gen_lights( globals->get_matlib(), light_pts, 4, 0.7 );
956 gnd_lights_brightness->addKid( lights );
958 lights = gen_lights( globals->get_matlib(), light_pts, 2, 0.85 );
959 gnd_lights_brightness->addKid( lights );
961 lights = gen_lights( globals->get_matlib(), light_pts, 1, 1.0 );
962 gnd_lights_brightness->addKid( lights );
964 gnd_lights_range->addKid( gnd_lights_brightness );
965 gnd_lights_transform->addKid( gnd_lights_range );
966 gnd_lights_transform->setTransform( &sgcoord );
969 // Update vasi lights transform
970 if ( vasi_lights_transform->getNumKids() > 0 ) {
971 vasi_lights_transform->setTransform( &sgcoord );
974 // Update runway lights transform
975 if ( rwy_lights_transform->getNumKids() > 0 ) {
976 rwy_lights_transform->setTransform( &sgcoord );
979 // Update taxi lights transform
980 if ( taxi_lights_transform->getNumKids() > 0 ) {
981 taxi_lights_transform->setTransform( &sgcoord );
986 FGTileEntry::makeDList( ssgBranch *b )
988 int nb = b->getNumKids();
989 for (int i = 0; i<nb; i++) {
990 ssgEntity *e = b->getKid(i);
991 if (e->isAKindOf(ssgTypeLeaf())) {
992 ((ssgLeaf*)e)->makeDList();
993 } else if (e->isAKindOf(ssgTypeBranch())) {
994 makeDList( (ssgBranch*)e );
1000 FGTileEntry::add_ssg_nodes( ssgBranch *terrain_branch,
1001 ssgBranch *gnd_lights_branch,
1002 ssgBranch *vasi_lights_branch,
1003 ssgBranch *rwy_lights_branch,
1004 ssgBranch *taxi_lights_branch )
1006 // bump up the ref count so we can remove this later without
1007 // having ssg try to free the memory.
1008 makeDList( terra_transform );
1010 terra_transform->ref();
1011 terrain_branch->addKid( terra_transform );
1013 SG_LOG( SG_TERRAIN, SG_DEBUG,
1014 "connected a tile into scene graph. terra_transform = "
1015 << terra_transform );
1016 SG_LOG( SG_TERRAIN, SG_DEBUG, "num parents now = "
1017 << terra_transform->getNumParents() );
1019 if ( gnd_lights_transform != NULL ) {
1020 // bump up the ref count so we can remove this later without
1021 // having ssg try to free the memory.
1022 gnd_lights_transform->ref();
1023 gnd_lights_branch->addKid( gnd_lights_transform );
1026 if ( vasi_lights_transform != NULL ) {
1027 // bump up the ref count so we can remove this later without
1028 // having ssg try to free the memory.
1029 vasi_lights_selector->ref();
1030 vasi_lights_selector->addKid( vasi_lights_transform );
1031 vasi_lights_branch->addKid( vasi_lights_selector );
1034 if ( rwy_lights_transform != NULL ) {
1035 // bump up the ref count so we can remove this later without
1036 // having ssg try to free the memory.
1037 rwy_lights_selector->ref();
1038 rwy_lights_selector->addKid( rwy_lights_transform );
1039 rwy_lights_branch->addKid( rwy_lights_selector );
1042 if ( taxi_lights_transform != NULL ) {
1043 // bump up the ref count so we can remove this later without
1044 // having ssg try to free the memory.
1045 taxi_lights_selector->ref();
1046 taxi_lights_selector->addKid( taxi_lights_transform );
1047 taxi_lights_branch->addKid( taxi_lights_selector );
1055 FGTileEntry::disconnect_ssg_nodes()
1057 SG_LOG( SG_TERRAIN, SG_DEBUG, "disconnecting ssg nodes" );
1060 SG_LOG( SG_TERRAIN, SG_DEBUG, "removing a not-fully loaded tile!" );
1062 SG_LOG( SG_TERRAIN, SG_DEBUG, "removing a fully loaded tile! terra_transform = " << terra_transform );
1065 // find the terrain branch parent
1066 int pcount = terra_transform->getNumParents();
1068 // find the first parent (should only be one)
1069 ssgBranch *parent = terra_transform->getParent( 0 ) ;
1071 // disconnect the tile (we previously ref()'d it so it
1072 // won't get freed now)
1073 parent->removeKid( terra_transform );
1075 SG_LOG( SG_TERRAIN, SG_ALERT,
1076 "parent pointer is NULL! Dying" );
1080 SG_LOG( SG_TERRAIN, SG_ALERT,
1081 "Parent count is zero for an ssg tile! Dying" );
1085 // find the ground lighting branch
1086 if ( gnd_lights_transform ) {
1087 pcount = gnd_lights_transform->getNumParents();
1089 // find the first parent (should only be one)
1090 ssgBranch *parent = gnd_lights_transform->getParent( 0 ) ;
1092 // disconnect the light branch (we previously ref()'d
1093 // it so it won't get freed now)
1094 parent->removeKid( gnd_lights_transform );
1096 SG_LOG( SG_TERRAIN, SG_ALERT,
1097 "parent pointer is NULL! Dying" );
1101 SG_LOG( SG_TERRAIN, SG_ALERT,
1102 "Parent count is zero for an ssg light tile! Dying" );
1107 // find the vasi lighting branch
1108 if ( vasi_lights_transform ) {
1109 pcount = vasi_lights_transform->getNumParents();
1111 // find the first parent (should only be one)
1112 ssgBranch *parent = vasi_lights_transform->getParent( 0 ) ;
1114 // disconnect the light branch (we previously ref()'d
1115 // it so it won't get freed now)
1116 parent->removeKid( vasi_lights_transform );
1118 SG_LOG( SG_TERRAIN, SG_ALERT,
1119 "parent pointer is NULL! Dying" );
1123 SG_LOG( SG_TERRAIN, SG_ALERT,
1124 "Parent count is zero for an ssg light tile! Dying" );
1129 // find the runway lighting branch
1130 if ( rwy_lights_transform ) {
1131 pcount = rwy_lights_transform->getNumParents();
1133 // find the first parent (should only be one)
1134 ssgBranch *parent = rwy_lights_transform->getParent( 0 ) ;
1136 // disconnect the light branch (we previously ref()'d
1137 // it so it won't get freed now)
1138 parent->removeKid( rwy_lights_transform );
1140 SG_LOG( SG_TERRAIN, SG_ALERT,
1141 "parent pointer is NULL! Dying" );
1145 SG_LOG( SG_TERRAIN, SG_ALERT,
1146 "Parent count is zero for an ssg light tile! Dying" );
1151 // find the taxi lighting branch
1152 if ( taxi_lights_transform ) {
1153 pcount = taxi_lights_transform->getNumParents();
1155 // find the first parent (should only be one)
1156 ssgBranch *parent = taxi_lights_transform->getParent( 0 ) ;
1158 // disconnect the light branch (we previously ref()'d
1159 // it so it won't get freed now)
1160 parent->removeKid( taxi_lights_transform );
1162 SG_LOG( SG_TERRAIN, SG_ALERT,
1163 "parent pointer is NULL! Dying" );
1167 SG_LOG( SG_TERRAIN, SG_ALERT,
1168 "Parent count is zero for an ssg light tile! Dying" );