source: osgVisual/include/sky_Silverlining/visual_skySilverLining.h @ 38

Last change on this file since 38 was 32, checked in by Torben Dannhauer, 15 years ago

Adding first version of osgVisual!!

File size: 23.3 KB
RevLine 
[32]1#pragma once
2/* -*-c++-*- osgVisual - Copyright (C) 2009-2010 Torben Dannhauer
3 *
4 * This library is based on OpenSceneGraph, open source and may be redistributed and/or modified under
5 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
6 * (at your option) any later version.  The full license is in LICENSE file
7 * included with this distribution, and on the openscenegraph.org website.
8 *
9 * osgVisual requires for some proprietary modules a license from the correspondig manufacturer.
10 * You have to aquire licenses for all used proprietary modules.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * OpenSceneGraph Public License for more details.
16 *
17 * This file is based on the OSG example of the Silverlining SDK:
18 * Copyright (c) 2008 Sundog Software, LLC. All rights reserved worldwide.
19*/
20
21#include <osg/NodeCallback>
22#include <osg/Geode>
23
24#include <SilverLining.h>
25#include <MillisecondTimer.h>
26#include <windows.h>
27#include <skySilverLining_skyDrawable.h>
28#include <skySilverLining_cloudsDrawable.h>
29#include <skySilverLining_AtmosphereReference.h>
30#include <skySilverLining_ProjectionMatrixCallback.h>
31#include <skySilverLining_cloudLayerSlot.h>
32
33#include <visual_util.h>
34
35namespace osgVisual
36{
37
38#define MAX_CLOUDLAYER_SLOTS 5
39/**
40 * \brief This class is the container class for the sky, stars and clouds
41 *
42 * This class is the container class for the sky, stars and clouds. It is responsible for initialization and updating of the sky system.
43 * It is realized as Geode that it is possible to install an updateCallback on this class.
44 * This way, the sky position is always updated during update traversal of the scene graph.
45 *
46 * The NodeCallback class is nested into this class that no external user can use this callback.
47 *
48 * @todo Add Cloudlayer->set/getalpha() function
49 * @todo Terrain shadows do not exist
50 * @todo Calibrate visual range with test objects. Populate a Lookuptable to use for true visibility ranges.
51 * @todo Implement an abstract sky interface class to allow other sky implementations than silverlining with identical interfaces
52 *
53 * @author Torben Dannhauer
54 * @date  Jul 2009
55 */ 
56class visual_skySilverLining : public osg::Geode
57{
58public:
59        /**
60         * \brief Constructor.
61         *
62         * @param viewer_ : Pointer to the applications viewer
63         */ 
64        visual_skySilverLining(osgViewer::Viewer* viewer_);
65
66        /**
67         * \brief Destrcutor: The updateCallback is removed and the atmosphere, if instantiated.
68         *
69         */ 
70        virtual ~visual_skySilverLining(void);
71
72        /**
73         * \brief Returns a Pointer to the atmosphere object.
74         *
75         * @return Pointer to the atmosphere object.
76         */ 
77        SilverLining::Atmosphere* getAtmosphere() {return atmosphere;};
78
79        /**
80         * \brief Checks if the sky system is initialized.
81         *
82         * Checks if the sky system is initialized. If not, it makes a deep lookup at the main cameras userdata, if atmosphere is initialized.
83         * If this returns true, the local variable is updated with ne new initialize status. If this deep lookup returns false, this method returns also false
84         * asks the cameras user data if initialzed. If that is
85         *
86         * @return : Returns the status of initialization.
87         */ 
88        bool isInitialized();
89       
90        /**
91         * \brief This function initializes the sky framework if its used with a PRE_RENDER camera like the distortion module.
92         *
93         * @param distortedRoot : osg::Group* which is the rootNode over distortion and scene
94         * @param sceneGraphRoot : osg::Group* which is the rootNode and coordinateSystemNode of the scene.
95         */ 
96        void init(osg::Group *distortedRoot, osg::CoordinateSystemNode *sceneGraphRoot);
97
98        /**
99         * \brief This function initializes the sky framework if it's used with the main camera (without any PRE_RENDER camera like the distortion module).
100         *
101         * @param sceneGraphRoot : osg::Group* which is the rootNode and coordinateSystemNode of the scene.
102         */ 
103        void init(osg::CoordinateSystemNode *sceneGraphRoot);
104
105        /**
106         * \brief This function can be called by the updateCallback. If the postInitialization for adding clouds etc. has be called already, this function will skip.
107         *
108         * If this function is called before sky is initalized, all actions are skipped.
109         * A standart usage is adding objects like clouds and winds, configuring time, location and visibility.
110         *
111         */ 
112        void postInit();
113
114        /**
115         * \brief This function shuts the sky framework down.
116         *
117         */ 
118        void shutdown();
119
120
121/** @name Time
122 *  The following functions control the simulated time and date.
123 */
124//@{
125        /**
126         * \brief Sets the new Date and Time to the sky system.
127         *
128         * Update is only performed if the sky systme is initialized.
129         *
130         * @param year_ : Year to set. SilverLining can only handle Gregorian calendar years, which means that years before 1582 will not be accurately simulated.
131         * @param month_ : Month to set. Ranging from 1 (Jan) to 12 (Dec)
132         * @param day_ : Day to set Ranging from 1 to 31
133         * @param hour_ : Hour to set. Ranging from 0 to 23
134         * @param minute_ : Minute to set. Ranging from 0 to 59.
135         * @param second_ : Second to set. Ranging from 0 to 59.
136         * @param daylightSaving_ : Configures, if the configured DateTime is in daylight savings or without daylight savings.
137         * @param timezoneOffset_ : Configures the timezone. Hour offset from GMT, ignoring daylight savings time.
138         */ 
139        void setDateTime( int year_, int month_, int day_, int hour_, int minute_, int second_, bool daylightSaving_, double timezoneOffset_ );
140
141        /**
142         * \brief Set time for the sky system.
143         *
144         * @param hour_ : Hour to set. Ranging from 0 to 23
145         * @param minute_ : Minute to set. Ranging from 0 to 59.
146         * @param second_ : Second to set. Ranging from 0 to 59.
147         */ 
148        void setTime( int hour_, int minute_, int second_ );
149
150        /**
151         * \brief Sets the date for the sky system.
152         *
153         * @param year_ : Year to set. SilverLining can only handle Gregorian calendar years, which means that years before 1582 will not be accurately simulated.
154         * @param month_ : Month to set. Ranging from 1 (Jan) to 12 (Dec)
155         * @param day_ : Day to set Ranging from 1 to 31
156         */ 
157        void setDate( int year_, int month_, int day_ );
158
159        /**
160         * \brief Configures the date and time by epoche (Seconds elapsed since midnight, January 1, 1970 UTC)
161         *
162         * This function ignores the daylight savings and timezone.
163         *
164         * @param secondsSince1970_ : Seconds elapsed since midnight, January 1, 1970 UTC
165         */ 
166        void setDateByEpoch(int secondsSince1970_ );
167
168//@}
169
170/** @name Location
171 *  The following functions control the location to simulate.
172 */
173//@{
174        /**
175         * \brief Configures the sky system to simulate a specific location.
176         *
177         * @param lat_ : Latitude in radians
178         * @param lon_ : Longitude in radians
179         * @param alt_ : Altimeter in meters above see level.
180         */ 
181        void setLocation(double lat_, double lon_, double alt_);
182//@}
183
184/** @name Visibility and Haze
185 *  The following functions control the atmosperic effects like visibility range and haze.
186 */
187//@{
188        /**
189         * \brief This functions sets the visibility range in meters to simulate.
190         *
191         * @param visibility_ : Visibility range in meters.
192         */ 
193        void setVisibility(double visibility_);
194
195        /**
196         * \brief This function returns the visibility range in meters which is simulated.
197         *
198         * @return : Visibility range in meters.
199         */ 
200        double getVisibility();
201
202        /**
203         * \brief This function sets the haze factor to simulate.
204         *
205         * 1 = Pure air, range 256 km
206         * 2 = very clear, range 50 km
207         * 3 = clear, range 15 km
208         * 7 = light haze, range 8 km
209         * 20 = haze, range 3 km
210         * 50 = thin fog, range 2 km
211         *
212         * @param turbidity_ : Haze factor to simulate.
213         */ 
214        void setTurbidity(double turbidity_);
215
216        /**
217         * \brief This function returns the simulated haze factor.
218         *
219         * @return : Haze factor.
220         */ 
221        double getTurbidity();
222//@}
223
224/** @name Light pollution
225 *  The following functions control the light pollution to simulate at night.
226 */
227//@{
228        /**
229         * \brief This functions sets the light pollution in Watt/m2
230         *
231         * @param lightPollution_ : Light pollution to set.
232         */ 
233        void setLightPollution(double lightPollution_);
234
235        /**
236         * \brief This function returns the simulated light pollution in Watt/m2.
237         *
238         * @return : Light pollution in Watt/m2
239         */ 
240        double getLightPollution();
241//@}
242
243/** @name Clouds
244 *  The following functions control the available slots for cloudLayer. In each slot a cloud layer can be adde and its perscpitation or
245 * baseAltitude updated. All other values are not updateable, therefore a delete and recreation of the cloud layer would be necessary.
246 */
247//@{
248        /**
249         * \brief This function adds a Cloudlayer to a sepcified SLOT. If the slot is used, this function returns immediately.
250         *
251         * If the slot number is out of range, nothing happens.
252         *
253         * Currently supported CloudTypes are:
254         *
255         * \li CloudTypes::CIRROCUMULUS - High planar cloud puffs.
256         * \li CloudTypes::CIRRUS_FIBRATUS - High, wispy cirrus clouds.
257     * \li CloudTypes::NIMBOSTRATUS - Low stratus decks.
258     * \li CloudTypes::CUMULONIMBUS_CAPPILATUS - A large thunderhead with lightning and rain.
259     * \li CloudTypes::CUMULUS_MEDIOCRIS - Small, puffy clouds.
260     * \li CloudTypes::CUMULUS_CONGESTUS - Larger cumulus clouds with flattened bottoms.
261     * \li CloudTypes::CUMULUS_MEDIOCRIS_INFINITE - A cumulus mediocris layer where the clouds wrap around
262     *  the camera location at all times, to create the illusion of an infinitely large cloud layer.
263     * \li CloudTypes::CUMULUS_CONGESTUS_INFINITE - A cumulus congestus layer where the clouds wrap around
264     *  the camera location at all times, to create the illusion of an infinitely large cloud layer.
265         *
266         * @param slot_ : Slot to use.
267         * @param baseLength_ : Baselength in meter of the cloud layer to generate.
268         * @param baseWidth_ : Basewideth in meter of the cloud layer to generate.
269         * @param thickness_ : Thicknes of the could layer in meter.
270         * @param baseHeight_ : Height of the cloud base in WGS84.
271         * @param density_ : Coverage of the cloud layer in percent (0.0 - 1.0).
272         * @param cloudtype_ : Type of the cloudlayer to generate.
273         */ 
274        void addCloudLayer(int slot_, double baseLength_, double baseWidth_, double thickness_, double baseHeight_, double density_, CloudTypes cloudtype_ );
275
276        /**
277         * \brief This function remove the cloudlayer in the specified slot and marks the slot as free.
278         *
279         * If the slot number is out of range, nothing happens.
280         *
281         * @param slot_ : Slot number to clean
282         */ 
283        void removeCloudLayer( int slot_ );
284       
285        /**
286         * \brief This function removes the cloud layers from all slots
287         *
288         */ 
289        void clearAllSlots();
290
291        /**
292         * \brief This function returns a pointer to the cloudLayer this slot contains.
293         *
294         * If the slot number is out of range, nothing happens.
295         *
296         * @param slot_ : Slot to query for it's cloudLayer pointer.
297         * @return : Pointer to the contained cloud layer.
298         */ 
299        SilverLining::CloudLayer* getCloudLayer( int slot_ );
300       
301        /**
302         * \brief This function configure the cloud layer als enabled (show clouds) or disabled (hide clouds).
303         *
304         * If the slot number is out of range, nothing happens.
305         *
306         * @param slot_ : Cloudlayer to hide/show.
307         * @param enabled_ : Control where hide or show should be configured.
308         */ 
309        void setEnabled(int slot_, bool enabled_ );
310
311        /**
312         * \brief This function returns if the specified cloud layer is en- or disabled (hidden or shown).
313         *
314         * If the slot number is out of range, nothing happens.
315         *
316         * @param slot_ : Slot zu query.
317         * @return : true if clouds are visible, false if clouds are hidden.
318         */ 
319        bool isEnabled( int slot_ );
320
321        /**
322         * \brief This functions fade the clouds in or out, depending on the visibility tsatus before.
323         *
324         * If the slot number is out of range, nothing happens.
325         *
326         * @param slot_ : Slot to fade.
327         * @param fadetimeMS_ : Milliseconds to fade the cloud layer.
328         */ 
329        void fadeVisibility( int slot_, int fadetimeMS_);
330
331        /**
332         * \brief
333         *
334         * If the slot number is out of range, nothing happens.
335         *
336         * @param slot_
337         * @return : String with the literal name of the cloud layer type.
338         */ 
339        std::string getCloudLayerTypeName( int slot_ );
340
341//@}
342
343/** @name Wind
344 *  Description of wind. Attention: Wind volumes are not geocentric: If far enough away from upvector location, the earth will curve away under the wind volume.
345 */
346//@{
347        /**
348         * \brief This function adds a wind volume to the scene, with the specified characteristics.
349         *
350         * @param bottom_ : Height in WGS84 in metern of the wind volumes bottom.
351         * @param top_ : Height in WGS84 in metern of the wind volumes top.
352         * @param speed_ : Windspeed in the wind volume in meter per seconds.
353         * @param direction_ : Wind direction in the wind volume in degree (wind origin, not wind destination).
354         *
355         */ 
356        void addWindVolume(double bottom_, double top_, double speed_, int direction_);
357
358        /**
359         * \brief This function deletes all wind volumes.
360         *
361         */ 
362        void clearAllWindVolumes();
363
364        /**
365         * \brief This functions checks wether the specified altitude in MSL is inside a wind volume.
366         *
367         * If multiple wind volumes are nested, this function returns the first matching wind volume.
368         * Because geocentric wind is not implemented, the altitude information is always base on the location where the wind was added.
369         * To avoid multiple winds, don't use nested wind volumes.
370         *
371         * @param height_ : Height in meters in WGS84 to check for wind.
372         * @param bottom_ : If checking altitude is inside a volume, the bottom altitude of the volume in meters above MSL is written into, otherwise -1.
373         * @param top_ : If checking altitude is inside a volume, the top altitude of the volume in meters above MSL is written into, otherwise -1.
374         * @param speed_ : If checking altitude is inside a volume, the wind speed in the wind volume is written into, otherwise -1.
375         * @param direction_ : If checking altitude is inside a volume, the wind direction (0 deg = from north, 90 deg = from east) in the wind volume is written into, otherwise -1.
376         * @return : True if checking altitude is inside a wind volume, otherwise false.
377         */ 
378        bool insideWind(double height_, double& bottom_, double& top_, double& speed_, double& direction_);
379
380       
381//@}
382
383/** @name Precipitation
384 *  The following functions control the rate and type of precipitation. It is possible to configure it on an global or a per cloud basis.
385 */
386//@{
387        // Per SLOT
388        /**
389         * \brief This functions enables the specified precipitation rate and precipitation type at the specified cloudLayer slot.
390         *
391         * @param slot_ : CloudLayer slot to enable precipitation in.
392         * @param rate_mmPerHour_rain_ : Precipitation rate in mm/hour of rain.
393         * @param rate_mmPerHour_drySnow_ : Precipitation rate in mm/hour of dry snow.
394         * @param rate_mmPerHour_wetSnow_ : Precipitation rate in mm/hour of wet snow.
395         * @param rate_mmPerHour_sleet_ : Precipitation rate in mm/hour of sleet.
396         */ 
397        void setSlotPrecipitation( int slot_, double rate_mmPerHour_rain_, double rate_mmPerHour_drySnow_, double rate_mmPerHour_wetSnow_, double rate_mmPerHour_sleet_ );
398
399        /**
400         * \brief This function retrieves the precipitation of a cloudlayer slot.
401         *
402         * @param slot_ : Slot to check for precipitation.
403         * @param rate_mmPerHour_rain : Precipitation rate in mm/hour of rain.
404         * @param rate_mmPerHour_drySnow : Precipitation rate in mm/hour of dry snow.
405         * @param rate_mmPerHour_wetSnow : Precipitation rate in mm/hour of wet snow.
406         * @param rate_mmPerHour_sleet : Precipitation rate in mm/hour of sleet.
407         * @return : True if cloudLayer has precipitation.
408         */ 
409        bool getSlotPrecipitation( int slot_, double& rate_mmPerHour_rain, double& rate_mmPerHour_drySnow, double& rate_mmPerHour_wetSnow, double& rate_mmPerHour_sleet );
410       
411        /**
412         * \brief This function checks a specified location for precipitation at the specified cloudLayer slot.
413         *
414         * @param slot_ : CloudLayer slot to check for specification.
415         * @param rate_mmPerHour_rain : Precipitation rate in mm/hour of rain.
416         * @param rate_mmPerHour_drySnow : Precipitation rate in mm/hour of dry snow.
417         * @param rate_mmPerHour_wetSnow : Precipitation rate in mm/hour of wet snow.
418         * @param rate_mmPerHour_sleet : Precipitation rate in mm/hour of sleet.
419         * @param lat_ : Latitude to check for precipitation. If it defaults to -1, the internal sky latitude will be used.
420         * @param lon_ : Longitude to check for precipitation. If it defaults to -1, the internal sky longitude will be used.
421         * @param height_ : Height in WGS84 to check for precipitation. If it defaults to -1, the internal sky height will be used.
422         * @return : Returns true if precipitation at the specified location is true. 
423         */ 
424        bool getSlotPrecipitationAtLocation( int slot_, double& rate_mmPerHour_rain, double& rate_mmPerHour_drySnow, double& rate_mmPerHour_wetSnow, double& rate_mmPerHour_sleet, double lat_=-1, double lon_=-1, double height_=-1 );
425
426        /**
427         * \brief This function clears all types of precipitation of the specified slot.
428         *
429         * @param slot_ : Slot toe clear precipitation.
430         */ 
431        void clearAllPrecipitation( int slot_ );
432
433        // Global
434        /**
435         * \brief This function clears the global precipitation.
436         *
437         */ 
438        void clearGlobalPrecipitation();
439
440        /**
441         * \brief This function sets the cloud independent, global precipitation.
442         *
443         * @param rate_mmPerHour_rain_ : Precipitation rate in mm/hour of rain.
444         * @param rate_mmPerHour_drySnow_ : Precipitation rate in mm/hour of dry snow.
445         * @param rate_mmPerHour_wetSnow_ : Precipitation rate in mm/hour of wet snow.
446         * @param rate_mmPerHour_sleet_ : Precipitation rate in mm/hour of sleet.
447         */ 
448        void setGlobalPrecipitation( double rate_mmPerHour_rain_, double rate_mmPerHour_drySnow_, double rate_mmPerHour_wetSnow_, double rate_mmPerHour_sleet_ );
449       
450        // Misc
451        /**
452         * \brief This function returns the overall precipitation rate of all cloud dependent precipitation.
453         *
454         * This function adds the precipitation of all cloudLayer seperated for all types of precipitation.
455         * Global precipitation is ignored, because precipitation without clouds is artificial and only reasonable for visualiszation purposes.
456         *
457         * @param rate_mmPerHour_rain : Precipitation rate in mm/hour of rain.
458         * @param rate_mmPerHour_drySnow : Precipitation rate in mm/hour of dry snow.
459         * @param rate_mmPerHour_wetSnow : Precipitation rate in mm/hour of wet snow.
460         * @param rate_mmPerHour_sleet : Precipitation rate in mm/hour of sleet.
461         * @param lat_ : Latitude to check for precipitation. If it defaults to -1, the internal sky latitude will be used.
462         * @param lon_ : Longitude to check for precipitation. If it defaults to -1, the internal sky longitude will be used.
463         * @param height_ : Height in WGS84 to check for precipitation. If it defaults to -1, the internal sky height will be used.
464         * @return : True if precipitation lookup was successful.
465         */ 
466        bool getOverallPrecipitationAtLocation( double& rate_mmPerHour_rain, double& rate_mmPerHour_drySnow, double& rate_mmPerHour_wetSnow, double& rate_mmPerHour_sleet, double lat_=-1, double lon_=-1, double height_=-1 );
467//@}
468
469
470
471
472
473private:
474        /**
475         * \brief Nested Callback class
476         *
477         * @author Torben Dannhauer
478         * @date  Jul 2009
479         */ 
480        class skyUpdateCallback : public osg::NodeCallback
481        {
482        public:
483                /**
484                 * \brief Constructor
485                 *
486                 * @param csn_ : Pointer to the Coordinate System Node. Necessary to extract lat, lon and height of the camera position.
487                 * @param sceneCamera_ : Pointer to the scene camera (undistorted camera, type PRE_RENDER)
488                 * @param sky_ : Pointer to the sky system.
489                 */ 
490                skyUpdateCallback(osg::CoordinateSystemNode* csn_, osg::Camera* sceneCamera_, visual_skySilverLining* sky_)
491                        : csn(csn_), sceneCamera(sceneCamera_), sky(sky_) {};
492
493                /**
494                 * \brief This function is executed as callback during traversal. It updates the skys displayed location.
495                 *
496                 */ 
497                virtual void operator()(osg::Node* node, osg::NodeVisitor* nv);
498        private:
499                /**
500                 * Referenced pointer to the Coordinate System Node. Necessary to extract lat, lon and height of the camera position.
501                 */ 
502                osg::ref_ptr<osg::CoordinateSystemNode> csn;
503               
504                /**
505                 * Referenced pointer to the scene camera (undistorted camera, type PRE_RENDER)
506                 */ 
507                osg::ref_ptr<osg::Camera> sceneCamera;
508
509                /**
510                 * Referenced pointer to the sky system.
511                 */ 
512                osg::ref_ptr<visual_skySilverLining> sky;
513        };      // Nested class END
514
515        /**
516         * \brief This function updates the atmosphere's upVector,
517         * if delta_lat or delta_lon (from the existing location
518         * and the location of the last upVector update) is larger than N degree.
519         * If an update is requiered, the existing location is noted as the last update location.
520         *
521         * Iis called by this->setLocation.
522         *
523         */ 
524        void updateUpVector();
525
526        /**
527         * Pointer to the atmosphere object of Silverlining.
528         */ 
529        SilverLining::Atmosphere *atmosphere;
530
531        /**
532         * Referenced Pointer to the viewer
533         */ 
534        osg::ref_ptr<osgViewer::Viewer> viewer;
535
536        /**
537         * Referenced Pointer to the camera which pre renders the scene
538         */ 
539        osg::ref_ptr<osg::Camera> sceneCamera;
540 
541        /**
542         * Referenced Pointer to the coordinate system node. Required for WGS84 transformations.
543         */ 
544        osg::ref_ptr<osg::CoordinateSystemNode> sceneRoot;
545
546        /**
547         * Referenced Pointer to the updatecallback, which is installed at this node.
548         */ 
549        osg::ref_ptr<skyUpdateCallback> updateCallback;
550
551        /**
552         * Referenced Pointer to the ProjectionMatrix callback.
553         */ 
554        osg::ref_ptr<skySilverLining_projectionMatrixCallback> cb;
555
556        /**
557         * Referenced Pointer to the sky Drawable, which renders the skybox.
558         */ 
559        osg::ref_ptr<skySilverLining_skyDrawable> skyDrawable;
560
561        /**
562         * Referenced Pointer to the cloudsDrawable, which renders the clouds.
563         */ 
564        osg::ref_ptr<skySilverLining_cloudsDrawable> cloudsDrawable;
565
566        /**
567         * Flag which contains if the sky system is initialized. This status is only a local
568         * copy if the cameras userdata which contain the primary information if the sky system is initialized
569         */ 
570        bool atmosphereInitialized;
571
572        /**
573         * This variable indicates whether postinit() was called already.
574         */ 
575        bool postInitialized;
576
577        /**
578         * This vector contains all available slots for cloud layer.
579         */ 
580        std::vector<cloudLayerSlot> cloudLayerSlots;
581
582                /**
583         * Latitude, which mirrors the latitude of the last sky update. This is neccesary if any weather effect is added to calculate the earth radius on that location for appropriate level above MSL
584         */ 
585        double lat;
586
587        /**
588         * Longitude, which mirrors the latitude of the last sky update. This is neccesary if any weather effect is added to calculate the earth radius on that location for appropriate level above MSL
589         */ 
590        double lon;
591
592        /**
593         * Height, which mirrors the height of the last sky update.
594         */ 
595        double height;
596
597        /**
598         * This variable contains the latitude of the last upVector update.
599         */ 
600        double upVectorLat;
601
602        /**
603         * This variable contains the longitude of the last upVector update.
604         */ 
605        double upVectorLon;
606
607};
608
609using namespace SilverLining;
610
611class MyMillisecondTimer : public SilverLining::MillisecondTimer
612{
613public:
614        virtual unsigned long GetMilliseconds() const
615        {
616                        return timeGetTime() * 50;
617        }
618};
619
620
621} // END NAMESPACE
Note: See TracBrowser for help on using the repository browser.