simgear/scene/sky/sky.cxx: Include sg_inlines.h with simgear/ prefix as all other...

[simgear.git] / simgear / scene / sky / cloud.cxx

diff --git a/simgear/scene/sky/cloud.cxx b/simgear/scene/sky/cloud.cxx
index 503763149450c72f355ad525f4036e514055eed9..aa5e44c0ac8abd6304dc1a03dee16c4873211e88 100644 (file)
--- a/simgear/scene/sky/cloud.cxx
+++ b/simgear/scene/sky/cloud.cxx
@@ -54,7 +54,7 @@
 #include <simgear/scene/model/model.hxx>
 #include <simgear/scene/util/RenderConstants.hxx>
 #include <simgear/scene/util/StateAttributeFactory.hxx>
-#include <simgear/math/polar3d.hxx>
+#include <simgear/screen/extensions.hxx>
 
 #include "newcloud.hxx"
 #include "cloudfield.hxx"
@@ -75,10 +75,6 @@ using namespace osg;
 // #  endif
 // #endif
 
-#if defined (__CYGWIN__)
-#include <ieeefp.h>
-#endif
-
 static osg::ref_ptr<osg::StateSet> layer_states[SGCloudLayer::SG_MAX_CLOUD_COVERAGES];
 static osg::ref_ptr<osg::StateSet> layer_states2[SGCloudLayer::SG_MAX_CLOUD_COVERAGES];
 static osg::ref_ptr<osg::TextureCubeMap> cubeMap;
@@ -87,6 +83,13 @@ static bool bump_mapping = false;
 
 bool SGCloudLayer::enable_bump_mapping = false;
 
+const std::string SGCloudLayer::SG_CLOUD_OVERCAST_STRING = "overcast";
+const std::string SGCloudLayer::SG_CLOUD_BROKEN_STRING = "broken";
+const std::string SGCloudLayer::SG_CLOUD_SCATTERED_STRING = "scattered";
+const std::string SGCloudLayer::SG_CLOUD_FEW_STRING = "few";
+const std::string SGCloudLayer::SG_CLOUD_CIRRUS_STRING = "cirrus";
+const std::string SGCloudLayer::SG_CLOUD_CLEAR_STRING = "clear";
+
 // make an StateSet for a cloud layer given the named texture
 static osg::StateSet*
 SGMakeState(const SGPath &path, const char* colorTexture,
@@ -145,12 +148,11 @@ SGCloudLayer::SGCloudLayer( const string &tex_path ) :
     layer_asl(0.0),
     layer_thickness(0.0),
     layer_transition(0.0),
+    layer_visibility(25.0),
     layer_coverage(SG_CLOUD_CLEAR),
     scale(4000.0),
     speed(0.0),
-    direction(0.0),
-    last_lon(0.0),
-    last_lat(0.0)
+    direction(0.0)
 {
     // XXX
     // Render bottoms before the rest of transparent objects (rendered
@@ -259,6 +261,18 @@ SGCloudLayer::setThickness_m (float thickness_m)
     layer_thickness = thickness_m;
 }
 
+float
+SGCloudLayer::getVisibility_m() const
+{
+    return layer_visibility;
+}
+
+void
+SGCloudLayer::setVisibility_m (float visibility_m)
+{
+    layer_visibility = visibility_m;
+}
+
 float
 SGCloudLayer::getTransition_m () const
 {
@@ -299,6 +313,56 @@ SGCloudLayer::setCoverage (Coverage coverage)
     }
 }
 
+const std::string &
+SGCloudLayer::getCoverageString( Coverage coverage )
+{
+       switch( coverage ) {
+               case SG_CLOUD_OVERCAST:
+                       return SG_CLOUD_OVERCAST_STRING;
+               case SG_CLOUD_BROKEN:
+                       return SG_CLOUD_BROKEN_STRING;
+               case SG_CLOUD_SCATTERED:
+                       return SG_CLOUD_SCATTERED_STRING;
+               case SG_CLOUD_FEW:
+                       return SG_CLOUD_FEW_STRING;
+               case SG_CLOUD_CIRRUS:
+                       return SG_CLOUD_CIRRUS_STRING;
+               case SG_CLOUD_CLEAR:
+               default:
+                       return SG_CLOUD_CLEAR_STRING;
+       }
+}
+
+SGCloudLayer::Coverage 
+SGCloudLayer::getCoverageType( const std::string & coverage )
+{
+       if( SG_CLOUD_OVERCAST_STRING == coverage ) {
+               return SG_CLOUD_OVERCAST;
+       } else if( SG_CLOUD_BROKEN_STRING == coverage ) {
+               return SG_CLOUD_BROKEN;
+       } else if( SG_CLOUD_SCATTERED_STRING == coverage ) {
+               return SG_CLOUD_SCATTERED;
+       } else if( SG_CLOUD_FEW_STRING == coverage ) {
+               return SG_CLOUD_FEW;
+       } else if( SG_CLOUD_CIRRUS_STRING == coverage ) {
+               return SG_CLOUD_CIRRUS;
+       } else {
+               return SG_CLOUD_CLEAR;
+       }
+}
+
+const std::string &
+SGCloudLayer::getCoverageString() const
+{
+       return getCoverageString(layer_coverage);
+}
+
+void
+SGCloudLayer::setCoverageString( const std::string & coverage )
+{
+       setCoverage( getCoverageType(coverage) );
+}
+
 void
 SGCloudLayer::setTextureOffset(const osg::Vec2& offset)
 {
@@ -502,7 +566,6 @@ SGCloudLayer::rebuild()
     }
 
     scale = 4000.0;
