18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-19 23:55:00 +01:00
Files
maszyna/simulation/simulationenvironment.cpp
jerrrrycho 5bac4e1cf1 Fix the four issues failing the Sonar quality gate on master (#323)
* fix(scripting): forward the object in push_object of the Lua screens (cpp:S5417)

push_object takes a forwarding reference and called std::move on it, which
SonarCloud reports as a blocker bug. It only worked because every caller
passes an rvalue: with an lvalue Type_ is deduced as a reference, and
new Type_(std::move(Object)) doesn't even compile.

The object is now forwarded, and the userdata is sized and built for
std::remove_cvref_t<Type_>, the type collect<> and check_object<> are used
with: an rvalue is moved in, an lvalue would be copied. Every caller passes
an rvalue of lua_image, bitmap_font or glyph, so they move the object in
exactly as before.

* fix(simulation): turbidity from the overcast without branches of the same value (cpp:S3923)

The chain of conditionals setting Global.fTurbidity had pairs of branches
with the same result (<= 0.10 and <= 0.20 both 4, and so on, the last two
both 9), which SonarCloud reports as a bug. The thresholds that changed
nothing are gone and the mapping is a small function: up to 0.20 gives 4,
up to 0.40 5, up to 0.60 6, up to 0.70 7, up to 0.80 8, anything else 9.
The comparisons are the same ones, in the same order, so every overcast
value gives the turbidity it gave before.

* test: script screen tests keep their files in the build folder, not in the temporary one (cpp:S5443)

The folders of the script screen host tests were made in the system's
temporary directory, and the sandbox test put its "outside.txt" straight
into that directory. SonarCloud reports both uses as vulnerabilities:
the directory is writable by everyone.

The folders are now made in the build folder of the unit tests, passed to
them as EU07_UNIT_TESTS_SCRATCH, the way EU07_UNIT_TESTS_DATA is. The
scripts are one level down in the folder of a test, so the file the sandbox
test puts outside the folder of the scripts is still inside the folder of
the test and goes with it. Nothing depends on the working directory, and
nothing is left behind.
2026-11-11 06:04:31 +01:00

271 lines
10 KiB
C++

/*
This Source Code Form is subject to the
terms of the Mozilla Public License, v.
2.0. If a copy of the MPL was not
distributed with this file, You can
obtain one at
http://mozilla.org/MPL/2.0/.
*/
#include "stdafx.h"
#include "simulation/simulationenvironment.h"
#include "simulation/simulationsounds.h"
#include "utilities/Globals.h"
#include "utilities/Timer.h"
namespace simulation {
world_environment Environment;
} // simulation
namespace {
// turbidity of the sky under the given cloud cover
float
turbidity_of( float const Overcast ) {
if( Overcast <= 0.20 ) { return 4.f; }
if( Overcast <= 0.40 ) { return 5.f; }
if( Overcast <= 0.60 ) { return 6.f; }
if( Overcast <= 0.70 ) { return 7.f; }
if( Overcast <= 0.80 ) { return 8.f; }
return 9.f;
}
} // namespace
void
world_environment::on_daylight_change() {
if( Global.FakeLight ) {
// for fake daylight enter fixed hour
time( 10, 30, 0 );
}
else {
// local clock based calculation
time();
}
}
// calculates current season of the year based on set simulation date
void
world_environment::compute_season( int const Yearday ) {
using dayseasonpair = std::pair<int, std::string>;
std::vector<dayseasonpair> seasonsequence {
{ 65, "winter:" },
{ 158, "spring:" },
{ 252, "summer:" },
{ 341, "autumn:" },
{ 366, "winter:" } };
auto const lookup =
std::ranges::lower_bound(
seasonsequence,
std::clamp( Yearday, 1, seasonsequence.back().first ),
{}, &dayseasonpair::first );
Global.Season = lookup->second;
// season can affect the weather so if it changes, re-calculate weather as well
compute_weather();
}
// calculates current weather
void
world_environment::compute_weather() const {
Global.Weather = Global.Overcast <= 0.10 ? "clear:" :
Global.Overcast <= 0.50 ? "scattered:" :
Global.Overcast <= 0.90 ? "broken:" :
Global.Overcast <= 1.00 ? "overcast:" :
Global.AirTemperature > 1 ? "rain:" :
"snow:";
Global.fTurbidity = turbidity_of( Global.Overcast );
}
void
world_environment::init() {
m_sun.init();
m_moon.init();
m_stars.init();
m_clouds.Init();
m_precipitation.init();
{
auto const rainsoundoverride { simulation::Sound_overrides.find( "weather.rainsound:" ) };
m_rainsound.deserialize(
rainsoundoverride != simulation::Sound_overrides.end() ? rainsoundoverride->second : "rain-sound-loop",
sound_type::single );
}
m_wind = basic_wind{
static_cast<float>( Random( 0, 360 ) ),
static_cast<float>( Random( -5, 5 ) ),
static_cast<float>( Random( -2, 4 ) ),
static_cast<float>( Random( -1, 1 ) ),
static_cast<float>( Random( 5, 20 ) ),
{} };
}
void
world_environment::update() {
// move celestial bodies...
m_sun.update();
m_moon.update();
// ...determine source of key light and adjust global state accordingly...
// diffuse (sun) intensity goes down after twilight, and reaches minimum 18 degrees below horizon
float twilightfactor = std::clamp( -m_sun.getAngle(), 0.0f, 18.0f ) / 18.0f;
// NOTE: sun light receives extra padding to prevent moon from kicking in too soon
auto const sunlightlevel = m_sun.getIntensity() + 0.05f * ( 1.f - twilightfactor );
auto const moonlightlevel = m_moon.getIntensity() * 0.65f; // scaled down by arbitrary factor, it's pretty bright otherwise
// ...update skydome to match the current sun position as well...
// twilight factor can be reset later down, so we do it here while it's still reflecting state of the sun
// turbidity varies from 2-3 during the day based on overcast, 3-4 after sunset to deal with sunlight bleeding too much into the sky from below horizon
m_skydome.SetTurbidity(
2.25f
+ std::clamp( Global.Overcast, 0.f, 1.f )
+ std::lerp( 0.f, 1.f, std::clamp( twilightfactor * 1.5f, 0.f, 1.f ) ) );
m_skydome.SetOvercastFactor( Global.Overcast );
m_skydome.Update( m_sun.getDirection() );
float keylightintensity;
glm::vec3 keylightcolor;
Global.SunAngle = m_sun.getAngle();
if (moonlightlevel > sunlightlevel && Global.SunAngle < -20)
{
// rare situations when the moon is brighter than the sun, typically at night
Global.SunAngle = m_moon.getAngle();
Global.DayLight.position = m_moon.getDirection();
Global.DayLight.direction = -1.0f * m_moon.getDirection();
keylightintensity = moonlightlevel;
m_lightintensity = moonlightlevel;
// if the moon is up, it overrides the twilight
twilightfactor = 0.0f;
keylightcolor = glm::vec3( 1.0f, 0.9490196f, 0.7921569f );
}
else {
// regular situation with sun as the key light
Global.SunAngle = m_sun.getAngle();
Global.DayLight.position = m_sun.getDirection();
Global.DayLight.direction = -1.0f * m_sun.getDirection();
keylightintensity = sunlightlevel;
m_lightintensity = 1.0f;
// include 'golden hour' effect in twilight lighting
float const duskfactor = 1.25f - std::clamp( Global.SunAngle, 0.0f, 18.0f ) / 18.0f;
keylightcolor = glm::mix(
glm::vec3( 1.0f, 0.9490196f, 0.9058824f ), // 255, 242, 231 / 255
glm::vec3( 0.9215686f, 0.4705882f, 0.1411765f ), // 235, 120, 36 / 255
duskfactor );
}
// ...retrieve current sky colour and brightness...
auto const skydomecolour = m_skydome.GetAverageColor();
auto const skydomehsv = colors::RGBtoHSV( skydomecolour );
// sun strength is reduced by overcast level
keylightintensity *= 1.0f - std::min(1.f, Global.Overcast) * 0.65f;
// intensity combines intensity of the sun and the light reflected by the sky dome
// it'd be more technically correct to have just the intensity of the sun here,
// but whether it'd _look_ better is something to be tested
auto const intensity = std::min( 1.15f * ( 0.05f + keylightintensity + skydomehsv.z ), 1.25f );
// the impact of sun component is reduced proportionally to overcast level, as overcast increases role of ambient light
auto const diffuselevel = std::lerp( keylightintensity, intensity * ( 1.0f - twilightfactor ), 1.0f - std::min( 1.f, Global.Overcast ) * 0.75f );
// ...update light colours and intensity.
Global.DayLight.diffuse = glm::vec4( keylightcolor * diffuselevel, Global.DayLight.diffuse.a );
Global.DayLight.specular = glm::vec4( keylightcolor * diffuselevel * 0.85f, diffuselevel );
// tonal impact of skydome color is inversely proportional to how high the sun is above the horizon
// (this is pure conjecture, aimed more to 'look right' than be accurate)
float const ambienttone = std::clamp( 1.0f - Global.SunAngle / 90.0f, 0.0f, 1.0f );
float const ambientintensitynightfactor = 1.f - 0.75f * std::clamp( -m_sun.getAngle(), 0.0f, 18.0f ) / 18.0f;
Global.DayLight.ambient[ 0 ] = std::lerp( skydomehsv.z, skydomecolour.r, ambienttone ) * ambientintensitynightfactor;
Global.DayLight.ambient[ 1 ] = std::lerp( skydomehsv.z, skydomecolour.g, ambienttone ) * ambientintensitynightfactor;
Global.DayLight.ambient[ 2 ] = std::lerp( skydomehsv.z, skydomecolour.b, ambienttone ) * ambientintensitynightfactor;
Global.fLuminance = intensity;
// update the fog. setting it to match the average colour of the sky dome is cheap
// but quite effective way to make the distant items blend with background better
Global.FogColor = m_skydome.GetAverageHorizonColor() * keylightcolor *
std::clamp((float)Global.fLuminance, 0.f, 1.f);
// weather-related simulation factors
Global.FrictionWeatherFactor = Global.Weather == "rain:" ? 0.85f : Global.Weather == "snow:" ? 0.75f : 1.0f;
Global.Period = m_sun.getAngle() > -12.0f ? "day:" : "night:";
if( true == (FreeFlyModeFlag || Global.CabWindowOpen)
&& Global.Weather == "rain:" ) {
if( m_rainsound.is_combined() ) {
m_rainsound.pitch( static_cast<float>(Global.Overcast - 1.0) );
}
m_rainsound
.gain( m_rainsound.m_amplitudeoffset + m_rainsound.m_amplitudefactor * 1.f )
.play( sound_flags::exclusive | sound_flags::looping );
}
else {
m_rainsound.stop();
}
update_wind();
}
void
world_environment::update_precipitation() {
m_precipitation.update();
}
void
world_environment::update_moon() {
m_moon.update( true );
}
void
world_environment::update_wind() {
auto const timedelta{ static_cast<float>( Timer::GetDeltaTime() ) };
m_wind.change_time -= timedelta;
if( m_wind.change_time < 0 ) {
m_wind.change_time = static_cast<float>(Random( 5, 15 ));
m_wind.velocity_change = static_cast<float>(Random( -0.2, 0.2 ));
if( Random() < 0.05 ) {
// changes in wind direction should be less frequent than changes in wind speed
// TBD, TODO: configuration-driven direction change frequency
m_wind.azimuth_change = static_cast<float>(Random( -5, 5 ));
}
else {
// keep direction change periods short, to avoid too drastic changes in direction
m_wind.azimuth_change = 0.0;
}
}
// TBD, TODO: wind configuration
m_wind.azimuth = clamp_circular( m_wind.azimuth + m_wind.azimuth_change * timedelta );
// HACK: negative part of range allows for some quiet periods, without active wind
m_wind.velocity = std::clamp( m_wind.velocity + m_wind.velocity_change * timedelta, -2.f, 4.f );
// convert to force vector
auto const polarangle { glm::radians( 90.f ) }; // theta
auto const azimuthalangle{ glm::radians( m_wind.azimuth ) }; // phi
// convert spherical coordinates to opengl coordinates
m_wind.vector =
std::max( 0.f, m_wind.velocity )
* glm::vec3(
std::sin( polarangle ) * std::sin( azimuthalangle ) * -1,
std::cos( polarangle ),
std::sin( polarangle ) * std::cos( azimuthalangle ) );
}
void
world_environment::time( int const Hour, int const Minute, int const Second ) {
m_sun.setTime( Hour, Minute, Second );
}
//---------------------------------------------------------------------------