1 // TimeManager.cxx -- simulation-wide time management
3 // Written by James Turner, started July 2010.
5 // Copyright (C) 2010 Curtis L. Olson - http://www.flightgear.org/~curt
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
25 #include "TimeManager.hxx"
27 #include <simgear/timing/sg_time.hxx>
28 #include <simgear/structure/event_mgr.hxx>
29 #include <simgear/misc/sg_path.hxx>
30 #include <simgear/timing/lowleveltime.h>
31 #include <simgear/structure/commands.hxx>
33 #include <Main/fg_props.hxx>
34 #include <Main/globals.hxx>
35 #include <Time/sunsolver.hxx>
39 static bool do_timeofday (const SGPropertyNode * arg)
41 const string &offset_type = arg->getStringValue("timeofday", "noon");
42 int offset = arg->getIntValue("offset", 0);
43 TimeManager* self = (TimeManager*) globals->get_subsystem("time");
44 if (offset_type == "real") {
45 // without this, setting 'real' time is a no-op, since the current
46 // wrap value (orig_warp) is retained in setTimeOffset. Ick.
47 fgSetInt("/sim/time/warp", 0);
50 self->setTimeOffset(offset_type, offset);
54 TimeManager::TimeManager() :
58 SGCommandMgr::instance()->addCommand("timeofday", do_timeofday);
61 void TimeManager::init()
64 // time manager has to be initialised early, so needs to be defensive
65 // about multiple initialisation
72 _adjustWarpOnUnfreeze = false;
74 _maxDtPerFrame = fgGetNode("/sim/max-simtime-per-frame", true);
75 _clockFreeze = fgGetNode("/sim/freeze/clock", true);
76 _timeOverride = fgGetNode("/sim/time/cur-time-override", true);
77 _warp = fgGetNode("/sim/time/warp", true);
78 _warp->addChangeListener(this);
80 _warpDelta = fgGetNode("/sim/time/warp-delta", true);
82 _longitudeDeg = fgGetNode("/position/longitude-deg", true);
83 _latitudeDeg = fgGetNode("/position/latitude-deg", true);
85 SGPath zone(globals->get_fg_root());
86 zone.append("Timezone");
87 double lon = _longitudeDeg->getDoubleValue() * SG_DEGREES_TO_RADIANS;
88 double lat = _latitudeDeg->getDoubleValue() * SG_DEGREES_TO_RADIANS;
90 _impl = new SGTime(lon, lat, zone.str(), _timeOverride->getLongValue());
92 _warpDelta->setIntValue(0);
94 globals->get_event_mgr()->addTask("updateLocalTime", this,
95 &TimeManager::updateLocalTime, 30*60 );
98 _impl->update(lon, lat, _timeOverride->getLongValue(),
99 _warp->getIntValue());
100 globals->set_time_params(_impl);
102 // frame-rate / worst-case latency / update-rate counters
103 _frameRate = fgGetNode("/sim/frame-rate", true);
104 _frameLatency = fgGetNode("/sim/frame-latency-max-ms", true);
105 _frameRateWorst = fgGetNode("/sim/frame-rate-worst", true);
107 _frameLatencyMax = 0.0;
111 void TimeManager::postinit()
116 void TimeManager::reinit()
123 void TimeManager::shutdown()
125 _warp->removeChangeListener(this);
127 globals->set_time_params(NULL);
131 globals->get_event_mgr()->removeTask("updateLocalTime");
134 void TimeManager::valueChanged(SGPropertyNode* aProp)
136 if (aProp == _warp) {
137 if (_clockFreeze->getBoolValue()) {
138 // if the warp is changed manually while frozen, don't modify it when
139 // un-freezing - the user wants to unfreeze with exactly the warp
141 _adjustWarpOnUnfreeze = false;
144 double lon = _longitudeDeg->getDoubleValue() * SG_DEGREES_TO_RADIANS;
145 double lat = _latitudeDeg->getDoubleValue() * SG_DEGREES_TO_RADIANS;
146 _impl->update(lon, lat,
147 _timeOverride->getLongValue(),
148 _warp->getIntValue());
152 void TimeManager::computeTimeDeltas(double& simDt, double& realDt)
154 // Update the elapsed time.
157 _firstUpdate = false;
158 _lastClockFreeze = _clockFreeze->getBoolValue();
161 bool scenery_loaded = fgGetBool("sim/sceneryloaded");
162 bool wait_for_scenery = !(scenery_loaded || fgGetBool("sim/sceneryloaded-override"));
164 if (!wait_for_scenery) {
165 throttleUpdateRate();
169 // suppress framerate while initial scenery isn't loaded yet (splash screen still active)
174 SGTimeStamp currentStamp;
175 currentStamp.stamp();
176 double dt = (currentStamp - _lastStamp).toSecs();
177 if (dt > _frameLatencyMax)
178 _frameLatencyMax = dt;
180 // Limit the time we need to spend in simulation loops
181 // That means, if the /sim/max-simtime-per-frame value is strictly positive
182 // you can limit the maximum amount of time you will do simulations for
183 // one frame to display. The cpu time spent in simulations code is roughly
184 // at least O(real_delta_time_sec). If this is (due to running debug
185 // builds or valgrind or something different blowing up execution times)
186 // larger than the real time you will no longer get any response
187 // from flightgear. This limits that effect. Just set to property from
188 // your .fgfsrc or commandline ...
189 double dtMax = _maxDtPerFrame->getDoubleValue();
190 if (0 < dtMax && dtMax < dt) {
194 int model_hz = fgGetInt("/sim/model-hz");
196 SGSubsystemGroup* fdmGroup =
197 globals->get_subsystem_mgr()->get_group(SGSubsystemMgr::FDM);
198 fdmGroup->set_fixed_update_time(1.0 / model_hz);
200 // round the real time down to a multiple of 1/model-hz.
201 // this way all systems are updated the _same_ amount of dt.
203 int multiLoop = long(floor(dt * model_hz));
204 multiLoop = SGMisc<long>::max(0, multiLoop);
205 _dtRemainder = dt - double(multiLoop)/double(model_hz);
206 dt = double(multiLoop)/double(model_hz);
209 if (_clockFreeze->getBoolValue() || wait_for_scenery) {
215 _lastStamp = currentStamp;
216 globals->inc_sim_time_sec(simDt);
218 // These are useful, especially for Nasal scripts.
219 fgSetDouble("/sim/time/delta-realtime-sec", realDt);
220 fgSetDouble("/sim/time/delta-sec", simDt);
223 void TimeManager::update(double dt)
225 bool freeze = _clockFreeze->getBoolValue();
226 time_t now = time(NULL);
229 // clock freeze requested
230 if (_timeOverride->getLongValue() == 0) {
231 _timeOverride->setLongValue(now);
232 _adjustWarpOnUnfreeze = true;
235 // no clock freeze requested
236 if (_lastClockFreeze) {
237 if (_adjustWarpOnUnfreeze) {
238 // clock just unfroze, let's set warp as the difference
239 // between frozen time and current time so we don't get a
240 // time jump (and corresponding sky object and lighting
242 int adjust = _timeOverride->getLongValue() - now;
243 SG_LOG(SG_GENERAL, SG_INFO, "adjusting on un-freeze:" << adjust);
244 _warp->setIntValue(_warp->getIntValue() + adjust);
246 _timeOverride->setLongValue(0);
249 int warpDelta = _warpDelta->getIntValue();
250 if (warpDelta != 0) {
251 _warp->setIntValue(_warp->getIntValue() + warpDelta);
255 _lastClockFreeze = freeze;
256 double lon = _longitudeDeg->getDoubleValue() * SG_DEGREES_TO_RADIANS;
257 double lat = _latitudeDeg->getDoubleValue() * SG_DEGREES_TO_RADIANS;
258 _impl->update(lon, lat,
259 _timeOverride->getLongValue(),
260 _warp->getIntValue());
265 void TimeManager::computeFrameRate()
267 // Calculate frame rate average
268 if ((_impl->get_cur_time() != _lastFrameTime)) {
269 _frameRate->setIntValue(_frameCount);
270 _frameLatency->setDoubleValue(_frameLatencyMax*1000);
271 if (_frameLatencyMax>0)
272 _frameRateWorst->setIntValue(1/_frameLatencyMax);
274 _frameLatencyMax = 0.0;
277 _lastFrameTime = _impl->get_cur_time();
281 void TimeManager::throttleUpdateRate()
283 // common case, no throttle requested
284 double throttle_hz = fgGetDouble("/sim/frame-rate-throttle-hz", 0.0);
285 if (throttle_hz <= 0)
288 // sleep for exactly 1/hz seconds relative to the past valid timestamp
289 SGTimeStamp::sleepUntil(_lastStamp + SGTimeStamp::fromSec(1/throttle_hz));
292 // periodic time updater wrapper
293 void TimeManager::updateLocalTime()
295 SGPath zone(globals->get_fg_root());
296 zone.append("Timezone");
298 double lon = _longitudeDeg->getDoubleValue() * SG_DEGREES_TO_RADIANS;
299 double lat = _latitudeDeg->getDoubleValue() * SG_DEGREES_TO_RADIANS;
301 SG_LOG(SG_GENERAL, SG_INFO, "updateLocal(" << lon << ", " << lat << ", " << zone.str() << ")");
302 _impl->updateLocal(lon, lat, zone.str());
305 void TimeManager::initTimeOffset()
308 long int offset = fgGetLong("/sim/startup/time-offset");
309 string offset_type = fgGetString("/sim/startup/time-offset-type");
310 setTimeOffset(offset_type, offset);
313 void TimeManager::setTimeOffset(const std::string& offset_type, long int offset)
315 // Handle potential user specified time offsets
316 int orig_warp = _warp->getIntValue();
317 time_t cur_time = _impl->get_cur_time();
318 time_t currGMT = sgTimeGetGMT( gmtime(&cur_time) );
319 time_t systemLocalTime = sgTimeGetGMT( localtime(&cur_time) );
320 time_t aircraftLocalTime =
321 sgTimeGetGMT( fgLocaltime(&cur_time, _impl->get_zonename() ) );
323 // Okay, we now have several possible scenarios
324 double lon = _longitudeDeg->getDoubleValue() * SG_DEGREES_TO_RADIANS;
325 double lat = _latitudeDeg->getDoubleValue() * SG_DEGREES_TO_RADIANS;
328 if ( offset_type == "real" ) {
330 } else if ( offset_type == "dawn" ) {
331 warp = fgTimeSecondsUntilSunAngle( cur_time, lon, lat, 90.0, true );
332 } else if ( offset_type == "morning" ) {
333 warp = fgTimeSecondsUntilSunAngle( cur_time, lon, lat, 75.0, true );
334 } else if ( offset_type == "noon" ) {
335 warp = fgTimeSecondsUntilSunAngle( cur_time, lon, lat, 0.0, true );
336 } else if ( offset_type == "afternoon" ) {
337 warp = fgTimeSecondsUntilSunAngle( cur_time, lon, lat, 75.0, false );
338 } else if ( offset_type == "dusk" ) {
339 warp = fgTimeSecondsUntilSunAngle( cur_time, lon, lat, 90.0, false );
340 } else if ( offset_type == "evening" ) {
341 warp = fgTimeSecondsUntilSunAngle( cur_time, lon, lat, 100.0, false );
342 } else if ( offset_type == "midnight" ) {
343 warp = fgTimeSecondsUntilSunAngle( cur_time, lon, lat, 180.0, false );
344 } else if ( offset_type == "system-offset" ) {
347 } else if ( offset_type == "gmt-offset" ) {
348 warp = offset - (currGMT - systemLocalTime);
350 } else if ( offset_type == "latitude-offset" ) {
351 warp = offset - (aircraftLocalTime - systemLocalTime);
353 } else if ( offset_type == "system" ) {
354 warp = offset - (systemLocalTime - currGMT) - cur_time;
355 } else if ( offset_type == "gmt" ) {
356 warp = offset - cur_time;
357 } else if ( offset_type == "latitude" ) {
358 warp = offset - (aircraftLocalTime - currGMT)- cur_time;
360 SG_LOG( SG_GENERAL, SG_ALERT,
361 "TimeManager::setTimeOffset: unsupported offset: " << offset_type );
365 _warp->setIntValue( orig_warp + warp );
367 SG_LOG( SG_GENERAL, SG_INFO, "After TimeManager::setTimeOffset(): warp = "
368 << _warp->getIntValue() );