simgear/scene/sky/oursun.cxx

   1 // oursun.hxx -- model earth's sun
   2 //
   3 // Written by Durk Talsma. Originally started October 1997, for distribution
   4 // with the FlightGear project. Version 2 was written in August and
   5 // September 1998. This code is based upon algorithms and data kindly
   6 // provided by Mr. Paul Schlyter. (pausch@saaf.se).
   7 //
   8 // Separated out rendering pieces and converted to ssg by Curt Olson,
   9 // March 2000
  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 #ifdef HAVE_CONFIG_H
  28 #  include <simgear_config.h>
  29 #endif
  30
  31 #include <simgear/compiler.h>
  32
  33 #include <osg/AlphaFunc>
  34 #include <osg/BlendFunc>
  35 #include <osg/Fog>
  36 #include <osg/Geode>
  37 #include <osg/Geometry>
  38 #include <osg/Material>
  39 #include <osg/ShadeModel>
  40 #include <osg/TexEnv>
  41 #include <osg/Texture2D>
  42 #include <osgDB/ReadFile>
  43
  44 #include <simgear/math/SGMath.hxx>
  45 #include <simgear/scene/util/SGReaderWriterOptions.hxx>
  46 #include <simgear/screen/colors.hxx>
  47 #include <simgear/scene/model/model.hxx>
  48 #include "oursun.hxx"
  49
  50 using namespace simgear;
  51
  52 // Constructor
  53 SGSun::SGSun( void ) :
  54     visibility(-9999.0), prev_sun_angle(-9999.0), path_distance(60000.0),
  55     sun_exp2_punch_through(7.0e-06)
  56 {
  57
  58 }
  59
  60
  61 // Destructor
  62 SGSun::~SGSun( void ) {
  63 }
  64
  65
  66 // initialize the sun object and connect it into our scene graph root
  67 osg::Node*
  68 SGSun::build( SGPath path, double sun_size, SGPropertyNode *property_tree_Node ) {
  69
  70     env_node = property_tree_Node;
  71
  72     osg::ref_ptr<SGReaderWriterOptions> options;
  73     options = SGReaderWriterOptions::fromPath(path.str());
  74     // build the ssg scene graph sub tree for the sky and connected
  75     // into the provide scene graph branch
  76     sun_transform = new osg::MatrixTransform;
  77     osg::StateSet* stateSet = sun_transform->getOrCreateStateSet();
  78
  79     osg::TexEnv* texEnv = new osg::TexEnv;
  80     texEnv->setMode(osg::TexEnv::MODULATE);
  81     stateSet->setTextureAttribute(0, texEnv, osg::StateAttribute::ON);
  82
  83     osg::Material* material = new osg::Material;
  84     material->setColorMode(osg::Material::AMBIENT_AND_DIFFUSE);
  85     material->setEmission(osg::Material::FRONT_AND_BACK, osg::Vec4(0,0,0,1));
  86     material->setSpecular(osg::Material::FRONT_AND_BACK, osg::Vec4(0,0,0,1));
  87     stateSet->setAttribute(material);
  88
  89     osg::ShadeModel* shadeModel = new osg::ShadeModel;
  90     shadeModel->setMode(osg::ShadeModel::SMOOTH);
  91     stateSet->setAttributeAndModes(shadeModel);
  92
  93     osg::AlphaFunc* alphaFunc = new osg::AlphaFunc;
  94     alphaFunc->setFunction(osg::AlphaFunc::ALWAYS);
  95     stateSet->setAttributeAndModes(alphaFunc);
  96
  97     osg::BlendFunc* blendFunc = new osg::BlendFunc;
  98     blendFunc->setSource(osg::BlendFunc::SRC_ALPHA);
  99     blendFunc->setDestination(osg::BlendFunc::ONE_MINUS_SRC_ALPHA);
 100     stateSet->setAttributeAndModes(blendFunc);
 101
 102     stateSet->setMode(GL_FOG, osg::StateAttribute::OFF);
 103     stateSet->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
 104     stateSet->setMode(GL_CULL_FACE, osg::StateAttribute::OFF);
 105     stateSet->setMode(GL_DEPTH_TEST, osg::StateAttribute::OFF);
 106
 107     osg::Geode* geode = new osg::Geode;
 108     stateSet = geode->getOrCreateStateSet();
 109
 110     stateSet->setRenderBinDetails(-6, "RenderBin");
 111
 112     // set up the sun-state
 113     osg::Texture2D* texture = SGLoadTexture2D("sun.png", options.get());
 114     stateSet->setTextureAttributeAndModes(0, texture);
 115
 116     // Build scenegraph
 117     sun_cl = new osg::Vec4Array;
 118     sun_cl->push_back(osg::Vec4(1, 1, 1, 1));
 119
 120     scene_cl = new osg::Vec4Array;
 121     scene_cl->push_back(osg::Vec4(1, 1, 1, 1));
 122
 123     osg::Vec3Array* sun_vl = new osg::Vec3Array;
 124     sun_vl->push_back(osg::Vec3(-sun_size, 0, -sun_size));
 125     sun_vl->push_back(osg::Vec3(sun_size, 0, -sun_size));
 126     sun_vl->push_back(osg::Vec3(-sun_size, 0, sun_size));
 127     sun_vl->push_back(osg::Vec3(sun_size, 0, sun_size));
 128
 129     osg::Vec2Array* sun_tl = new osg::Vec2Array;
 130     sun_tl->push_back(osg::Vec2(0, 0));
 131     sun_tl->push_back(osg::Vec2(1, 0));
 132     sun_tl->push_back(osg::Vec2(0, 1));
 133     sun_tl->push_back(osg::Vec2(1, 1));
 134
 135     osg::Geometry* geometry = new osg::Geometry;
 136     geometry->setUseDisplayList(false);
 137     geometry->setVertexArray(sun_vl);
 138     geometry->setColorArray(sun_cl.get(), osg::Array::BIND_OVERALL);
 139     geometry->setNormalBinding(osg::Geometry::BIND_OFF);
 140     geometry->setTexCoordArray(0, sun_tl, osg::Array::BIND_PER_VERTEX);
 141     geometry->addPrimitiveSet(new osg::DrawArrays(GL_TRIANGLE_STRIP, 0, 4));
 142     geode->addDrawable(geometry);
 143
 144     sun_transform->addChild( geode );
 145
 146     // set up the inner-halo state
 147     geode = new osg::Geode;
 148     stateSet = geode->getOrCreateStateSet();
 149     stateSet->setRenderBinDetails(-7, "RenderBin");
 150
 151     texture = SGLoadTexture2D("inner_halo.png", options.get());
 152     stateSet->setTextureAttributeAndModes(0, texture);
 153
 154     // Build ssg structure
 155     ihalo_cl = new osg::Vec4Array;
 156     ihalo_cl->push_back(osg::Vec4(1, 1, 1, 1));
 157
 158     float ihalo_size = sun_size * 2.0;
 159     osg::Vec3Array* ihalo_vl = new osg::Vec3Array;
 160     ihalo_vl->push_back(osg::Vec3(-ihalo_size, 0, -ihalo_size));
 161     ihalo_vl->push_back(osg::Vec3(ihalo_size, 0, -ihalo_size));
 162     ihalo_vl->push_back(osg::Vec3(-ihalo_size, 0, ihalo_size));
 163     ihalo_vl->push_back(osg::Vec3(ihalo_size, 0, ihalo_size));
 164
 165     osg::Vec2Array* ihalo_tl = new osg::Vec2Array;
 166     ihalo_tl->push_back(osg::Vec2(0, 0));
 167     ihalo_tl->push_back(osg::Vec2(1, 0));
 168     ihalo_tl->push_back(osg::Vec2(0, 1));
 169     ihalo_tl->push_back(osg::Vec2(1, 1));
 170
 171     geometry = new osg::Geometry;
 172     geometry->setUseDisplayList(false);
 173     geometry->setVertexArray(ihalo_vl);
 174     geometry->setColorArray(ihalo_cl.get(), osg::Array::BIND_OVERALL);
 175     geometry->setNormalBinding(osg::Geometry::BIND_OFF);
 176     geometry->setTexCoordArray(0, ihalo_tl, osg::Array::BIND_PER_VERTEX);
 177     geometry->addPrimitiveSet(new osg::DrawArrays(GL_TRIANGLE_STRIP, 0, 4));
 178     geode->addDrawable(geometry);
 179
 180     sun_transform->addChild( geode );
 181
 182     // set up the outer halo state
 183
 184     geode = new osg::Geode;
 185     stateSet = geode->getOrCreateStateSet();
 186     stateSet->setRenderBinDetails(-8, "RenderBin");
 187
 188     texture = SGLoadTexture2D("outer_halo.png", options.get());
 189     stateSet->setTextureAttributeAndModes(0, texture);
 190
 191     // Build ssg structure
 192     ohalo_cl = new osg::Vec4Array;
 193     ohalo_cl->push_back(osg::Vec4(1, 1, 1, 1));
 194
 195     double ohalo_size = sun_size * 8.0;
 196     osg::Vec3Array* ohalo_vl = new osg::Vec3Array;
 197     ohalo_vl->push_back(osg::Vec3(-ohalo_size, 0, -ohalo_size));
 198     ohalo_vl->push_back(osg::Vec3(ohalo_size, 0, -ohalo_size));
 199     ohalo_vl->push_back(osg::Vec3(-ohalo_size, 0, ohalo_size));
 200     ohalo_vl->push_back(osg::Vec3(ohalo_size, 0, ohalo_size));
 201
 202     osg::Vec2Array* ohalo_tl = new osg::Vec2Array;
 203     ohalo_tl->push_back(osg::Vec2(0, 0));
 204     ohalo_tl->push_back(osg::Vec2(1, 0));
 205     ohalo_tl->push_back(osg::Vec2(0, 1));
 206     ohalo_tl->push_back(osg::Vec2(1, 1));
 207
 208     geometry = new osg::Geometry;
 209     geometry->setUseDisplayList(false);
 210     geometry->setVertexArray(ohalo_vl);
 211     geometry->setColorArray(ohalo_cl.get(), osg::Array::BIND_OVERALL);
 212     geometry->setNormalBinding(osg::Geometry::BIND_OFF);
 213     geometry->setTexCoordArray(0, ohalo_tl, osg::Array::BIND_PER_VERTEX);
 214     geometry->addPrimitiveSet(new osg::DrawArrays(GL_TRIANGLE_STRIP, 0, 4));
 215     geode->addDrawable(geometry);
 216
 217     sun_transform->addChild( geode );
 218
 219     // force a repaint of the sun colors with arbitrary defaults
 220     repaint( 0.0, 1.0 );
 221
 222     return sun_transform.get();
 223 }
 224
 225
 226 // repaint the sun colors based on current value of sun_angle in
 227 // degrees relative to verticle
 228 // 0 degrees = high noon
 229 // 90 degrees = sun rise/set
 230 // 180 degrees = darkest midnight
 231 bool SGSun::repaint( double sun_angle, double new_visibility ) {
 232
 233     if ( visibility != new_visibility ) {
 234         if (new_visibility < 100.0) new_visibility = 100.0;
 235         else if (new_visibility > 45000.0) new_visibility = 45000.0;
 236         visibility = new_visibility;
 237         sun_exp2_punch_through = 2.0/log(visibility);
 238     }
 239
 240     if ( prev_sun_angle != sun_angle ) {
 241         prev_sun_angle = sun_angle;
 242
 243         // determine how much aerosols are in the air (rough guess)
 244         double aerosol_factor;
 245         if ( visibility < 100 ) {
 246             aerosol_factor = 8000;
 247         }
 248         else {
 249             aerosol_factor = 80.5 / log( visibility / 99.9 );
 250         }
 251
 252         // get environmental data from property tree or use defaults
 253         double rel_humidity, density_avg;
 254
 255         if ( !env_node ) {
 256             rel_humidity = 0.5;
 257             density_avg = 0.7;
 258         }
 259         else {
 260             rel_humidity = env_node->getFloatValue( "relative-humidity" );
 261             density_avg =  env_node->getFloatValue( "atmosphere/density-tropo-avg" );
 262         }
 263
 264         // ok, now let's go and generate the sun and scene color
 265         osg::Vec4 i_halo_color, o_halo_color, scene_color, sun_color;
 266
 267         // Some comments:
 268         // * When the sunangle changes, light has to travel a longer
 269         //   distance through the atmosphere. So it's scattered more due
 270         //   to raleigh scattering, which affects blue more than green
 271         //   light.
 272         // * Red is almost not scattered and effectively only get's
 273         //   touched when the sun is near the horizon.
 274         // * Visability also affects suncolor inasmuch as more particles
 275         //   are in the air that cause more scattering.
 276         // * We base our calculation on the halo's color, which is most
 277         //   scattered.
 278         double red_scat_f, red_scat_corr_f, green_scat_f, blue_scat_f;
 279
 280         // Red - is almost not scattered
 281         // Lambda is 700 nm
 282
 283         red_scat_f = (aerosol_factor * path_distance * density_avg)/5E+07;
 284         red_scat_corr_f = sun_exp2_punch_through / (1 - red_scat_f);
 285         sun_color[0] = 1;
 286         scene_color[0] = 1 - red_scat_f;
 287
 288         // Green - 546.1 nm
 289         green_scat_f = (aerosol_factor * path_distance * density_avg)/8.8938E+06;
 290         sun_color[1] = 1 - green_scat_f * red_scat_corr_f;
 291         scene_color[1] = 1 - green_scat_f;
 292
 293         // Blue - 435.8 nm
 294         blue_scat_f = (aerosol_factor * path_distance * density_avg)/3.607E+06;
 295         sun_color[2] = 1 - blue_scat_f * red_scat_corr_f;
 296         scene_color[2] = 1 - blue_scat_f;
 297
 298         // Alpha
 299         sun_color[3] = 1;
 300         scene_color[3] = 1;
 301
 302         // Now that we have the color calculated
 303         // let's consider the saturation which is produced by mie scattering
 304         double saturation = 1 - ( rel_humidity / 200 );
 305         scene_color[1] += (( 1 - saturation ) * ( 1 - scene_color[1] ));
 306         scene_color[2] += (( 1 - saturation ) * ( 1 - scene_color[2] ));
 307
 308         if (sun_color[0] > 1.0) sun_color[0] = 1.0;
 309         if (sun_color[0] < 0.0) sun_color[0] = 0.0;
 310         if (sun_color[1] > 1.0) sun_color[1] = 1.0;
 311         if (sun_color[1] < 0.0) sun_color[1] = 0.0;
 312         if (sun_color[2] > 1.0) sun_color[2] = 1.0;
 313         if (sun_color[2] < 0.0) sun_color[2] = 0.0;
 314
 315         if (scene_color[0] > 1.0) scene_color[0] = 1.0;
 316         if (scene_color[0] < 0.0) scene_color[0] = 0.0;
 317         if (scene_color[1] > 1.0) scene_color[1] = 1.0;
 318         if (scene_color[1] < 0.0) scene_color[1] = 0.0;
 319         if (scene_color[2] > 1.0) scene_color[2] = 1.0;
 320         if (scene_color[2] < 0.0) scene_color[2] = 0.0;
 321
 322         double scene_f = 0.5 * (1 / (1 - red_scat_f));
 323         double sun_f = 1.0 - scene_f;
 324         i_halo_color[0] = sun_f * sun_color[0] + scene_f * scene_color[0];
 325         i_halo_color[1] = sun_f * sun_color[1] + scene_f * scene_color[1];
 326         i_halo_color[2] = sun_f * sun_color[2] + scene_f * scene_color[2];
 327         i_halo_color[3] = 1;
 328
 329         o_halo_color[0] = 0.2 * sun_color[0] + 0.8 * scene_color[0];
 330         o_halo_color[1] = 0.2 * sun_color[1] + 0.8 * scene_color[1];
 331         o_halo_color[2] = 0.2 * sun_color[2] + 0.8 * scene_color[2];
 332         o_halo_color[3] = blue_scat_f;
 333         if ((visibility < 10000) && (blue_scat_f > 1)) {
 334             o_halo_color[3] = 2 - blue_scat_f;
 335         }
 336         if (o_halo_color[3] > 1) o_halo_color[3] = 1;
 337         if (o_halo_color[3] < 0) o_halo_color[3] = 0;
 338
 339         gamma_correct_rgb( i_halo_color._v );
 340         gamma_correct_rgb( o_halo_color._v );
 341         gamma_correct_rgb( scene_color._v );
 342         gamma_correct_rgb( sun_color._v );
 343
 344         (*sun_cl)[0] = sun_color;
 345         sun_cl->dirty();
 346         (*scene_cl)[0] = scene_color;
 347         scene_cl->dirty();
 348         (*ihalo_cl)[0] = i_halo_color;
 349         ihalo_cl->dirty();
 350         (*ohalo_cl)[0] = o_halo_color;
 351         ohalo_cl->dirty();
 352     }
 353
 354     return true;
 355 }
 356
 357
 358 // reposition the sun at the specified right ascension and
 359 // declination, offset by our current position (p) so that it appears
 360 // fixed at a great distance from the viewer.  Also add in an optional
 361 // rotation (i.e. for the current time of day.)
 362 // Then calculate stuff needed for the sun-coloring
 363 bool SGSun::reposition( double rightAscension, double declination,
 364                         double sun_dist, double lat, double alt_asl, double sun_angle)
 365 {
 366     // GST - GMT sidereal time
 367     osg::Matrix T2, RA, DEC;
 368
 369     // xglRotatef( ((SGD_RADIANS_TO_DEGREES * rightAscension)- 90.0),
 370     //             0.0, 0.0, 1.0);
 371     RA.makeRotate(rightAscension - 90*SGD_DEGREES_TO_RADIANS, osg::Vec3(0, 0, 1));
 372
 373     // xglRotatef((SGD_RADIANS_TO_DEGREES * declination), 1.0, 0.0, 0.0);
 374     DEC.makeRotate(declination, osg::Vec3(1, 0, 0));
 375
 376     // xglTranslatef(0,sun_dist);
 377     T2.makeTranslate(osg::Vec3(0, sun_dist, 0));
 378
 379     sun_transform->setMatrix(T2*DEC*RA);
 380
 381     // Suncolor related things:
 382     if ( prev_sun_angle != sun_angle ) {
 383       if ( sun_angle == 0 ) sun_angle = 0.1;
 384          const double r_earth_pole = 6356752.314;
 385          const double r_tropo_pole = 6356752.314 + 8000;
 386          const double epsilon_earth2 = 6.694380066E-3;
 387          const double epsilon_tropo2 = 9.170014946E-3;
 388
 389          double r_tropo = r_tropo_pole / sqrt ( 1 - ( epsilon_tropo2 * pow ( cos( lat ), 2 )));
 390          double r_earth = r_earth_pole / sqrt ( 1 - ( epsilon_earth2 * pow ( cos( lat ), 2 )));
 391
 392          double position_radius = r_earth + alt_asl;
 393
 394          double gamma =  SG_PI - sun_angle;
 395          double sin_beta =  ( position_radius * sin ( gamma )  ) / r_tropo;
 396          if (sin_beta > 1.0) sin_beta = 1.0;
 397          double alpha =  SG_PI - gamma - asin( sin_beta );
 398
 399          // OK, now let's calculate the distance the light travels
 400          path_distance = sqrt( pow( position_radius, 2 ) + pow( r_tropo, 2 )
 401                         - ( 2 * position_radius * r_tropo * cos( alpha ) ));
 402
 403          double alt_half = sqrt( pow ( r_tropo, 2 ) + pow( path_distance / 2, 2 ) - r_tropo * path_distance * cos( asin( sin_beta )) ) - r_earth;
 404
 405          if ( alt_half < 0.0 ) alt_half = 0.0;
 406
 407          // Push the data to the property tree, so it can be used in the enviromental code
 408          if ( env_node ){
 409             env_node->setDoubleValue( "atmosphere/altitude-troposphere-top", r_tropo - r_earth );
 410             env_node->setDoubleValue( "atmosphere/altitude-half-to-sun", alt_half );
 411       }
 412     }
 413
 414     return true;
 415 }
 416
 417 SGVec4f
 418 SGSun::get_color()
 419 {
 420     return SGVec4f((*sun_cl)[0][0], (*sun_cl)[0][1], (*sun_cl)[0][2], (*sun_cl)[0][3]);
 421 }
 422
 423 SGVec4f
 424 SGSun::get_scene_color()
 425 {
 426     return SGVec4f((*scene_cl)[0][0], (*scene_cl)[0][1], (*scene_cl)[0][2], (*scene_cl)[0][3]);
 427 }