Environment Settings

• The IG plugin API section for more details on managing IG via code (C++).
• SkyMap Class for more details on managing sky and celestial bodies via code (C++).
• Meteo Class for more details on managing global weather settings via code (C++).
• Region Class for more details on managing weather regions via code (C++).

Star field intensity is very low by default. You may need to adjust brightness level of your displays or increase maximum brightness of the star field for your area.

To make the stars look brighter do the following:

• Temporarily disable the sun node in the Editor
• Open Environment Settings (Windows -> Settings -> Runtime/World/Render/Environment)
• Make sure the Environment Texture is set to star_c.hdr
• Click Environment Color and increase values of RGB color components until you reach the desired brightness of the star field (e.g., to 100,100,100)
  Notice

  Alpha channel is used by the system to control Star Intensity (e.g., via CIGI).
• Enable the sun node back again and save your world.

Stars are positioned on the sky automatically, depending on the date/time and geographic location.

IG has a built-in celestial body control (celestial_control packet). In order to use it, you should have:

• Two nodes, one for the Sun, and one for the Moon
• The Celestial property assigned to the sun node
• Parameters of the Celestial property containing links to the corresponding nodes.

Positions of the Sun and the Moon are adjusted automatically depending on the date/time and geographic location.

Sometimes it may be necessary to perform certain actions when the state of the sky changes (e.g. enable lighting at nignt time). Callbacks can be used for this purpose. Just implement your specific actions in a callback function and set it as follows:

/// callback function to be called when sky state changes
void SomeClass::my_callback()
{
	// pointer to your sun node (don't forget to initialize it)
	NodePtr sun;
	
	// calculating zenith angle to determine if it is night time or not
	float zenith = getAngle(vec3::UP, sun->getDirection(AXIS_Z));
	bool night = zenith > sun_zenit_threshold;
	
	// switching lights
	for (auto & it : lights)
	{
		it.data.setEnable(night);
	}
	
	// switching the emission state for emissive materials
	for (auto & it : emissive_materials)
	{
		it->setState("emission",night);
	}			
}

// ...
// somwhere in code
void SomeClass::init()
{
	// adding "my_callback" to be called on changing sky state
	ig_manager->getSkyMap()->addCallbackRefresh(this, Unigine::MakeCallback(this, &SomeClass::my_callback ) );
}

Volumetric clouds are particle masses that simulate light absorption, creating a realistic reduction in visibility when flown through. Clouds can cast shadows on the terrain.

IG currently supports Stratocumulus and Stratus clouds (types 9 and 10 according to CIGI specification), but you can extend this set by inheriting new materials from the clouds_base, tweaking their parameters and assigning these materials the the corresponding fields of the CloudsParams property (data/ig/weather/properties/CloudsParams.prop).

Cloud coverage is set automatically using the Coverage value from a weather_control packet received, or you can change it manually via the following code:

// setting cloud coverage for weather region with a given id
ig_manager->getMeteo()->getRegion(region_id)->setCloudDensity(density_value);

Cloud coverage does not change immediately, it has some transition period providing smoothness. You can adjust transition time by changing value in the cloud_transition_time tag in configuration file (data/ig_config.xml).

Lightning parameters can be found in the LightingProperties property (data/ig/weather/properties/LightingProperties.prop).

The following ones are available for adjustment:

• Period - interval between the subsequent lightning flashes, in seconds.
• Emission Params - a set of parameters defining emission properties of the lightning flash:
  • the first two are emission_random_factor_min and emission_random_factor_max - these values define the limits of random flash intensity (min and max deviation from the value of the Emission Scale parameter of the lightning material).
  • emission_period - defines the lifetime of a single flash, in seconds. This value should always be less than the interval between the subsequent flashes.

To adjust parameters for rain or snow (intensity, size of raindrops/snowflakes, etc.) select the corresponding node on the scene and tweak the parameters of the PrecipitationParams property assigned to it.

The following parameters are available:

• Minimum Intensity and Maximum Intensity - these values define the limits of random intensity of rain or snow.
• Minimum Particle Size and Particle Size - these values define size variation for raindrops or snowflakes.
• Source Node - node representing rain or snow on the scene.
• Lut Base Image - Base scattering LUT to be used.
• Lut Mie Image - Mie scattering LUT to be used.

Sometimes it may be necessary to perform certain actions when weather conditions change (e.g. to set orientation for a windsock or a vane). This can be done using callbacks the same way as for changing sky state. Just implement your specific actions in a callback function and set it as follows:

/// callback function to be called when weather conditions change
void SomeClass::my_weather_callback()
{
	// setting orientation of the vane downwind
	vec3 wind_direction = ig_manager->getMeteo()->getMeanWindSpeed(vane_node->getWorldPosition());
	vane_node->setWorldDirection(wind_direction, vec3::UP);
}

// ...
// somwhere in code
void SomeClass::init()
{
	// adding "my_weather_callback" to be called on changing weather conditions
	ig_manager->getMeteo()->addCallbackMeteoChanged(this, Unigine::MakeCallback(this, &SomeClass::my_weather_callback );
}