-    last_lon = last_lat = -999.0f;
 
     setTextureOffset(base);
     // build the cloud layer
@@ -605,7 +668,7 @@ SGCloudLayer::rebuild()
 
 // repaint the cloud layer colors
 bool SGCloudLayer::repaint( const SGVec3f& fog_color ) {
-    osg::Vec4f combineColor(fog_color.osg(), cloud_alpha);
+    osg::Vec4f combineColor(toOsg(fog_color), cloud_alpha);
     osg::TexEnvCombine* combiner
         = dynamic_cast<osg::TexEnvCombine*>(layer_root->getStateSet()
                                             ->getTextureAttribute(1, osg::StateAttribute::TEXENV));
@@ -625,7 +688,7 @@ bool SGCloudLayer::reposition( const SGVec3f& p, const SGVec3f& up, double lon,
                               double alt, double dt )
 {
     // combine p and asl (meters) to get translation offset
-    osg::Vec3 asl_offset(up.osg());
+    osg::Vec3 asl_offset(toOsg(up));
     asl_offset.normalize();
     if ( alt <= layer_asl ) {
         asl_offset *= layer_asl;
@@ -635,7 +698,7 @@ bool SGCloudLayer::reposition( const SGVec3f& p, const SGVec3f& up, double lon,
 
     // cout << "asl_offset = " << asl_offset[0] << "," << asl_offset[1]
     //      << "," << asl_offset[2] << endl;
-    asl_offset += p.osg();
+    asl_offset += toOsg(p);
     // cout << "  asl_offset = " << asl_offset[0] << "," << asl_offset[1]
     //      << "," << asl_offset[2] << endl;
 
@@ -679,20 +742,17 @@ bool SGCloudLayer::reposition( const SGVec3f& p, const SGVec3f& up, double lon,
         
 
     // now calculate update texture coordinates
-    if ( last_lon < -900 ) {
-        last_lon = lon;
-        last_lat = lat;
+    SGGeod pos = SGGeod::fromRad(lon, lat);
+    if ( last_pos == SGGeod() ) {
+        last_pos = pos;
     }
 
     double sp_dist = speed*dt;
-
-    if ( lon != last_lon || lat != last_lat || sp_dist != 0 ) {
-        Point3D start( last_lon, last_lat, 0.0 );
-        Point3D dest( lon, lat, 0.0 );
-        double course = 0.0, dist = 0.0;
-
-        calc_gc_course_dist( dest, start, &course, &dist );
-        // cout << "course = " << course << ", dist = " << dist << endl;
+    
+    
+    if ( lon != last_pos.getLongitudeRad() || lat != last_pos.getLatitudeRad() || sp_dist != 0 ) {
+        double course = SGGeodesy::courseDeg(last_pos, pos) * SG_DEGREES_TO_RADIANS, 
+            dist = SGGeodesy::distanceM(last_pos, pos);
 
         // if start and dest are too close together,
         // calc_gc_course_dist() can return a course of "nan".  If
@@ -709,7 +769,7 @@ bool SGCloudLayer::reposition( const SGVec3f& p, const SGVec3f& up, double lon,
         double ax = 0.0, ay = 0.0, bx = 0.0, by = 0.0;
 
         if (dist > 0.0) {
-            ax = cos(course) * dist;
+            ax = -cos(course) * dist;
             ay = sin(course) * dist;
         }
 
@@ -722,6 +782,7 @@ bool SGCloudLayer::reposition( const SGVec3f& p, const SGVec3f& up, double lon,
         double xoff = (ax + bx) / (2 * scale);
         double yoff = (ay + by) / (2 * scale);
 
+
 //        const float layer_scale = layer_span / scale;
 
         // cout << "xoff = " << xoff << ", yoff = " << yoff << endl;
@@ -757,8 +818,7 @@ bool SGCloudLayer::reposition( const SGVec3f& p, const SGVec3f& up, double lon,
         // cout << "base = " << base[0] << "," << base[1] << endl;
 
         setTextureOffset(base);
-        last_lon = lon;
-        last_lat = lat;
+        last_pos = pos;
     }
 
     layer3D->reposition( p, up, lon, lat, dt, layer_asl);