X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=simgear%2Fsky%2Fsky.cxx;h=5cde898fb29e360e460a0c0f12b50326c597dd53;hb=6531b1ebbc5c82bed5f52869511e880afd05bfcf;hp=beff38a8c608528cd737505a8a946febad95a97d;hpb=c2b84db5a20e3876a49367486fcd9ac7d3dcbe94;p=simgear.git diff --git a/simgear/sky/sky.cxx b/simgear/sky/sky.cxx index beff38a8..5cde898f 100644 --- a/simgear/sky/sky.cxx +++ b/simgear/sky/sky.cxx @@ -26,13 +26,26 @@ # include #endif -#include // plib include +#include +#include + +#include #include "sky.hxx" // Constructor SGSky::SGSky( void ) { + effective_visibility = visibility = 10000.0; + + // near cloud visibility state variables + in_puff = false; + puff_length = 0; + puff_progression = 0; + ramp_up = 0.15; + ramp_down = 0.15; + // ramp_up = 4.0; + // ramp_down = 4.0; } @@ -82,6 +95,25 @@ void SGSky::build( double sun_size, double moon_size, pre_root->addKid( pre_selector ); post_root->addKid( post_selector ); + + // add the cloud ssgStates to the material lib + FGPath cloud_path; + + cloud_path.set( tex_path.str() ); + cloud_path.append( "overcast.rgb" ); + cloud_mats[SG_CLOUD_OVERCAST] = SGCloudMakeState( cloud_path.str() ); + + cloud_path.set( tex_path.str() ); + cloud_path.append( "mostlycloudy.rgba" ); + cloud_mats[SG_CLOUD_MOSTLY_CLOUDY] = SGCloudMakeState( cloud_path.str() ); + + cloud_path.set( tex_path.str() ); + cloud_path.append( "mostlysunny.rgba" ); + cloud_mats[SG_CLOUD_MOSTLY_SUNNY] = SGCloudMakeState( cloud_path.str() ); + + cloud_path.set( tex_path.str() ); + cloud_path.append( "cirrus.rgba" ); + cloud_mats[SG_CLOUD_CIRRUS] = SGCloudMakeState( cloud_path.str() ); } @@ -97,14 +129,20 @@ bool SGSky::repaint( sgVec4 sky_color, sgVec4 fog_color, int nplanets, sgdVec3 *planet_data, int nstars, sgdVec3 *star_data ) { - dome->repaint( sky_color, fog_color, sun_angle ); - oursun->repaint( sun_angle ); - moon->repaint( moon_angle ); - planets->repaint( sun_angle, nplanets, planet_data ); - stars->repaint( sun_angle, nstars, star_data ); - - for ( int i = 0; i < (int)cloud_layers.size(); ++i ) { - cloud_layers[i]->repaint( fog_color ); + if ( effective_visibility > 1000.0 ) { + enable(); + dome->repaint( sky_color, fog_color, sun_angle, effective_visibility ); + oursun->repaint( sun_angle ); + moon->repaint( moon_angle ); + planets->repaint( sun_angle, nplanets, planet_data ); + stars->repaint( sun_angle, nstars, star_data ); + + for ( int i = 0; i < (int)cloud_layers.size(); ++i ) { + cloud_layers[i]->repaint( fog_color ); + } + } else { + // turn off sky + disable(); } return true; @@ -119,7 +157,7 @@ bool SGSky::repaint( sgVec4 sky_color, sgVec4 fog_color, // additional orientation for the sunrise/set effects and is used by // the skydome and perhaps clouds. bool SGSky::reposition( sgVec3 view_pos, sgVec3 zero_elev, sgVec3 view_up, - double lon, double lat, double spin, + double lon, double lat, double alt, double spin, double gst, double sun_ra, double sun_dec, double sun_dist, double moon_ra, double moon_dec, double moon_dist ) @@ -132,27 +170,222 @@ bool SGSky::reposition( sgVec3 view_pos, sgVec3 zero_elev, sgVec3 view_up, stars->reposition( view_pos, angle ); for ( int i = 0; i < (int)cloud_layers.size(); ++i ) { - cloud_layers[i]->reposition( zero_elev, view_up, lon, lat ); + cloud_layers[i]->reposition( zero_elev, view_up, lon, lat, alt ); } return true; } -// draw background portions of the sky -void SGSky::draw_background() { +// draw background portions of the sky ... do this before you draw the +// rest of your scene. +void SGSky::preDraw() { ssgCullAndDraw( pre_root ); } -// draw scenery elements of the sky -void SGSky::draw_scene() { - ssgCullAndDraw( post_root ); +// draw translucent clouds ... do this after you've drawn all the +// oapaque elements of your scene. +void SGSky::postDraw( float alt ) { + float slop = 5.0; // if we are closer than this to a cloud layer, + // don't draw clouds + + int in_cloud = -1; // cloud we are in + + // check where we are relative to the cloud layers + for ( int i = 0; i < (int)cloud_layers.size(); ++i ) { + float asl = cloud_layers[i]->get_asl(); + float thickness = cloud_layers[i]->get_thickness(); + + if ( alt < asl - slop ) { + // below cloud layer + } else if ( alt < asl + thickness + slop ) { + // in cloud layer + + // bail now and don't draw any clouds + in_cloud = i; + } else { + // above cloud layer + } + } + + // determine rendering order + int pos = 0; + while ( pos < (int)cloud_layers.size() && + alt > cloud_layers[pos]->get_asl()) + { + ++pos; + } + + if ( pos == 0 ) { + // we are below all the cloud layers, draw top to bottom + for ( int i = cloud_layers.size() - 1; i >= 0; --i ) { + if ( i != in_cloud ) { + cloud_layers[i]->draw(); + } + } + } else if ( pos >= (int)cloud_layers.size() ) { + // we are above all the cloud layers, draw bottom to top + for ( int i = 0; i < (int)cloud_layers.size(); ++i ) { + if ( i != in_cloud ) { + cloud_layers[i]->draw(); + } + } + } else { + // we are between cloud layers, draw lower layers bottom to + // top and upper layers top to bottom + for ( int i = 0; i < pos; ++i ) { + if ( i != in_cloud ) { + cloud_layers[i]->draw(); + } + } + for ( int i = cloud_layers.size() - 1; i >= pos; --i ) { + if ( i != in_cloud ) { + cloud_layers[i]->draw(); + } + } + } } -void SGSky::add_cloud_layer( double asl ) { +void SGSky::add_cloud_layer( double asl, double thickness, + double transition, double span, + ssgSimpleState *state ) { SGCloudLayer *layer = new SGCloudLayer; - post_transform -> addKid( layer->build(tex_path, 20000.0f, asl) ); - cloud_layers.push_back( layer ); + layer->build( span, asl, thickness, transition, state ); + + layer_list_iterator current = cloud_layers.begin(); + layer_list_iterator last = cloud_layers.end(); + while ( current != last && (*current)->get_asl() < asl ) { + ++current; + } + + if ( current != last ) { + cloud_layers.insert( current, layer ); + } else { + cloud_layers.push_back( layer ); + } + + for ( int i = 0; i < (int)cloud_layers.size(); ++i ) { + cout << "layer " << i << " = " << cloud_layers[i]->get_asl() << endl; + } + cout << endl; +} + + +void SGSky::add_cloud_layer( double asl, double thickness, + double transition, double span, + const string &tex_path ) { + ssgSimpleState *state = SGCloudMakeState( tex_path ); + add_cloud_layer( asl, thickness, transition, span, state ); +} + + +void SGSky::add_cloud_layer( double asl, double thickness, + double transition, double span, + SGCloudType type ) { + if ( type > 0 && type < SG_MAX_CLOUD_TYPES ) { + add_cloud_layer( asl, thickness, transition, span, cloud_mats[type] ); + } } + + +// modify the current visibility based on cloud layers, thickness, +// transition range, and simulated "puffs". +void SGSky::modify_vis( float alt, float time_factor ) { + float effvis = visibility; + + for ( int i = 0; i < (int)cloud_layers.size(); ++i ) { + float asl = cloud_layers[i]->get_asl(); + float thickness = cloud_layers[i]->get_thickness(); + float transition = cloud_layers[i]->get_transition(); + + double ratio = 1.0; + + if ( alt < asl - transition ) { + // below cloud layer + ratio = 1.0; + } else if ( alt < asl ) { + // in lower transition + ratio = (asl - alt) / transition; + } else if ( alt < asl + thickness ) { + // in cloud layer + ratio = 0.0; + } else if ( alt < asl + thickness + transition ) { + // in upper transition + ratio = (alt - (asl + thickness)) / transition; + } else { + // above cloud layer + ratio = 1.0; + } + + // accumulate effects from multiple cloud layers + effvis *= ratio; + + if ( ratio < 1.0 ) { + if ( ! in_puff ) { + // calc chance of entering cloud puff + double rnd = fg_random(); + double chance = rnd * rnd * rnd; + if ( chance > 0.95 /* * (diff - 25) / 50.0 */ ) { + in_puff = true; + puff_length = fg_random() * 2.0; // up to 2 seconds + puff_progression = 0.0; + } + } + + if ( in_puff ) { + // modify actual_visibility based on puff envelope + + if ( puff_progression <= ramp_up ) { + double x = 0.5 * SGD_PI * puff_progression / ramp_up; + double factor = 1.0 - sin( x ); + // cout << "ramp up = " << puff_progression + // << " factor = " << factor << endl; + effvis = effvis * factor; + } else if ( puff_progression >= ramp_up + puff_length ) { + double x = 0.5 * SGD_PI * + (puff_progression - (ramp_up + puff_length)) / + ramp_down; + double factor = sin( x ); + // cout << "ramp down = " + // << puff_progression - (ramp_up + puff_length) + // << " factor = " << factor << endl; + effvis = effvis * factor; + } else { + effvis = 0.0; + } + + /* cout << "len = " << puff_length + << " x = " << x + << " factor = " << factor + << " actual_visibility = " << actual_visibility + << endl; */ + + // time_factor = ( global_multi_loop * + // current_options.get_speed_up() ) / + // (double)current_options.get_model_hz(); + + puff_progression += time_factor; + // cout << "time factor = " << time_factor << endl; + + /* cout << "gml = " << global_multi_loop + << " speed up = " << current_options.get_speed_up() + << " hz = " << current_options.get_model_hz() << endl; + */ + + if ( puff_progression > puff_length + ramp_up + ramp_down) { + in_puff = false; + } + } + + // never let visibility drop below 25 meters + if ( effvis <= 25.0 ) { + effvis = 25.0; + } + } + } // for + + effective_visibility = effvis; +} +