visual_enviro.hxx

// Visual environment helper class
//
// Written by Harald JOHNSEN, started April 2005.
//
// Copyright (C) 2005  Harald JOHNSEN - hjohnsen@evc.net
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program 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
// 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.
//
//
#ifndef _VISUAL_ENVIRO_HXX
#define _VISUAL_ENVIRO_HXX

#include <plib/sg.h>

#include <simgear/compiler.h>
#include <string>
#include <vector>

using std::vector;
using std::string;

class SGLightning;
class SGSampleGroup;

class SGWxRadarEcho {
public:
        SGWxRadarEcho(float _heading, float _alt, float _radius, float _dist,
                        double _LWC, bool _lightning, int _cloudId ) :
          heading( _heading ),
          alt ( _alt ),
          radius ( _radius ),
          dist ( _dist ),
          LWC ( _LWC ),
          lightning ( _lightning ),
          cloudId ( _cloudId )
        {}

        float heading;
        float alt, radius, dist;
        double LWC;
        bool lightning;
        int cloudId;
};

typedef vector<SGWxRadarEcho> list_of_SGWxRadarEcho;

class SGEnviro {
friend class SGLightning;
private:
        void DrawCone2(float baseRadius, float height, int slices, bool down, double rain_norm, double speed);
        void lt_update(void);

        bool view_in_cloud;
        bool precipitation_enable_state;
        float precipitation_density;
        float precipitation_max_alt;
        bool turbulence_enable_state;
        double last_cloud_turbulence, cloud_turbulence;
        bool lightning_enable_state;
        double elapsed_time, dt;
        sgVec4  fog_color;
        sgMat4 transform;
        double last_lon, last_lat, last_alt;
        SGSampleGroup   *sampleGroup;
        bool            snd_active, snd_playing;
        double          snd_timer, snd_wait, snd_pos_lat, snd_pos_lon, snd_dist;
        double          min_time_before_lt;

        float fov_width, fov_height;

        list_of_SGWxRadarEcho radarEcho;
        static sgVec3 min_light;
        static SGfloat streak_bright_nearmost_layer,
                                   streak_bright_farmost_layer,
                                   streak_period_max,
                                   streak_period_change_per_kt,
                                   streak_period_min,
                                   streak_length_min,
                                   streak_length_change_per_kt,
                                   streak_length_max;
        static int streak_count_min, streak_count_max;
        static SGfloat cone_base_radius,
                                   cone_height;

public:
        SGEnviro();
        ~SGEnviro();

        void config(const class SGPropertyNode* precip_rendering_cfgNode);

        void startOfFrame( sgVec3 p, sgVec3 up, double lon, double lat, double alt, double delta_time);

        void endOfFrame(void);

#if 0

        void callback_cloud(float heading, float alt, float radius, int family, float dist, int cloudId);
#endif
        void drawRain(double pitch, double roll, double heading, double hspeed, double rain_norm);
        void drawPrecipitation(double rain_norm, double snow_norm, double hail_norm,
                                                        double pitch, double roll, double heading, double hspeed);

        void drawLightning(void);

        void setLight(sgVec4 adj_fog_color);

        // this can be queried to add some turbulence for example
        bool is_view_in_cloud(void) const;
        void set_view_in_cloud(bool incloud);
        double get_cloud_turbulence(void) const;

        // Clouds
        // return the size of the memory pool used by texture impostors
        int get_clouds_CacheSize(void) const;
        int get_CacheResolution(void) const;
        float get_clouds_visibility(void) const;
        float get_clouds_density(void) const;
        bool get_clouds_enable_state(void) const;
        bool get_turbulence_enable_state(void) const;

        void set_clouds_CacheSize(int sizeKb);
        void set_CacheResolution(int resolutionPixels);
        void set_clouds_visibility(float distance);
        void set_clouds_density(float density);
        void set_clouds_enable_state(bool enable);
        void set_turbulence_enable_state(bool enable);

        // rain/snow
        float get_precipitation_density(void) const;
        bool get_precipitation_enable_state(void) const;

        void set_precipitation_density(float density);
        void set_precipitation_enable_state(bool enable);

        // others
        bool get_lightning_enable_state(void) const;
        void set_lightning_enable_state(bool enable);

        void addLightning(double lon, double lat, double alt);

        void set_sampleGroup(SGSampleGroup *sgr);

        void setFOV( float w, float h );
        void getFOV( float &w, float &h );

        list_of_SGWxRadarEcho *get_radar_echo(void);

        sgMat4 *get_transform(void) { return &transform; }
};

extern SGEnviro sgEnviro;

#endif // _VISUAL_ENVIRO_HXX

---