// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
-// $Id$
#ifdef HAVE_CONFIG_H
# include <simgear_config.h>
#include <math.h>
+#include <simgear/structure/OSGVersion.hxx>
#include <osg/AlphaFunc>
#include <osg/BlendFunc>
#include <osg/CullFace>
#include <osg/TextureCubeMap>
#include <osg/TexMat>
#include <osg/Fog>
+#if SG_OSG_MIN_VERSION_REQUIRED(2,9,5)
+#include <osgDB/Options>
+#endif
#include <simgear/math/sg_random.h>
#include <simgear/misc/PathOptions.hxx>
#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"
// # 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;
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,
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)
+ last_course(0.0),
+ max_alpha(1.0)
{
// XXX
// Render bottoms before the rest of transparent objects (rendered
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
{
}
}
+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)
{
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();
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
// 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));
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;
// 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;
// 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
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;
}
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;
// 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);
projects / simgear.git / blobdiff