Improved tile cache priority scheme.

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

diff --git a/simgear/scene/sky/cloud.cxx b/simgear/scene/sky/cloud.cxx
index 0addf208e55b66ecd46db90bb43c90b9cb64a24c..0c5b6e21acf7d8f3f03267660df7b2deca8a5297 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,
@@ -148,9 +151,7 @@ SGCloudLayer::SGCloudLayer( const string &tex_path ) :
     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
@@ -299,6 +300,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)
 {
@@ -485,6 +536,9 @@ SGCloudLayer::rebuild()
         
         layer_states[SG_CLOUD_CLEAR] = 0;
         layer_states2[SG_CLOUD_CLEAR] = 0;
+#if 1
+        // experimental optimization that may not make any difference
+        // at all :/
         osg::CopyOp copyOp;
         for (int i = 0; i < SG_MAX_CLOUD_COVERAGES; ++i) {
             StateAttributeFactory *saf = StateAttributeFactory::instance();
@@ -495,13 +549,10 @@ SGCloudLayer::rebuild()
                 layer_states2[i]->setAttribute(saf ->getCullFaceBack());
             }
         }
-      // OSGFIXME
-//             SGNewCloud::loadTextures(texture_path.str());
-//             layer3D->buildTestLayer();
+#endif
     }
 
     scale = 4000.0;
-    last_lon = last_lat = -999.0f;
 
     setTextureOffset(base);
     // build the cloud layer
@@ -604,7 +655,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));
@@ -624,7 +675,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;
@@ -634,7 +685,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;
 
@@ -678,20 +729,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
@@ -708,7 +756,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;
         }
 
@@ -721,7 +769,8 @@ 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;
+
+//        const float layer_scale = layer_span / scale;
 
         // cout << "xoff = " << xoff << ", yoff = " << yoff << endl;
         base[0] += xoff;
@@ -756,8 +805,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);