simgear/scene/sky/cloudfield.hxx

   1 // a layer of 3d clouds
   2 //
   3 // Written by Harald JOHNSEN, started April 2005.
   4 //
   5 // Copyright (C) 2005  Harald JOHNSEN - hjohnsen@evc.net
   6 //
   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.
  11 //
  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.
  16 //
  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.
  20 //
  21 //
  22
  23 #ifndef _CLOUDFIELD_HXX
  24 #define _CLOUDFIELD_HXX
  25
  26 #include <plib/sg.h>
  27 #include <simgear/compiler.h>
  28 #include <vector>
  29
  30 #include <osgDB/ReaderWriter>
  31
  32 #include <osg/ref_ptr>
  33 #include <osg/Array>
  34 #include <osg/Geometry>
  35 #include <osg/Group>
  36 #include <osg/Switch>
  37
  38 namespace osg
  39 {
  40         class Fog;
  41         class StateSet;
  42         class Vec4f;
  43 }
  44
  45 #include <simgear/misc/sg_path.hxx>
  46 #include <simgear/structure/Singleton.hxx>
  47
  48 using std::vector;
  49
  50 class SGNewCloud;
  51
  52 /**
  53  * A layer of 3D clouds.
  54  */
  55 class SGCloudField {
  56
  57 private:
  58         class Cloud  {
  59         public:
  60                 SGNewCloud      *aCloud;
  61                 sgVec3          pos;
  62                 bool            visible;
  63         };
  64
  65         float Rnd(float);
  66
  67         // We create a quadtree two levels deep
  68         static const int BRANCH_SIZE = 16;
  69         static const int QUADTREE_SIZE = 32;
  70
  71         // this is a relative position only, with that we can move all clouds at once
  72         sgVec3 relative_position;
  73         //      double lon, lat;
  74
  75         osg::ref_ptr<osg::Group> field_root;
  76         osg::ref_ptr<osg::MatrixTransform> field_transform;
  77         osg::ref_ptr<osg::PositionAttitudeTransform> altitude_transform;
  78         osg::ref_ptr<osg::Switch> field_group[QUADTREE_SIZE][QUADTREE_SIZE];
  79         osg::ref_ptr<osg::LOD> quad[BRANCH_SIZE][BRANCH_SIZE];
  80
  81         osg::ref_ptr<osg::LOD> field_lod;
  82
  83         double deltax, deltay, alt;
  84         double last_course;
  85         sgSphere field_sphere;
  86         float   last_coverage;
  87         SGGeoc cld_pos;
  88         int reposition_count;
  89         struct CloudFog : public simgear::Singleton<CloudFog>
  90         {
  91                 CloudFog();
  92                 osg::ref_ptr<osg::Fog> fog;
  93         };
  94 public:
  95
  96         SGCloudField();
  97         ~SGCloudField();
  98
  99         void clear(void);
 100
 101         // add one cloud, data is not copied, ownership given
 102         void addCloud( SGVec3f& pos, SGNewCloud *cloud);
 103
 104         /**
 105         * reposition the cloud layer at the specified origin and
 106         * orientation.
 107         * @param p position vector
 108         * @param up the local up vector
 109         * @param lon specifies a rotation about the Z axis
 110         * @param lat specifies a rotation about the new Y axis
 111         * @param dt the time elapsed since the last call
 112         * @param asl altitude of the layer
 113         */
 114         bool reposition( const SGVec3f& p, const SGVec3f& up,
 115                         double lon, double lat, double dt, int asl);
 116
 117         osg::Group* getNode() { return field_root.get(); }
 118
 119         // visibility distance for clouds in meters
 120         static float CloudVis;
 121
 122         static sgVec3 view_vec, view_X, view_Y;
 123
 124         static float coverage;
 125         static float view_distance;
 126         static double timer_dt;
 127         static float fieldSize;
 128
 129         bool defined3D;
 130
 131         static float getCoverage(void) { return coverage; }
 132         static void setCoverage(float coverage) { coverage = coverage; }
 133
 134         static float getVisRange(void) { return view_distance; }
 135         static void setVisRange(float d) { view_distance = d; }
 136
 137         void applyCoverage(void);
 138         void applyVisRange(void);
 139
 140         typedef std::map<std::string, osg::ref_ptr<osg::StateSet> > StateSetMap;
 141         static StateSetMap cloudTextureMap;
 142
 143         static osg::Fog* getFog()
 144         {
 145                 return CloudFog::instance()->fog.get();
 146         }
 147         static void updateFog(double visibility, const osg::Vec4f& color);
 148 };
 149
 150 #endif // _CLOUDFIELD_HXX