sky.hxx

Go to the documentation of this file.

// Written by Curtis Olson, started December 1997.
// SSG-ified by Curtis Olson, February 2000.
//
// Copyright (C) 1997-2000  Curtis L. Olson  - http://www.flightgear.org/~curt
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
//
// $Id: sky_8hxx_source.html,v 1.3 2010/02/23 22:10:16 curt Exp $


#ifndef _SG_SKY_HXX
#define _SG_SKY_HXX


#ifndef __cplusplus
# error This library requires C++
#endif

#include <simgear/compiler.h>
#include <simgear/misc/sg_path.hxx>
#include <simgear/props/props.hxx>

#include <vector>

#include <osg/ref_ptr>
#include <osg/MatrixTransform>
#include <osg/Node>
#include <osg/Switch>

#include <simgear/ephemeris/ephemeris.hxx>
#include <simgear/math/SGMath.hxx>

#include <simgear/scene/sky/cloud.hxx>
#include <simgear/scene/sky/dome.hxx>
#include <simgear/scene/sky/moon.hxx>
#include <simgear/scene/sky/oursun.hxx>
#include <simgear/scene/sky/stars.hxx>

using std::vector;


typedef struct {
        SGVec3d pos;
        SGGeod pos_geod;
        SGQuatd ori;
        double spin;
        double gst;
        double sun_dist;
        double moon_dist;
        double sun_angle;
} SGSkyState;

typedef struct {
        SGVec3f sky_color;
        SGVec3f adj_sky_color;
        SGVec3f fog_color;
        SGVec3f cloud_color;
        double sun_angle, moon_angle;
} SGSkyColor;

class SGSky {

private:
    typedef std::vector<SGSharedPtr<SGCloudLayer> > layer_list_type;
    typedef layer_list_type::iterator layer_list_iterator;
    typedef layer_list_type::const_iterator layer_list_const_iterator;

    // components of the sky
    SGSharedPtr<SGSkyDome> dome;
    SGSharedPtr<SGSun> oursun;
    SGSharedPtr<SGMoon> moon;
    SGSharedPtr<SGStars> planets;
    SGSharedPtr<SGStars> stars;
    layer_list_type cloud_layers;

    osg::ref_ptr<osg::Group> pre_root, cloud_root;
    osg::ref_ptr<osg::Switch> pre_selector;
    osg::ref_ptr<osg::Group> pre_transform;

    osg::ref_ptr<osg::MatrixTransform> _ephTransform;

    SGPath tex_path;

    // visibility
    float visibility;
    float effective_visibility;

    int in_cloud;
    int cur_layer_pos;

    // near cloud visibility state variables
    bool in_puff;
    double puff_length;         // in seconds
    double puff_progression;    // in seconds
    double ramp_up;             // in seconds
    double ramp_down;           // in seconds

    // 3D clouds enabled
    bool clouds_3d_enabled;

    // 3D cloud density
    double clouds_3d_density;

public:

    SGSky( void );

    ~SGSky( void );

    void build( double h_radius_m, double v_radius_m,
                double sun_size, double moon_size,
                const SGEphemeris& eph, SGPropertyNode *property_tree_node );

    bool repaint( const SGSkyColor &sc, const SGEphemeris& eph );

    bool reposition( const SGSkyState &st, const SGEphemeris& eph, double dt = 0.0 );

    void modify_vis( float alt, float time_factor );

    osg::Node* getPreRoot() { return pre_root.get(); }
    osg::Node* getCloudRoot() { return cloud_root.get(); }

    void texture_path( const string& path );

    inline void enable() {
        pre_selector->setValue(0, 1);
    }

    inline void disable() {
        pre_selector->setValue(0, 0);
    }

    inline SGVec4f get_sun_color() { return oursun->get_color(); }

    inline SGVec4f get_scene_color() { return oursun->get_scene_color(); }

    void add_cloud_layer (SGCloudLayer * layer);


    const SGCloudLayer * get_cloud_layer (int i) const;


    SGCloudLayer * get_cloud_layer (int i);


    int get_cloud_layer_count () const;


    inline float get_visibility() const { return effective_visibility; }

    inline void set_visibility( float v ) {
        effective_visibility = visibility = (v <= 25.0) ? 25.0 : v;
    }

    virtual double get_3dCloudDensity() const;

    virtual void set_3dCloudDensity(double density);

    virtual float get_3dCloudVisRange() const;

    virtual void set_3dCloudVisRange(float vis);

};


#endif // _SG_SKY_HXX

---