src/Main/main.cxx

   1 // main.cxx -- top level sim routines
   2 //
   3 // Written by Curtis Olson, started May 1997.
   4 //
   5 // Copyright (C) 1997 - 2002  Curtis L. Olson  - http://www.flightgear.org/~curt
   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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 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 #if defined(__linux__) && defined(__i386__)
  31 #  include <fpu_control.h>
  32 #  include <signal.h>
  33 #endif
  34
  35 #ifdef HAVE_WINDOWS_H
  36 #  include <windows.h>
  37 #  include <float.h>
  38 #endif
  39
  40 #include <plib/netSocket.h>
  41
  42 #include <simgear/props/props.hxx>
  43 #include <simgear/timing/sg_time.hxx>
  44 #include <simgear/math/sg_random.h>
  45
  46 #include <osgDB/Registry>
  47
  48 // Class references
  49 #include <simgear/ephemeris/ephemeris.hxx>
  50 #include <simgear/scene/model/modellib.hxx>
  51 #include <simgear/scene/material/matlib.hxx>
  52 #include <simgear/scene/model/animation.hxx>
  53 #include <simgear/scene/sky/sky.hxx>
  54 #include <Time/light.hxx>
  55 #include <Include/general.hxx>
  56 #include <Aircraft/replay.hxx>
  57 #include <Cockpit/cockpit.hxx>
  58 #include <Cockpit/hud.hxx>
  59 #include <Model/panelnode.hxx>
  60 #include <Model/modelmgr.hxx>
  61 #include <Model/acmodel.hxx>
  62 #include <Scenery/scenery.hxx>
  63 #include <Scenery/tilemgr.hxx>
  64 #include <Sound/beacon.hxx>
  65 #include <Sound/morse.hxx>
  66 #include <FDM/flight.hxx>
  67 #include <ATCDCL/ATCmgr.hxx>
  68 #include <ATCDCL/AIMgr.hxx>
  69 #include <Time/tmp.hxx>
  70 #include <Time/fg_timer.hxx>
  71 #include <Environment/environment_mgr.hxx>
  72 #include <GUI/new_gui.hxx>
  73 #include <MultiPlayer/multiplaymgr.hxx>
  74
  75 #include "fg_commands.hxx"
  76 #include "fg_io.hxx"
  77 #include "renderer.hxx"
  78 #include "splash.hxx"
  79 #include "main.hxx"
  80 #include "util.hxx"
  81
  82
  83 static double real_delta_time_sec = 0.0;
  84 double delta_time_sec = 0.0;
  85 extern float init_volume;
  86
  87 // This is a record containing a bit of global housekeeping information
  88 FGGeneral general;
  89
  90 // Specify our current idle function state.  This is used to run all
  91 // our initializations out of the idle callback so that we can get a
  92 // splash screen up and running right away.
  93 int idle_state = 0;
  94 long global_multi_loop;
  95
  96 SGTimeStamp last_time_stamp;
  97 SGTimeStamp current_time_stamp;
  98
  99 // The atexit() function handler should know when the graphical subsystem
 100 // is initialized.
 101 extern int _bootstrap_OSInit;
 102
 103
 104
 105 // Update internal time dependent calculations (i.e. flight model)
 106 // FIXME: this distinction is obsolete; all subsystems now get delta
 107 // time on update.
 108 void fgUpdateTimeDepCalcs() {
 109     static bool inited = false;
 110
 111     static const SGPropertyNode *replay_state
 112         = fgGetNode( "/sim/freeze/replay-state", true );
 113     static SGPropertyNode *replay_time
 114         = fgGetNode( "/sim/replay/time", true );
 115     // static const SGPropertyNode *replay_end_time
 116     //     = fgGetNode( "/sim/replay/end-time", true );
 117
 118     //SG_LOG(SG_FLIGHT,SG_INFO, "Updating time dep calcs()");
 119
 120     // Initialize the FDM here if it hasn't been and if we have a
 121     // scenery elevation hit.
 122
 123     // cout << "cur_fdm_state->get_inited() = " << cur_fdm_state->get_inited()
 124     //      << " cur_elev = " << scenery.get_cur_elev() << endl;
 125
 126     if (!cur_fdm_state->get_inited()) {
 127         // Check for scenery around the aircraft.
 128         double lon = fgGetDouble("/sim/presets/longitude-deg");
 129         double lat = fgGetDouble("/sim/presets/latitude-deg");
 130         // We require just to have 50 meter scenery availabe around
 131         // the aircraft.
 132         double range = 1000.0;
 133         if (globals->get_scenery()->scenery_available(lat, lon, range)) {
 134             //SG_LOG(SG_FLIGHT, SG_INFO, "Finally initializing fdm");
 135             cur_fdm_state->init();
 136             if ( cur_fdm_state->get_bound() ) {
 137                 cur_fdm_state->unbind();
 138             }
 139             cur_fdm_state->bind();
 140         }
 141     }
 142
 143     // conceptually, the following block could be done for each fdm
 144     // instance ...
 145     if ( cur_fdm_state->get_inited() ) {
 146         // we have been inited, and  we are good to go ...
 147
 148         if ( replay_state->getIntValue() == 0 ) {
 149             // replay off, run fdm
 150             cur_fdm_state->update( delta_time_sec );
 151         } else {
 152             FGReplay *r = (FGReplay *)(globals->get_subsystem( "replay" ));
 153             r->replay( replay_time->getDoubleValue() );
 154             if ( replay_state->getIntValue() == 1 ) {
 155                 // normal playback
 156                 replay_time->setDoubleValue( replay_time->getDoubleValue()
 157                                              + ( delta_time_sec
 158                                                * fgGetInt("/sim/speed-up") ) );
 159             } else if ( replay_state->getIntValue() == 2 ) {
 160                 // paused playback (don't advance replay time)
 161             }
 162         }
 163
 164         if ( !inited ) {
 165             inited = true;
 166             fgSetBool("/sim/signals/fdm-initialized", true);
 167         }
 168
 169     } else {
 170         // do nothing, fdm isn't inited yet
 171     }
 172
 173     globals->get_model_mgr()->update(delta_time_sec);
 174     globals->get_aircraft_model()->update(delta_time_sec);
 175
 176     // Update solar system
 177     globals->get_ephem()->update( globals->get_time_params()->getMjd(),
 178                                   globals->get_time_params()->getLst(),
 179                                   cur_fdm_state->get_Latitude() );
 180
 181 }
 182
 183
 184 void fgInitTimeDepCalcs( void ) {
 185     // noop for now
 186 }
 187
 188
 189 static const double alt_adjust_ft = 3.758099;
 190 static const double alt_adjust_m = alt_adjust_ft * SG_FEET_TO_METER;
 191
 192
 193 // What should we do when we have nothing else to do?  Let's get ready
 194 // for the next move and update the display?
 195 static void fgMainLoop( void ) {
 196     int model_hz = fgGetInt("/sim/model-hz");
 197
 198     static SGConstPropertyNode_ptr longitude
 199         = fgGetNode("/position/longitude-deg");
 200     static SGConstPropertyNode_ptr latitude
 201         = fgGetNode("/position/latitude-deg");
 202     static SGConstPropertyNode_ptr altitude
 203         = fgGetNode("/position/altitude-ft");
 204     static SGConstPropertyNode_ptr clock_freeze
 205         = fgGetNode("/sim/freeze/clock", true);
 206     static SGConstPropertyNode_ptr cur_time_override
 207         = fgGetNode("/sim/time/cur-time-override", true);
 208     static SGConstPropertyNode_ptr max_simtime_per_frame
 209         = fgGetNode("/sim/max-simtime-per-frame", true);
 210     static SGPropertyNode_ptr frame_signal
 211         = fgGetNode("/sim/signals/frame", true);
 212
 213     frame_signal->fireValueChanged();
 214     SGCloudLayer::enable_bump_mapping = fgGetBool("/sim/rendering/bump-mapping");
 215
 216     bool scenery_loaded = fgGetBool("sim/sceneryloaded");
 217     bool wait_for_scenery = !(scenery_loaded || fgGetBool("sim/sceneryloaded-override"));
 218
 219     // Update the elapsed time.
 220     static bool first_time = true;
 221     if ( first_time ) {
 222         last_time_stamp.stamp();
 223         first_time = false;
 224     }
 225
 226     double throttle_hz = fgGetDouble("/sim/frame-rate-throttle-hz", 0.0);
 227     if ( throttle_hz > 0.0 && !wait_for_scenery ) {
 228         // optionally throttle the frame rate (to get consistent frame
 229         // rates or reduce cpu usage.
 230
 231         double frame_us = 1000000.0 / throttle_hz;
 232
 233 #define FG_SLEEP_BASED_TIMING 1
 234 #if defined(FG_SLEEP_BASED_TIMING)
 235         // sleep based timing loop.
 236         //
 237         // Calling sleep, even usleep() on linux is less accurate than
 238         // we like, but it does free up the cpu for other tasks during
 239         // the sleep so it is desirable.  Because of the way sleep()
 240         // is implemented in consumer operating systems like windows
 241         // and linux, you almost always sleep a little longer than the
 242         // requested amount.
 243         //
 244         // To combat the problem of sleeping too long, we calculate the
 245         // desired wait time and shorten it by 2000us (2ms) to avoid
 246         // [hopefully] over-sleep'ing.  The 2ms value was arrived at
 247         // via experimentation.  We follow this up at the end with a
 248         // simple busy-wait loop to get the final pause timing exactly
 249         // right.
 250         //
 251         // Assuming we don't oversleep by more than 2000us, this
 252         // should be a reasonable compromise between sleep based
 253         // waiting, and busy waiting.
 254
 255         // sleep() will always overshoot by a bit so undersleep by
 256         // 2000us in the hopes of never oversleeping.
 257         frame_us -= 2000.0;
 258         if ( frame_us < 0.0 ) {
 259             frame_us = 0.0;
 260         }
 261         current_time_stamp.stamp();
 262         /* Convert to ms */
 263         double elapsed_us = current_time_stamp - last_time_stamp;
 264         if ( elapsed_us < frame_us ) {
 265             double requested_us = frame_us - elapsed_us;
 266             ulMilliSecondSleep ( (int)(requested_us / 1000.0) ) ;
 267         }
 268 #endif
 269
 270         // busy wait timing loop.
 271         //
 272         // This yields the most accurate timing.  If the previous
 273         // ulMilliSecondSleep() call is omitted this will peg the cpu
 274         // (which is just fine if FG is the only app you care about.)
 275         current_time_stamp.stamp();
 276         while ( current_time_stamp - last_time_stamp < frame_us ) {
 277             current_time_stamp.stamp();
 278         }
 279     } else {
 280         // run as fast as the app will go
 281         current_time_stamp.stamp();
 282     }
 283
 284     real_delta_time_sec
 285         = double(current_time_stamp - last_time_stamp) / 1000000.0;
 286
 287     // Limit the time we need to spend in simulation loops
 288     // That means, if the /sim/max-simtime-per-frame value is strictly positive
 289     // you can limit the maximum amount of time you will do simulations for
 290     // one frame to display. The cpu time spent in simulations code is roughly
 291     // at least O(real_delta_time_sec). If this is (due to running debug
 292     // builds or valgrind or something different blowing up execution times)
 293     // larger than the real time you will no longer get any response
 294     // from flightgear. This limits that effect. Just set to property from
 295     // your .fgfsrc or commandline ...
 296     double dtMax = max_simtime_per_frame->getDoubleValue();
 297     if (0 < dtMax && dtMax < real_delta_time_sec)
 298         real_delta_time_sec = dtMax;
 299
 300     // round the real time down to a multiple of 1/model-hz.
 301     // this way all systems are updated the _same_ amount of dt.
 302     {
 303         static double rem = 0.0;
 304         real_delta_time_sec += rem;
 305         double hz = model_hz;
 306         double nit = floor(real_delta_time_sec*hz);
 307         rem = real_delta_time_sec - nit/hz;
 308         real_delta_time_sec = nit/hz;
 309     }
 310
 311
 312     if (clock_freeze->getBoolValue() || wait_for_scenery) {
 313         delta_time_sec = 0;
 314     } else {
 315         delta_time_sec = real_delta_time_sec;
 316     }
 317     last_time_stamp = current_time_stamp;
 318     globals->inc_sim_time_sec( delta_time_sec );
 319
 320     // These are useful, especially for Nasal scripts.
 321     fgSetDouble("/sim/time/delta-realtime-sec", real_delta_time_sec);
 322     fgSetDouble("/sim/time/delta-sec", delta_time_sec);
 323
 324     static long remainder = 0;
 325     long elapsed;
 326 #ifdef FANCY_FRAME_COUNTER
 327     int i;
 328     double accum;
 329 #else
 330     static time_t last_time = 0;
 331     static int frames = 0;
 332 #endif // FANCY_FRAME_COUNTER
 333
 334     SGTime *t = globals->get_time_params();
 335
 336     SG_LOG( SG_ALL, SG_DEBUG, "Running Main Loop");
 337     SG_LOG( SG_ALL, SG_DEBUG, "======= ==== ====");
 338
 339     // Fix elevation.  I'm just sticking this here for now, it should
 340     // probably move eventually
 341
 342     /* printf("Before - ground = %.2f  runway = %.2f  alt = %.2f\n",
 343            scenery.get_cur_elev(),
 344            cur_fdm_state->get_Runway_altitude() * SG_FEET_TO_METER,
 345            cur_fdm_state->get_Altitude() * SG_FEET_TO_METER); */
 346
 347     /* printf("Adjustment - ground = %.2f  runway = %.2f  alt = %.2f\n",
 348            scenery.get_cur_elev(),
 349            cur_fdm_state->get_Runway_altitude() * SG_FEET_TO_METER,
 350            cur_fdm_state->get_Altitude() * SG_FEET_TO_METER); */
 351
 352     // cout << "Warp = " << globals->get_warp() << endl;
 353
 354     // update "time"
 355     static bool last_clock_freeze = false;
 356
 357     if ( clock_freeze->getBoolValue() ) {
 358         // clock freeze requested
 359         if ( cur_time_override->getLongValue() == 0 ) {
 360             fgSetLong( "/sim/time/cur-time-override", t->get_cur_time() );
 361             globals->set_warp( 0 );
 362         }
 363     } else {
 364         // no clock freeze requested
 365         if ( last_clock_freeze == true ) {
 366             // clock just unfroze, let's set warp as the difference
 367             // between frozen time and current time so we don't get a
 368             // time jump (and corresponding sky object and lighting
 369             // jump.)
 370             globals->set_warp( cur_time_override->getLongValue() - time(NULL) );
 371             fgSetLong( "/sim/time/cur-time-override", 0 );
 372         }
 373         if ( globals->get_warp_delta() != 0 ) {
 374             globals->inc_warp( globals->get_warp_delta() );
 375         }
 376     }
 377
 378     last_clock_freeze = clock_freeze->getBoolValue();
 379
 380     t->update( longitude->getDoubleValue() * SGD_DEGREES_TO_RADIANS,
 381                latitude->getDoubleValue() * SGD_DEGREES_TO_RADIANS,
 382                cur_time_override->getLongValue(),
 383                globals->get_warp() );
 384
 385     if (globals->get_warp_delta() != 0) {
 386         FGLight *l = (FGLight *)(globals->get_subsystem("lighting"));
 387         l->update( 0.5 );
 388     }
 389
 390     // update magvar model
 391     globals->get_mag()->update( longitude->getDoubleValue()
 392                                 * SGD_DEGREES_TO_RADIANS,
 393                                 latitude->getDoubleValue()
 394                                 * SGD_DEGREES_TO_RADIANS,
 395                                 altitude->getDoubleValue() * SG_FEET_TO_METER,
 396                                 globals->get_time_params()->getJD() );
 397
 398     // Get elapsed time (in usec) for this past frame
 399     elapsed = fgGetTimeInterval();
 400     SG_LOG( SG_ALL, SG_DEBUG,
 401             "Elapsed time interval is = " << elapsed
 402             << ", previous remainder is = " << remainder );
 403
 404     // Calculate frame rate average
 405 #ifdef FANCY_FRAME_COUNTER
 406     /* old fps calculation */
 407     if ( elapsed > 0 ) {
 408         double tmp;
 409         accum = 0.0;
 410         for ( i = FG_FRAME_RATE_HISTORY - 2; i >= 0; i-- ) {
 411             tmp = general.get_frame(i);
 412             accum += tmp;
 413             // printf("frame[%d] = %.2f\n", i, g->frames[i]);
 414             general.set_frame(i+1,tmp);
 415         }
 416         tmp = 1000000.0 / (float)elapsed;
 417         general.set_frame(0,tmp);
 418         // printf("frame[0] = %.2f\n", general.frames[0]);
 419         accum += tmp;
 420         general.set_frame_rate(accum / (float)FG_FRAME_RATE_HISTORY);
 421         // printf("ave = %.2f\n", general.frame_rate);
 422     }
 423 #else
 424     if ( (t->get_cur_time() != last_time) && (last_time > 0) ) {
 425         general.set_frame_rate( frames );
 426         fgSetInt("/sim/frame-rate", frames);
 427         SG_LOG( SG_ALL, SG_DEBUG,
 428             "--> Frame rate is = " << general.get_frame_rate() );
 429         frames = 0;
 430     }
 431     last_time = t->get_cur_time();
 432     ++frames;
 433 #endif
 434
 435     // Update any multiplayer's network queues, the AIMultiplayer
 436     // implementation is an AI model and depends on that
 437     globals->get_multiplayer_mgr()->Update();
 438
 439     // Run ATC subsystem
 440     if (fgGetBool("/sim/atc/enabled"))
 441         globals->get_ATC_mgr()->update(delta_time_sec);
 442
 443     // Run the AI subsystem
 444     // FIXME: run that also if we have multiplaying enabled since the
 445     // multiplayer information is interpreted by an AI model
 446     if (fgGetBool("/sim/ai-traffic/enabled"))
 447         globals->get_AI_mgr()->update(delta_time_sec);
 448
 449     // Run flight model
 450
 451     // Calculate model iterations needed for next frame
 452     elapsed += remainder;
 453
 454     global_multi_loop = (long)(((double)elapsed * 0.000001) * model_hz );
 455     remainder = elapsed - ( (global_multi_loop*1000000) / model_hz );
 456     SG_LOG( SG_ALL, SG_DEBUG,
 457             "Model iterations needed = " << global_multi_loop
 458             << ", new remainder = " << remainder );
 459
 460     // chop max iterations to something reasonable if the sim was
 461     // delayed for an excessive amount of time
 462     if ( global_multi_loop > 2.0 * model_hz ) {
 463         global_multi_loop = (int)(2.0 * model_hz );
 464         remainder = 0;
 465     }
 466
 467     // flight model
 468     if ( global_multi_loop > 0) {
 469         // first run the flight model each frame until it is initialized
 470         // then continue running each frame only after initial scenery load is complete.
 471         fgUpdateTimeDepCalcs();
 472     } else {
 473         SG_LOG( SG_ALL, SG_DEBUG,
 474             "Elapsed time is zero ... we're zinging" );
 475     }
 476
 477     // Run audio scheduler
 478 #ifdef ENABLE_AUDIO_SUPPORT
 479     if ( globals->get_soundmgr()->is_working() ) {
 480         globals->get_soundmgr()->update( delta_time_sec );
 481     }
 482 #endif
 483
 484     globals->get_subsystem_mgr()->update(delta_time_sec);
 485
 486     //
 487     // Tile Manager updates - see if we need to load any new scenery tiles.
 488     //   this code ties together the fdm, viewer and scenery classes...
 489     //   we may want to move this to its own class at some point
 490     //
 491     double visibility_meters = fgGetDouble("/environment/visibility-m");
 492     FGViewer *current_view = globals->get_current_view();
 493
 494     globals->get_tile_mgr()->prep_ssg_nodes( visibility_meters );
 495     // update tile manager for view...
 496     SGLocation *view_location = globals->get_current_view()->getSGLocation();
 497     globals->get_tile_mgr()->update( view_location, visibility_meters );
 498     {
 499         double lon = view_location->getLongitude_deg();
 500         double lat = view_location->getLatitude_deg();
 501         double alt = view_location->getAltitudeASL_ft() * SG_FEET_TO_METER;
 502
 503         // check if we can reuse the groundcache for that purpose.
 504         double ref_time, r;
 505         SGVec3d pt;
 506         bool valid = cur_fdm_state->is_valid_m(&ref_time, pt.sg(), &r);
 507         SGVec3d viewpos(globals->get_current_view()->get_view_pos());
 508         if (valid && distSqr(viewpos, pt) < r*r) {
 509             // Reuse the cache ...
 510             double lev
 511                 = cur_fdm_state->get_groundlevel_m(lat*SGD_DEGREES_TO_RADIANS,
 512                                                    lon*SGD_DEGREES_TO_RADIANS,
 513                                                    alt + 2.0);
 514             view_location->set_cur_elev_m( lev );
 515         } else {
 516             // Do full intersection test.
 517             double lev;
 518             if (globals->get_scenery()->get_elevation_m(lat, lon, alt+2, lev, 0))
 519                 view_location->set_cur_elev_m( lev );
 520             else
 521                 view_location->set_cur_elev_m( -9999.0 );
 522         }
 523     }
 524
 525     // run Nasal's settimer() loops right before the view manager
 526     globals->get_event_mgr()->update(delta_time_sec);
 527
 528     // update the view angle as late as possible, but before sound calculations
 529     globals->get_viewmgr()->update(delta_time_sec);
 530
 531     // Do any I/O channel work that might need to be done (must come after viewmgr)
 532     globals->get_io()->update(real_delta_time_sec);
 533
 534 #ifdef ENABLE_AUDIO_SUPPORT
 535     // Right now we make a simplifying assumption that the primary
 536     // aircraft is the source of all sounds and that all sounds are
 537     // positioned in the aircraft base
 538
 539     static sgdVec3 last_visitor_pos = {0, 0, 0};
 540     static sgdVec3 last_model_pos = {0, 0, 0};
 541
 542     // get the orientation
 543     const SGQuatd view_or = current_view->getViewOrientation();
 544     SGQuatd surf_or = SGQuatd::fromLonLatDeg(
 545         current_view->getLongitude_deg(), current_view->getLatitude_deg());
 546     SGQuatd model_or = SGQuatd::fromYawPitchRollDeg(
 547         globals->get_aircraft_model()->get3DModel()->getHeadingDeg(),
 548         globals->get_aircraft_model()->get3DModel()->getPitchDeg(),
 549         globals->get_aircraft_model()->get3DModel()->getRollDeg());
 550
 551     // get the up and at vector in the aircraft base
 552     // (ok, the up vector is a down vector, but the coordinates
 553     // are finally calculated in a left hand system and openal
 554     // lives in a right hand system. Therefore we need to pass
 555     // the down vector to get correct stereo sound.)
 556     SGVec3d sgv_up = model_or.rotateBack(
 557         surf_or.rotateBack(view_or.rotate(SGVec3d(0, 1, 0))));
 558     sgVec3 up;
 559     sgSetVec3(up, sgv_up[0], sgv_up[1], sgv_up[2]);
 560     SGVec3d sgv_at = model_or.rotateBack(
 561         surf_or.rotateBack(view_or.rotate(SGVec3d(0, 0, 1))));
 562     sgVec3 at;
 563     sgSetVec3(at, sgv_at[0], sgv_at[1], sgv_at[2]);
 564
 565     // get the location data for the primary FDM (now hardcoded to ac model)...
 566     SGLocation *acmodel_loc = NULL;
 567     acmodel_loc = (SGLocation *)globals->
 568         get_aircraft_model()->get3DModel()->getSGLocation();
 569
 570     // calculate speed of visitor and model
 571     sgVec3 listener_vel, model_vel;
 572     SGVec3d SGV3d_help;
 573     sgdVec3 sgdv3_help;
 574     sgdVec3 sgdv3_null = {0, 0, 0};
 575
 576     sgdSubVec3( sgdv3_help,
 577                 last_visitor_pos, (double *)&current_view->get_view_pos());
 578     sgdAddVec3( last_visitor_pos, sgdv3_null, (double *)&current_view->get_view_pos());
 579     SGV3d_help = model_or.rotateBack(
 580         surf_or.rotateBack(SGVec3d(sgdv3_help[0],
 581         sgdv3_help[1], sgdv3_help[2])));
 582     sgSetVec3( listener_vel, SGV3d_help[0], SGV3d_help[1], SGV3d_help[2]);
 583
 584     sgdSubVec3( sgdv3_help,
 585                 last_model_pos, acmodel_loc->get_absolute_view_pos());
 586     sgdAddVec3( last_model_pos, sgdv3_null, acmodel_loc->get_absolute_view_pos());
 587     SGV3d_help = model_or.rotateBack(
 588         surf_or.rotateBack(SGVec3d(sgdv3_help[0],
 589         sgdv3_help[1], sgdv3_help[2])));
 590     sgSetVec3( model_vel, SGV3d_help[0], SGV3d_help[1], SGV3d_help[2]);
 591
 592     if (delta_time_sec > 0) {
 593         sgScaleVec3( model_vel, 1 / delta_time_sec );
 594         sgScaleVec3( listener_vel, 1 / delta_time_sec );
 595     }
 596
 597     // checking, if the listener pos has moved suddenly
 598     if (sgLengthVec3(listener_vel) > 1000)
 599     {
 600         // check if the relative speed model vs listener has moved suddenly, too
 601         sgVec3 delta_vel;
 602         sgSubVec3(delta_vel, listener_vel, model_vel );
 603         if (sgLengthVec3(delta_vel) > 1000)
 604             sgSetVec3(listener_vel, model_vel[0], model_vel[1], model_vel[2] ); // a sane value
 605         else
 606             globals->get_soundmgr()->set_listener_vel( listener_vel );
 607     }
 608     else
 609         globals->get_soundmgr()->set_listener_vel( listener_vel );
 610
 611     // set positional offset for sources
 612     sgdVec3 dsource_pos_offset;
 613     sgdSubVec3( dsource_pos_offset,
 614                 (double*) &current_view->get_view_pos(),
 615                 acmodel_loc->get_absolute_view_pos() );
 616     SGVec3d sgv_dsource_pos_offset = model_or.rotateBack(
 617         surf_or.rotateBack(SGVec3d(dsource_pos_offset[0],
 618         dsource_pos_offset[1], dsource_pos_offset[2])));
 619
 620     sgVec3 source_pos_offset;
 621     sgSetVec3(source_pos_offset, sgv_dsource_pos_offset[0],
 622         sgv_dsource_pos_offset[1], sgv_dsource_pos_offset[2]);
 623
 624     globals->get_soundmgr()->set_source_pos_all( source_pos_offset );
 625
 626     float orient[6];
 627     for (int i = 0; i < 3; i++) {
 628         orient[i] = sgv_at[i];
 629         orient[i + 3] = sgv_up[i];
 630     }
 631     globals->get_soundmgr()->set_listener_orientation( orient );
 632
 633     // set the velocity
 634     // all sources are defined to be in the model
 635     globals->get_soundmgr()->set_source_vel_all( model_vel );
 636
 637     // The listener is always positioned at the origin.
 638     sgVec3 listener_pos;
 639     sgSetVec3( listener_pos, 0.0, 0.0, 0.0 );
 640     globals->get_soundmgr()->set_listener_pos( listener_pos );
 641 #endif
 642
 643     // END Tile Manager udpates
 644
 645     if (!scenery_loaded && globals->get_tile_mgr()->isSceneryLoaded()
 646         && cur_fdm_state->get_inited()) {
 647         fgSetBool("sim/sceneryloaded",true);
 648         fgSetFloat("/sim/sound/volume", init_volume);
 649         globals->get_soundmgr()->set_volume(init_volume);
 650     }
 651
 652     fgRequestRedraw();
 653
 654     SG_LOG( SG_ALL, SG_DEBUG, "" );
 655 }
 656
 657
 658 // This is the top level master main function that is registered as
 659 // our idle funciton
 660
 661 // The first few passes take care of initialization things (a couple
 662 // per pass) and once everything has been initialized fgMainLoop from
 663 // then on.
 664
 665 static void fgIdleFunction ( void ) {
 666     if ( idle_state == 0 ) {
 667         idle_state++;
 668
 669         // This seems to be the absolute earliest in the init sequence
 670         // that these calls will return valid info.  Too bad it's after
 671         // we've already created and sized our window. :-(
 672         general.set_glVendor( (char *)glGetString ( GL_VENDOR ) );
 673         general.set_glRenderer( (char *)glGetString ( GL_RENDERER ) );
 674         general.set_glVersion( (char *)glGetString ( GL_VERSION ) );
 675         SG_LOG( SG_GENERAL, SG_INFO, general.get_glRenderer() );
 676
 677         GLint tmp;
 678         glGetIntegerv( GL_MAX_TEXTURE_SIZE, &tmp );
 679         general.set_glMaxTexSize( tmp );
 680         SG_LOG ( SG_GENERAL, SG_INFO, "Max texture size = " << tmp );
 681
 682         glGetIntegerv( GL_DEPTH_BITS, &tmp );
 683         general.set_glDepthBits( tmp );
 684         SG_LOG ( SG_GENERAL, SG_INFO, "Depth buffer bits = " << tmp );
 685
 686         // Initialize the user interface so that we can use fonts
 687         guiStartInit();
 688
 689
 690     } else if ( idle_state == 1 ) {
 691         if (!guiFinishInit())
 692             return;
 693         idle_state++;
 694         fgSplashProgress("reading aircraft list");
 695
 696
 697     } else if ( idle_state == 2 ) {
 698         idle_state++;
 699         // Read the list of available aircraft
 700         fgReadAircraft();
 701         fgSplashProgress("reading airport & navigation data");
 702
 703
 704     } else if ( idle_state == 3 ) {
 705         idle_state++;
 706         fgInitNav();
 707         fgSplashProgress("setting up scenery");
 708
 709
 710     } else if ( idle_state == 4 ) {
 711         idle_state++;
 712         // based on the requested presets, calculate the true starting
 713         // lon, lat
 714         fgInitPosition();
 715         fgInitTowerLocationListener();
 716
 717         SGTime *t = fgInitTime();
 718         globals->set_time_params( t );
 719
 720         // Do some quick general initializations
 721         if( !fgInitGeneral()) {
 722             SG_LOG( SG_GENERAL, SG_ALERT,
 723                 "General initialization failed ..." );
 724             exit(-1);
 725         }
 726
 727         ////////////////////////////////////////////////////////////////////
 728         // Initialize the property-based built-in commands
 729         ////////////////////////////////////////////////////////////////////
 730         fgInitCommands();
 731
 732
 733         ////////////////////////////////////////////////////////////////////
 734         // Initialize the material manager
 735         ////////////////////////////////////////////////////////////////////
 736         globals->set_matlib( new SGMaterialLib );
 737         simgear::SGModelLib::init(globals->get_fg_root());
 738
 739
 740         ////////////////////////////////////////////////////////////////////
 741         // Initialize the TG scenery subsystem.
 742         ////////////////////////////////////////////////////////////////////
 743         globals->set_scenery( new FGScenery );
 744         globals->get_scenery()->init();
 745         globals->get_scenery()->bind();
 746         globals->set_tile_mgr( new FGTileMgr );
 747
 748
 749         ////////////////////////////////////////////////////////////////////
 750         // Initialize the general model subsystem.
 751         ////////////////////////////////////////////////////////////////////
 752         globals->set_model_mgr(new FGModelMgr);
 753         globals->get_model_mgr()->init();
 754         globals->get_model_mgr()->bind();
 755         fgSplashProgress("loading aircraft");
 756
 757
 758     } else if ( idle_state == 5 ) {
 759         idle_state++;
 760         ////////////////////////////////////////////////////////////////////
 761         // Initialize the 3D aircraft model subsystem (has a dependency on
 762         // the scenery subsystem.)
 763         ////////////////////////////////////////////////////////////////////
 764         globals->set_aircraft_model(new FGAircraftModel);
 765         globals->get_aircraft_model()->init();
 766         globals->get_aircraft_model()->bind();
 767
 768         ////////////////////////////////////////////////////////////////////
 769         // Initialize the view manager subsystem.
 770         ////////////////////////////////////////////////////////////////////
 771         FGViewMgr *viewmgr = new FGViewMgr;
 772         globals->set_viewmgr( viewmgr );
 773         viewmgr->init();
 774         viewmgr->bind();
 775         fgSplashProgress("generating sky elements");
 776
 777
 778     } else if ( idle_state == 6 ) {
 779         idle_state++;
 780         // Initialize the sky
 781         SGPath ephem_data_path( globals->get_fg_root() );
 782         ephem_data_path.append( "Astro" );
 783         SGEphemeris *ephem = new SGEphemeris( ephem_data_path.c_str() );
 784         ephem->update( globals->get_time_params()->getMjd(),
 785                        globals->get_time_params()->getLst(),
 786                        0.0 );
 787         globals->set_ephem( ephem );
 788
 789         // TODO: move to environment mgr
 790         thesky = new SGSky;
 791         SGPath texture_path(globals->get_fg_root());
 792         texture_path.append("Textures");
 793         texture_path.append("Sky");
 794         for (int i = 0; i < FGEnvironmentMgr::MAX_CLOUD_LAYERS; i++) {
 795             SGCloudLayer * layer = new SGCloudLayer(texture_path.str());
 796             thesky->add_cloud_layer(layer);
 797         }
 798
 799         SGPath sky_tex_path( globals->get_fg_root() );
 800         sky_tex_path.append( "Textures" );
 801         sky_tex_path.append( "Sky" );
 802         thesky->texture_path( sky_tex_path.str() );
 803
 804         // The sun and moon diameters are scaled down numbers of the
 805         // actual diameters. This was needed to fit both the sun and the
 806         // moon within the distance to the far clip plane.
 807         // Moon diameter:    3,476 kilometers
 808         // Sun diameter: 1,390,000 kilometers
 809         thesky->build( 80000.0, 80000.0,
 810                        463.3, 361.8,
 811                        globals->get_ephem()->getNumPlanets(),
 812                        globals->get_ephem()->getPlanets(),
 813                        globals->get_ephem()->getNumStars(),
 814                        globals->get_ephem()->getStars(),
 815                        fgGetNode("/environment", true));
 816
 817         // Initialize MagVar model
 818         SGMagVar *magvar = new SGMagVar();
 819         globals->set_mag( magvar );
 820
 821
 822                                     // kludge to initialize mag compass
 823                                     // (should only be done for in-flight
 824                                     // startup)
 825         // update magvar model
 826         globals->get_mag()->update( fgGetDouble("/position/longitude-deg")
 827                                     * SGD_DEGREES_TO_RADIANS,
 828                                     fgGetDouble("/position/latitude-deg")
 829                                     * SGD_DEGREES_TO_RADIANS,
 830                                     fgGetDouble("/position/altitude-ft")
 831                                     * SG_FEET_TO_METER,
 832                                     globals->get_time_params()->getJD() );
 833         double var = globals->get_mag()->get_magvar() * SGD_RADIANS_TO_DEGREES;
 834         fgSetDouble("/instrumentation/heading-indicator/offset-deg", -var);
 835         fgSetDouble("/instrumentation/heading-indicator-fg/offset-deg", -var);
 836
 837
 838         // airport = new ssgBranch;
 839         // airport->setName( "Airport Lighting" );
 840         // lighting->addKid( airport );
 841
 842         // build our custom render states
 843         fgSplashProgress("initializing subsystems");
 844
 845
 846     } else if ( idle_state == 7 ) {
 847         idle_state++;
 848         // Initialize audio support
 849 #ifdef ENABLE_AUDIO_SUPPORT
 850
 851         // Start the intro music
 852         if ( fgGetBool("/sim/startup/intro-music") ) {
 853             SGPath mp3file( globals->get_fg_root() );
 854             mp3file.append( "Sounds/intro.mp3" );
 855
 856             SG_LOG( SG_GENERAL, SG_INFO,
 857                 "Starting intro music: " << mp3file.str() );
 858
 859 #if defined( __CYGWIN__ )
 860             string command = "start /m `cygpath -w " + mp3file.str() + "`";
 861 #elif defined( WIN32 )
 862             string command = "start /m " + mp3file.str();
 863 #else
 864             string command = "mpg123 " + mp3file.str() + "> /dev/null 2>&1";
 865 #endif
 866
 867             system ( command.c_str() );
 868         }
 869 #endif
 870         // This is the top level init routine which calls all the
 871         // other subsystem initialization routines.  If you are adding
 872         // a subsystem to flightgear, its initialization call should be
 873         // located in this routine.
 874         if( !fgInitSubsystems()) {
 875             SG_LOG( SG_GENERAL, SG_ALERT,
 876                 "Subsystem initialization failed ..." );
 877             exit(-1);
 878         }
 879         fgSplashProgress("setting up time & renderer");
 880
 881
 882     } else if ( idle_state == 8 ) {
 883         idle_state = 1000;
 884         // Initialize the time offset (warp) after fgInitSubsystem
 885         // (which initializes the lighting interpolation tables.)
 886         fgInitTimeOffset();
 887
 888         // setup OpenGL view parameters
 889         globals->get_renderer()->init();
 890
 891         SG_LOG( SG_GENERAL, SG_INFO, "Panel visible = " << fgPanelVisible() );
 892         globals->get_renderer()->resize( fgGetInt("/sim/startup/xsize"),
 893                                          fgGetInt("/sim/startup/ysize") );
 894
 895         fgSplashProgress("loading scenery objects");
 896
 897     }
 898
 899     if ( idle_state == 1000 ) {
 900         // We've finished all our initialization steps, from now on we
 901         // run the main loop.
 902         fgSetBool("sim/sceneryloaded", false);
 903         fgRegisterIdleHandler( fgMainLoop );
 904     }
 905 }
 906
 907
 908 static void upper_case_property(const char *name)
 909 {
 910     SGPropertyNode *p = fgGetNode(name, false);
 911     if (!p) {
 912         p = fgGetNode(name, true);
 913         p->setStringValue("");
 914     } else {
 915         SGPropertyNode::Type t = p->getType();
 916         if (t == SGPropertyNode::NONE || t == SGPropertyNode::UNSPECIFIED)
 917             p->setStringValue("");
 918         else
 919             assert(t == SGPropertyNode::STRING);
 920     }
 921     p->addChangeListener(new FGMakeUpperCase);
 922 }
 923
 924
 925 // Main top level initialization
 926 bool fgMainInit( int argc, char **argv ) {
 927
 928     // set default log levels
 929     sglog().setLogLevels( SG_ALL, SG_ALERT );
 930
 931     string version;
 932 #ifdef FLIGHTGEAR_VERSION
 933     version = FLIGHTGEAR_VERSION;
 934 #else
 935     version = "unknown version";
 936 #endif
 937     SG_LOG( SG_GENERAL, SG_INFO, "FlightGear:  Version "
 938             << version );
 939     SG_LOG( SG_GENERAL, SG_INFO, "Built with " << SG_COMPILER_STR << endl );
 940
 941     // Allocate global data structures.  This needs to happen before
 942     // we parse command line options
 943
 944     globals = new FGGlobals;
 945
 946     // seed the random number generator
 947     sg_srandom_time();
 948
 949     FGControls *controls = new FGControls;
 950     globals->set_controls( controls );
 951
 952     string_list *col = new string_list;
 953     globals->set_channel_options_list( col );
 954
 955     fgValidatePath("", false);  // initialize static variables
 956     upper_case_property("/sim/presets/airport-id");
 957     upper_case_property("/sim/presets/runway");
 958     upper_case_property("/sim/tower/airport-id");
 959     upper_case_property("/autopilot/route-manager/input");
 960
 961     // Scan the config file(s) and command line options to see if
 962     // fg_root was specified (ignore all other options for now)
 963     fgInitFGRoot(argc, argv);
 964
 965     // Check for the correct base package version
 966     static char required_version[] = "1.0.0";
 967     string base_version = fgBasePackageVersion();
 968     if ( !(base_version == required_version) ) {
 969         // tell the operator how to use this application
 970
 971         SG_LOG( SG_GENERAL, SG_ALERT, "" ); // To popup the console on windows
 972         cerr << endl << "Base package check failed ... " \
 973              << "Found version " << base_version << " at: " \
 974              << globals->get_fg_root() << endl;
 975         cerr << "Please upgrade to version: " << required_version << endl;
 976 #ifdef _MSC_VER
 977         cerr << "Hit a key to continue..." << endl;
 978         cin.get();
 979 #endif
 980         exit(-1);
 981     }
 982
 983     // Load the configuration parameters.  (Command line options
 984     // override config file options.  Config file options override
 985     // defaults.)
 986     if ( !fgInitConfig(argc, argv) ) {
 987         SG_LOG( SG_GENERAL, SG_ALERT, "Config option parsing failed ..." );
 988         exit(-1);
 989     }
 990
 991     // Initialize the Window/Graphics environment.
 992     fgOSInit(&argc, argv);
 993     _bootstrap_OSInit++;
 994
 995     fgRegisterWindowResizeHandler( &FGRenderer::resize );
 996     fgRegisterIdleHandler( &fgIdleFunction );
 997     fgRegisterDrawHandler( &FGRenderer::update );
 998
 999 #ifdef FG_ENABLE_MULTIPASS_CLOUDS
1000     bool get_stencil_buffer = true;
1001 #else
1002     bool get_stencil_buffer = false;
1003 #endif
1004
1005     // Initialize plib net interface
1006     netInit( &argc, argv );
1007
1008     // Clouds3D requires an alpha channel
1009     // clouds may require stencil buffer
1010     fgOSOpenWindow(get_stencil_buffer);
1011
1012     // Initialize the splash screen right away
1013     fntInit();
1014     fgSplashInit();
1015
1016     // pass control off to the master event handler
1017     fgOSMainLoop();
1018
1019     // we never actually get here ... but to avoid compiler warnings,
1020     // etc.
1021     return false;
1022 }
1023
1024