simgear/scene/sky/cloud.hxx

   1 /**
   2  * \file cloud.hxx
   3  * Provides a class to model a single cloud layer
   4  */
   5
   6 // Written by Curtis Olson, started June 2000.
   7 //
   8 // Copyright (C) 2000  Curtis L. Olson  - http://www.flightgear.org/~curt
   9 //
  10 // This library is free software; you can redistribute it and/or
  11 // modify it under the terms of the GNU Library General Public
  12 // License as published by the Free Software Foundation; either
  13 // version 2 of the License, or (at your option) any later version.
  14 //
  15 // This library is distributed in the hope that it will be useful,
  16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18 // Library General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this program; if not, write to the Free Software
  22 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  23 //
  24 // $Id$
  25
  26
  27 #ifndef _SG_CLOUD_HXX_
  28 #define _SG_CLOUD_HXX_
  29
  30 #include <simgear/compiler.h>
  31 #include <simgear/misc/sg_path.hxx>
  32 #include <simgear/math/SGMath.hxx>
  33 #include <simgear/structure/SGReferenced.hxx>
  34
  35 #include STL_STRING
  36 SG_USING_STD(string);
  37
  38 #include <osg/ref_ptr>
  39 #include <osg/Array>
  40 #include <osg/Geode>
  41 #include <osg/Group>
  42 #include <osg/MatrixTransform>
  43 #include <osg/Switch>
  44
  45 class SGCloudField;
  46
  47 /**
  48  * A class layer to model a single cloud layer
  49  */
  50 class SGCloudLayer : public SGReferenced {
  51 public:
  52
  53     /**
  54      * This is the list of available cloud coverages/textures
  55      */
  56     enum Coverage {
  57         SG_CLOUD_OVERCAST = 0,
  58         SG_CLOUD_BROKEN,
  59         SG_CLOUD_SCATTERED,
  60         SG_CLOUD_FEW,
  61         SG_CLOUD_CIRRUS,
  62         SG_CLOUD_CLEAR,
  63         SG_MAX_CLOUD_COVERAGES
  64     };
  65
  66     /**
  67      * Constructor
  68      * @param tex_path the path to the set of cloud textures
  69      */
  70     SGCloudLayer( const string &tex_path );
  71
  72     /**
  73      * Destructor
  74      */
  75     ~SGCloudLayer( void );
  76
  77     /** get the cloud span (in meters) */
  78     float getSpan_m () const;
  79     /**
  80      * set the cloud span
  81      * @param span_m the cloud span in meters
  82      */
  83     void setSpan_m (float span_m);
  84
  85     /** get the layer elevation (in meters) */
  86     float getElevation_m () const;
  87     /**
  88      * set the layer elevation.  Note that this specifies the bottom
  89      * of the cloud layer.  The elevation of the top of the layer is
  90      * elevation_m + thickness_m.
  91      * @param elevation_m the layer elevation in meters
  92      * @param set_span defines whether it is allowed to adjust the span
  93      */
  94     void setElevation_m (float elevation_m, bool set_span = true);
  95
  96     /** get the layer thickness */
  97     float getThickness_m () const;
  98     /**
  99      * set the layer thickness.
 100      * @param thickness_m the layer thickness in meters.
 101      */
 102     void setThickness_m (float thickness_m);
 103
 104     /**
 105      * get the transition/boundary layer depth in meters.  This
 106      * allows gradual entry/exit from the cloud layer via adjusting
 107      * visibility.
 108      */
 109     float getTransition_m () const;
 110
 111     /**
 112      * set the transition layer size in meters
 113      * @param transition_m the transition layer size in meters
 114      */
 115     void setTransition_m (float transition_m);
 116
 117     /** get coverage type */
 118     Coverage getCoverage () const;
 119
 120     /**
 121      * set coverage type
 122      * @param coverage the coverage type
 123      */
 124     void setCoverage (Coverage coverage);
 125
 126     /**
 127      * set the cloud movement direction
 128      * @param dir the cloud movement direction
 129      */
 130     inline void setDirection(float dir) {
 131         // cout << "cloud dir = " << dir << endl;
 132         direction = dir;
 133     }
 134
 135     /** get the cloud movement direction */
 136     inline float getDirection() { return direction; }
 137
 138     /**
 139      * set the cloud movement speed
 140      * @param sp the cloud movement speed
 141      */
 142     inline void setSpeed(float sp) {
 143         // cout << "cloud speed = " << sp << endl;
 144         speed = sp;
 145     }
 146
 147     /** get the cloud movement speed */
 148     inline float getSpeed() { return speed; }
 149
 150     /**
 151      * set the alpha component of the cloud base color.  Normally this
 152      * should be 1.0, but you can set it anywhere in the range of 0.0
 153      * to 1.0 to fade a cloud layer in or out.
 154      * @param alpha cloud alpha value (0.0 to 1.0)
 155      */
 156     inline void setAlpha( float alpha ) {
 157         if ( alpha < 0.0 ) { alpha = 0.0; }
 158         if ( alpha > 1.0 ) { alpha = 1.0; }
 159         cloud_alpha = alpha;
 160     }
 161
 162     /** build the cloud object */
 163     void rebuild();
 164
 165     /**
 166      * repaint the cloud colors based on the specified fog_color
 167      * @param fog_color the fog color
 168      */
 169     bool repaint( const SGVec3f& fog_color );
 170
 171     /**
 172      * reposition the cloud layer at the specified origin and
 173      * orientation.
 174      * @param p position vector
 175      * @param up the local up vector
 176      * @param lon specifies a rotation about the Z axis
 177      * @param lat specifies a rotation about the new Y axis
 178      * @param spin specifies a rotation about the new Z axis
 179      *        (and orients the sunrise/set effects)
 180      * @param dt the time elapsed since the last call
 181      */
 182     bool reposition( const SGVec3f& p, const SGVec3f& up,
 183                      double lon, double lat, double alt,
 184                      double dt = 0.0 );
 185
 186     osg::Switch* getNode() { return layer_root.get(); }
 187
 188     static bool enable_bump_mapping;
 189
 190     /** return the 3D layer cloud associated with this 2D layer */
 191     SGCloudField *get_layer3D(void) { return layer3D; }
 192 protected:
 193     void setTextureOffset(const osg::Vec2& offset);
 194 private:
 195
 196     osg::ref_ptr<osg::Switch> layer_root;
 197     osg::ref_ptr<osg::Group> group_top, group_bottom;
 198     osg::ref_ptr<osg::MatrixTransform> layer_transform;
 199     osg::ref_ptr<osg::Geode> layer[4];
 200
 201     float cloud_alpha;          // 1.0 = drawn fully, 0.0 faded out completely
 202
 203     osg::ref_ptr<osg::Vec4Array> cl[4];
 204     osg::ref_ptr<osg::Vec3Array> vl[4];
 205     osg::ref_ptr<osg::Vec2Array> tl[4];
 206     osg::ref_ptr<osg::Vec3Array> tl2[4];
 207
 208     // height above sea level (meters)
 209     SGPath texture_path;
 210     float layer_span;
 211     float layer_asl;
 212     float layer_thickness;
 213     float layer_transition;
 214     Coverage layer_coverage;
 215     float scale;
 216     float speed;
 217     float direction;
 218
 219     // for handling texture coordinates to simulate cloud movement
 220     // from winds, and to simulate the clouds being tied to ground
 221     // position, not view position
 222     // double xoff, yoff;
 223     double last_lon, last_lat, last_course;
 224
 225     osg::Vec2 base;
 226
 227     SGCloudField *layer3D;
 228 };
 229
 230 #endif // _SG_CLOUD_HXX_