From b114699ab38d3405481bee3ca9ec8fef4503500b Mon Sep 17 00:00:00 2001 From: Hirek Date: Tue, 7 Jan 2025 03:42:40 +0100 Subject: [PATCH] General lights overhaul Add modern light switcher Available fiz variables with defualt parameters Headlights: LampRed=255 LampGreen=255 LampBlue=255 DimmedMultiplier=0.6 NormalMultiplier=1.0 HighbeamDimmedMultiplier=2.5 HighBeamMultiplier=2.8 Switches: ModernDimmer=No ModernDimmerOffPosition=Yes --- DynObj.cpp | 77 ++++++++++++++++++++++++++++++++++++++++- DynObj.h | 5 +++ McZapkie/MOVER.h | 23 +++++++++++++ McZapkie/Mover.cpp | 26 ++++++++++++++ Train.cpp | 81 ++++++++++++++++++++++++++++++++++++++------ Train.h | 3 ++ command.cpp | 2 ++ command.h | 3 ++ drivermouseinput.cpp | 5 ++- lightarray.cpp | 39 +++++++++++++++++---- translation.cpp | 3 +- 11 files changed, 246 insertions(+), 21 deletions(-) diff --git a/DynObj.cpp b/DynObj.cpp index 1ea3aae1..63f32565 100644 --- a/DynObj.cpp +++ b/DynObj.cpp @@ -1168,6 +1168,28 @@ void TDynamicObject::ABuLittleUpdate(double ObjSqrDist) } btnOn = true; } + + // logika dlugich + if (TestFlag(MoverParameters->iLights[end::front], light::highbeamlight_left)) + m_highbeam13.TurnxOnWithOnAsFallback(); + else + m_highbeam13.TurnOff(); + + if (TestFlag(MoverParameters->iLights[end::front], light::highbeamlight_right)) + m_highbeam12.TurnxOnWithOnAsFallback(); + else + m_highbeam12.TurnOff(); + + // i to samo od dupy strony + if (TestFlag(MoverParameters->iLights[end::rear], light::highbeamlight_left)) + m_highbeam23.TurnxOnWithOnAsFallback(); + else + m_highbeam23.TurnOff(); + + if (TestFlag(MoverParameters->iLights[end::rear], light::highbeamlight_right)) + m_highbeam22.TurnxOnWithOnAsFallback(); + else + m_highbeam22.TurnOff(); } // interior light levels auto sectionlightcolor { glm::vec4( 1.f ) }; @@ -2197,9 +2219,13 @@ TDynamicObject::Init(std::string Name, // nazwa pojazdu, np. "EU07-424" m_headlamp11.Init( "headlamp11", mdModel ); // górne m_headlamp12.Init( "headlamp12", mdModel ); // prawe m_headlamp13.Init( "headlamp13", mdModel ); // lewe + m_highbeam12.Init("highbeam12", mdModel); // prawe dlugie + m_highbeam13.Init("highbeam13", mdModel); // lewe dlugie m_headlamp21.Init( "headlamp21", mdModel ); m_headlamp22.Init( "headlamp22", mdModel ); m_headlamp23.Init( "headlamp23", mdModel ); + m_highbeam22.Init("highbeam22", mdModel); + m_highbeam23.Init("highbeam23", mdModel); m_headsignal12.Init( "headsignal12", mdModel ); m_headsignal13.Init( "headsignal13", mdModel ); m_headsignal22.Init( "headsignal22", mdModel ); @@ -2216,6 +2242,10 @@ TDynamicObject::Init(std::string Name, // nazwa pojazdu, np. "EU07-424" iInventory[ end::front ] |= m_headlamp11.Active() ? light::headlight_upper : 0; iInventory[ end::front ] |= m_headlamp12.Active() ? light::headlight_right : 0; iInventory[ end::front ] |= m_headlamp13.Active() ? light::headlight_left : 0; + + iInventory[end::front] |= m_highbeam12.Active() ? light::highbeamlight_right : 0; + iInventory[end::front] |= m_highbeam13.Active() ? light::highbeamlight_left : 0; + iInventory[ end::rear ] |= m_headlamp21.Active() ? light::headlight_upper : 0; iInventory[ end::rear ] |= m_headlamp22.Active() ? light::headlight_right : 0; iInventory[ end::rear ] |= m_headlamp23.Active() ? light::headlight_left : 0; @@ -2223,6 +2253,11 @@ TDynamicObject::Init(std::string Name, // nazwa pojazdu, np. "EU07-424" iInventory[ end::front ] |= m_headsignal13.Active() ? light::auxiliary_left : 0; iInventory[ end::rear ] |= m_headsignal22.Active() ? light::auxiliary_right : 0; iInventory[ end::rear ] |= m_headsignal23.Active() ? light::auxiliary_left : 0; + + iInventory[end::rear] |= m_highbeam22.Active() ? light::highbeamlight_right : 0; + iInventory[end::rear] |= m_highbeam23.Active() ? light::highbeamlight_left : 0; + + btMechanik1.Init( "mechanik1", mdLowPolyInt, false); btMechanik2.Init( "mechanik2", mdLowPolyInt, false); if( MoverParameters->dizel_heat.water.config.shutters ) { @@ -4162,6 +4197,10 @@ void TDynamicObject::TurnOff() m_headlamp21.TurnOff(); m_headlamp22.TurnOff(); m_headlamp23.TurnOff(); + m_highbeam12.TurnOff(); + m_highbeam13.TurnOff(); + m_highbeam22.TurnOff(); + m_highbeam23.TurnOff(); m_headsignal12.TurnOff(); m_headsignal13.TurnOff(); m_headsignal22.TurnOff(); @@ -7000,7 +7039,6 @@ void TDynamicObject::Damage(char flag) }; void TDynamicObject::SetLights() { - auto const isfrontcaboccupied { MoverParameters->CabOccupied * DirectionGet() >= 0 }; int const automaticmarkers { MoverParameters->CabActive == 0 && ( MoverParameters->InactiveCabFlag & activation::redmarkers ) ? light::redmarker_left + light::redmarker_right : 0 }; @@ -7054,6 +7092,43 @@ void TDynamicObject::RaLightsSet(int head, int rear) if( head >= 0 ) { auto const vehicleend { iDirection > 0 ? end::front : end::rear }; MoverParameters->iLights[ vehicleend ] = ( head & iInventory[ vehicleend ] ); + bool tLeft = MoverParameters->iLights[vehicleend] & (light::auxiliary_left | light::headlight_left); // roboczo czy jakiekolwiek swiatlo z lewej jest zapalone + bool tRight = MoverParameters->iLights[vehicleend] & (light::auxiliary_right | light::headlight_right); // a tu z prawej + switch (MoverParameters->modernDimmerState) + { + case 0: + // wylaczone + MoverParameters->iLights[vehicleend] &= 0 | light::rearendsignals; // zostawiamy tylko tabliczki jesli sa + HighBeamLights = false; + DimHeadlights = false; + break; + case 1: + // przyciemnione normalne + DimHeadlights = true; // odpalamy przyciemnienie normalnych reflektorow + HighBeamLights = false; + break; + case 3: + // dlugie przyciemnione + DimHeadlights = true; + HighBeamLights = true; + MoverParameters->iLights[vehicleend] &= light::headlight_upper | light::rearendsignals | light::redmarker_left | light::redmarker_right | light::rearendsignals; // nie ruszamy gornych i koncowek + MoverParameters->iLights[vehicleend] |= tLeft ? light::highbeamlight_left : 0; // jesli swiatlo z lewej zapalone to odpal dlugie + MoverParameters->iLights[vehicleend] |= tRight ? light::highbeamlight_right : 0; // a tu z prawej + break; + case 4: + // zwykle dlugie + DimHeadlights = false; + HighBeamLights = true; + MoverParameters->iLights[vehicleend] &= light::headlight_upper | light::rearendsignals | light::redmarker_left | light::redmarker_right | light::rearendsignals; // nie ruszamy gornych i koncowek + MoverParameters->iLights[vehicleend] |= tLeft ? light::highbeamlight_left : 0; // jesli swiatlo z lewej zapalone to odpal dlugie + MoverParameters->iLights[vehicleend] |= tRight ? light::highbeamlight_right : 0; // a tu z prawej + break; + default: // to case 2 - zwykle + DimHeadlights = false; + HighBeamLights = false; + break; + } + } if( rear >= 0 ) { auto const vehicleend{ iDirection > 0 ? end::rear : end::front }; diff --git a/DynObj.h b/DynObj.h index 807e09df..60d7de10 100644 --- a/DynObj.h +++ b/DynObj.h @@ -469,9 +469,13 @@ private: AirCoupler m_headlamp11; // oswietlenie czolowe - przod AirCoupler m_headlamp12; AirCoupler m_headlamp13; + AirCoupler m_highbeam12; // dlugie + AirCoupler m_highbeam13; AirCoupler m_headlamp21; // oswietlenie czolowe - tyl AirCoupler m_headlamp22; AirCoupler m_headlamp23; + AirCoupler m_highbeam22; + AirCoupler m_highbeam23; AirCoupler m_headsignal12; AirCoupler m_headsignal13; AirCoupler m_headsignal22; @@ -571,6 +575,7 @@ private: public: bool DimHeadlights{ false }; // status of the headlight dimming toggle. NOTE: single toggle for all lights is a simplification. TODO: separate per-light switches + bool HighBeamLights { false }; // status of the highbeam toggle // checks whether there's unbroken connection of specified type to specified vehicle bool is_connected( TDynamicObject const *Vehicle, coupling const Coupling = coupling::coupler ) const; TDynamicObject * PrevAny() const; diff --git a/McZapkie/MOVER.h b/McZapkie/MOVER.h index c23f16f5..812550c6 100644 --- a/McZapkie/MOVER.h +++ b/McZapkie/MOVER.h @@ -205,6 +205,8 @@ enum light { rearendsignals = ( 1 << 6 ), auxiliary_left = ( 1 << 7 ), auxiliary_right = ( 1 << 8 ), + highbeamlight_left = ( 1 << 9 ), + highbeamlight_right = ( 1 << 10 ) }; // door operation methods; exclusive @@ -1705,6 +1707,26 @@ public: int iProblem = 0; // flagi problemów z taborem, aby AI nie musiało porównywać; 0=może jechać int iLights[2]; // bity zapalonych świateł tutaj, żeby dało się liczyć pobór prądu + // Status nowszego hebelka od przyciemniania swiatel/swiatel dlugich + // 0 - swiatla wylaczone (opcja dziala tylko gdy w fiz zdefiniowano OffState w sekcji Switches; w przeciwnym wypadku pstryk startuje z wartoscia == 1 + // 1 - swiatla normalne przyciemnione + // 2 - swiatla normalne + // 3 - swiatla dlugie przyciemnione + // 4 - swiatla dlugie normalne + int modernDimmerState{0}; + bool modernContainOffPos = true; + bool enableModernDimmer = false; + + // Barwa reflektora + int refR{255}; // Czerwony + int refG{255}; // Zielony + int refB{255}; // Niebieski + + double dimMultiplier{0.6f}; // mnoznik swiatel przyciemnionych + double normMultiplier{1.0f}; // mnoznik swiatel zwyklych + double highDimMultiplier{2.5f}; // mnoznik dlugich przyciemnionych + double highMultiplier{2.8f}; // mnoznik dlugich + plc::basic_controller m_plc; int AIHintPantstate{ 0 }; // suggested pantograph setup @@ -1969,6 +1991,7 @@ private: void LoadFIZ_DCEMUED(std::string const &line); void LoadFIZ_SpringBrake(std::string const &line); void LoadFIZ_Light( std::string const &line ); + void LoadFIZ_Headlights(std::string const &Line); void LoadFIZ_Clima( std::string const &line ); void LoadFIZ_Power( std::string const &Line ); void LoadFIZ_SpeedControl( std::string const &Line ); diff --git a/McZapkie/Mover.cpp b/McZapkie/Mover.cpp index 53c535cb..1cc076ec 100644 --- a/McZapkie/Mover.cpp +++ b/McZapkie/Mover.cpp @@ -9666,6 +9666,14 @@ bool TMoverParameters::LoadFIZ(std::string chkpath) continue; } + if (issection("Headlights:", inputline)) + { + startBPT = false; + fizlines.emplace("Headlights", inputline); + LoadFIZ_Headlights(inputline); + continue; + } + if (issection("Blending:", inputline)) { startBPT = false; LISTLINE = 0; @@ -10026,6 +10034,18 @@ void TMoverParameters::LoadFIZ_Load( std::string const &line ) { extract_value( UnLoadSpeed, "UnLoadSpeed", line, "" ); } +void TMoverParameters::LoadFIZ_Headlights(std::string const &line) +{ + extract_value(refR, "LampRed", line, ""); + extract_value(refG, "LampGreen", line, ""); + extract_value(refB, "LampBlue", line, ""); + + extract_value(dimMultiplier, "DimmedMultiplier", line, ""); + extract_value(normMultiplier, "NormalMultiplier", line, ""); + extract_value(highDimMultiplier, "HighbeamDimmedMultiplier", line, ""); + extract_value(highMultiplier, "HighBeamMultiplier", line, ""); +} + void TMoverParameters::LoadFIZ_Dimensions( std::string const &line ) { extract_value( Dim.L, "L", line, "" ); @@ -11120,6 +11140,12 @@ void TMoverParameters::LoadFIZ_Switches( std::string const &Input ) { extract_value( UniversalResetButtonFlag[ 0 ], "RelayResetButton1", Input, "" ); extract_value( UniversalResetButtonFlag[ 1 ], "RelayResetButton2", Input, "" ); extract_value( UniversalResetButtonFlag[ 2 ], "RelayResetButton3", Input, "" ); + extract_value(enableModernDimmer, "ModernDimmer", Input, ""); + extract_value(modernContainOffPos, "ModernDimmerOffPosition", Input, ""); + if (!modernContainOffPos) + modernDimmerState = 1; + if (!enableModernDimmer) + modernDimmerState = 2; // pantograph presets { auto &presets { PantsPreset.first }; diff --git a/Train.cpp b/Train.cpp index ff22d4c2..796fe1c5 100644 --- a/Train.cpp +++ b/Train.cpp @@ -375,6 +375,8 @@ TTrain::commandhandler_map const TTrain::m_commandhandlers = { { user_command::headlighttogglerearupper, &TTrain::OnCommand_headlighttogglerearupper }, { user_command::headlightenablerearupper, &TTrain::OnCommand_headlightenablerearupper }, { user_command::headlightdisablerearupper, &TTrain::OnCommand_headlightdisablerearupper }, + {user_command::modernlightdimmerdecrease, &TTrain::OnCommand_modernlightdimmerdecrease}, + {user_command::modernlightdimmerincrease, &TTrain::OnCommand_modernlightdimmerincrease}, { user_command::redmarkertogglerearleft, &TTrain::OnCommand_redmarkertogglerearleft }, { user_command::redmarkerenablerearleft, &TTrain::OnCommand_redmarkerenablerearleft }, { user_command::redmarkerdisablerearleft, &TTrain::OnCommand_redmarkerdisablerearleft }, @@ -4669,6 +4671,44 @@ void TTrain::OnCommand_headlightdisablerearupper( TTrain *Train, command_data co } } +void TTrain::OnCommand_modernlightdimmerincrease(TTrain* Train, command_data const& Command) +{ + if (!Train->mvOccupied->enableModernDimmer) + return; // if modern dimmer is disabled, skip entire command + if (Command.action == GLFW_PRESS) + { + // update modern dimmer state + if (Train->mvOccupied->modernDimmerState < 4) + Train->mvOccupied->modernDimmerState++; + Train->Dynamic()->SetLights(); + // visual feedback + if (Train->ggModernLightDimSw.SubModel != nullptr) + if (Train->mvOccupied->modernContainOffPos) + Train->ggModernLightDimSw.UpdateValue(Train->mvOccupied->modernDimmerState, Train->dsbSwitch); + else + Train->ggModernLightDimSw.UpdateValue(Train->mvOccupied->modernDimmerState - 1, Train->dsbSwitch); + } +} +void TTrain::OnCommand_modernlightdimmerdecrease(TTrain *Train, command_data const &Command) +{ + if (!Train->mvOccupied->enableModernDimmer) + return; // if modern dimmer is disabled, skip entire command + if (Command.action == GLFW_PRESS) + { + byte minPos = (Train->mvOccupied->modernContainOffPos) ? 0 : 1; // prevent switching to 0 if its not enabled + // update modern dimmer state + if (Train->mvOccupied->modernDimmerState > minPos) + Train->mvOccupied->modernDimmerState--; + Train->Dynamic()->SetLights(); + // visual feedback + if (Train->ggModernLightDimSw.SubModel != nullptr) + if (Train->mvOccupied->modernContainOffPos) + Train->ggModernLightDimSw.UpdateValue(Train->mvOccupied->modernDimmerState, Train->dsbSwitch); + else + Train->ggModernLightDimSw.UpdateValue(Train->mvOccupied->modernDimmerState - 1, Train->dsbSwitch); + } +} + void TTrain::OnCommand_redmarkertogglerearleft( TTrain *Train, command_data const &Command ) { if( Command.action == GLFW_PRESS ) { // NOTE: we toggle the light on opposite side, as 'rear right' is 'front left' on the rear end etc @@ -4866,17 +4906,22 @@ void TTrain::OnCommand_headlightsdimenable( TTrain *Train, command_data const &C if( Command.action == GLFW_PRESS ) { // only reacting to press, so the switch doesn't flip back and forth if key is held down - if( Train->ggDimHeadlightsButton.SubModel == nullptr ) { + if( Train->ggDimHeadlightsButton.SubModel != nullptr ) { // TODO: proper control deviced definition for the interiors, that doesn't hinge of presence of 3d submodels - WriteLog( "Dim Headlights switch is missing, or wasn't defined" ); - return; + // visual feedback + Train->ggDimHeadlightsButton.UpdateValue(1.0, Train->dsbSwitch); } - // visual feedback - Train->ggDimHeadlightsButton.UpdateValue( 1.0, Train->dsbSwitch ); - if( true == Train->DynamicObject->DimHeadlights ) { return; } // already enabled + /* // to jest stara logika + if (true == Train->DynamicObject->DimHeadlights) + { + return; + } // already enabled Train->DynamicObject->DimHeadlights = true; + */ + + Train->mvOccupied->modernDimmerState = 1; // ustawiamy modern dimmer na flage przyciemnienia } } @@ -4884,17 +4929,20 @@ void TTrain::OnCommand_headlightsdimdisable( TTrain *Train, command_data const & if( Command.action == GLFW_PRESS ) { // only reacting to press, so the switch doesn't flip back and forth if key is held down - if( Train->ggDimHeadlightsButton.SubModel == nullptr ) { + if( Train->ggDimHeadlightsButton.SubModel != nullptr ) { // TODO: proper control deviced definition for the interiors, that doesn't hinge of presence of 3d submodels - WriteLog( "Dim Headlights switch is missing, or wasn't defined" ); - return; + // visual feedback + Train->ggDimHeadlightsButton.UpdateValue(0.0, Train->dsbSwitch); } - // visual feedback - Train->ggDimHeadlightsButton.UpdateValue( 0.0, Train->dsbSwitch ); + + /* // stara logika przyciemniania if( false == Train->DynamicObject->DimHeadlights ) { return; } // already enabled Train->DynamicObject->DimHeadlights = false; + + */ + Train->mvOccupied->modernDimmerState = 2; // ustawiamy modern dimmer na flage rozjasnienia } } @@ -7995,6 +8043,7 @@ bool TTrain::Update( double const Deltatime ) ggRightLightButton.Update(); ggLeftEndLightButton.Update(); ggRightEndLightButton.Update(); + ggModernLightDimSw.Update(); // hunter-230112 ggRearUpperLightButton.Update(); ggRearLeftLightButton.Update(); @@ -8002,6 +8051,7 @@ bool TTrain::Update( double const Deltatime ) ggRearLeftEndLightButton.Update(); ggRearRightEndLightButton.Update(); ggDimHeadlightsButton.Update(); + ggDimHeadlightsButton.Update(); //------------ ggConverterButton.Update(); ggConverterLocalButton.Update(); @@ -9580,6 +9630,7 @@ void TTrain::clear_cab_controls() ggRightLightButton.Clear(); ggUpperLightButton.Clear(); ggDimHeadlightsButton.Clear(); + ggModernLightDimSw.Clear(); ggLeftEndLightButton.Clear(); ggRightEndLightButton.Clear(); ggLightsButton.Clear(); @@ -9611,6 +9662,13 @@ void TTrain::set_cab_controls( int const Cab ) { m_linebreakerstate > 0 ? 1.f : 0.f ) ); } + + if (ggModernLightDimSw.SubModel != nullptr) { + ggModernLightDimSw.PutValue( + mvOccupied->modernDimmerState + ); + } + // motor connectors ggStLinOffButton.PutValue( ( mvControlled->StLinSwitchOff ? @@ -10172,6 +10230,7 @@ bool TTrain::initialize_gauge(cParser &Parser, std::string const &Label, int con { "leftend_sw:", ggLeftEndLightButton }, { "rightend_sw:", ggRightEndLightButton }, { "lights_sw:", ggLightsButton }, + { "moderndimmer_sw:", ggModernLightDimSw }, { "rearupperlight_sw:", ggRearUpperLightButton }, { "rearleftlight_sw:", ggRearLeftLightButton }, { "rearrightlight_sw:", ggRearRightLightButton }, diff --git a/Train.h b/Train.h index ce0467c5..5346e648 100644 --- a/Train.h +++ b/Train.h @@ -399,6 +399,8 @@ class TTrain { static void OnCommand_headlighttogglerearupper( TTrain *Train, command_data const &Command ); static void OnCommand_headlightenablerearupper( TTrain *Train, command_data const &Command ); static void OnCommand_headlightdisablerearupper( TTrain *Train, command_data const &Command ); + static void OnCommand_modernlightdimmerincrease(TTrain *Train, command_data const &Command); + static void OnCommand_modernlightdimmerdecrease(TTrain *Train, command_data const &Command); static void OnCommand_redmarkertogglerearleft( TTrain *Train, command_data const &Command ); static void OnCommand_redmarkerenablerearleft( TTrain *Train, command_data const &Command ); static void OnCommand_redmarkerdisablerearleft( TTrain *Train, command_data const &Command ); @@ -578,6 +580,7 @@ public: // reszta może by?publiczna TGauge ggRightEndLightButton; TGauge ggLightsButton; // przelacznik reflektorow (wszystkich) TGauge ggDimHeadlightsButton; // headlights dimming switch + TGauge ggModernLightDimSw; // modern lights dimmer // hunter-230112: przelacznik swiatel tylnich TGauge ggRearUpperLightButton; diff --git a/command.cpp b/command.cpp index cef9f524..9f9d99da 100644 --- a/command.cpp +++ b/command.cpp @@ -151,6 +151,8 @@ commanddescription_sequence Commands_descriptions = { { "radiovolumeset", command_target::vehicle, command_mode::oneoff }, { "cabchangeforward", command_target::vehicle, command_mode::oneoff }, { "cabchangebackward", command_target::vehicle, command_mode::oneoff }, + {"modernlightdimmerdecrease", command_target::vehicle, command_mode::oneoff}, + {"modernlightdimmerincrease", command_target::vehicle, command_mode::oneoff}, { "viewturn", command_target::entity, command_mode::oneoff }, { "movehorizontal", command_target::entity, command_mode::oneoff }, { "movehorizontalfast", command_target::entity, command_mode::oneoff }, diff --git a/command.h b/command.h index 47ae1b31..44bb24fe 100644 --- a/command.h +++ b/command.h @@ -145,6 +145,9 @@ enum class user_command { cabchangeforward, cabchangebackward, + modernlightdimmerdecrease, + modernlightdimmerincrease, + viewturn, movehorizontal, movehorizontalfast, diff --git a/drivermouseinput.cpp b/drivermouseinput.cpp index 78529a23..4d6ae28d 100644 --- a/drivermouseinput.cpp +++ b/drivermouseinput.cpp @@ -506,7 +506,7 @@ drivermouse_input::bindings( std::string const &Control ) const { void drivermouse_input::default_bindings() { - + // pierwsza komenda jest od zwiekszania a druga od zmniejszania - ewentualnie kolejno lewy i prawy przycisk m_buttonbindings = { { "jointctrl:", { user_command::jointcontrollerset, @@ -731,6 +731,9 @@ drivermouse_input::default_bindings() { { "dimheadlights_sw:", { user_command::headlightsdimtoggle, user_command::none } }, + {"moderndimmer_sw:", { + user_command::modernlightdimmerincrease, + user_command::modernlightdimmerdecrease } }, { "leftend_sw:", { user_command::redmarkertoggleleft, user_command::none } }, diff --git a/lightarray.cpp b/lightarray.cpp index e262eb34..77dd3ccd 100644 --- a/lightarray.cpp +++ b/lightarray.cpp @@ -65,17 +65,42 @@ light_array::update() { light.count = 0 + ( ( lights & light::headlight_left ) ? 1 : 0 ) + ( ( lights & light::headlight_right ) ? 1 : 0 ) - + ( ( lights & light::headlight_upper ) ? 1 : 0 ); + + ( ( lights & light::headlight_upper ) ? 1 : 0 ) + + ( ( lights & light::highbeamlight_left ) ? 1: 0) + + ( ( lights & light::highbeamlight_right ) ? 1 : 0); if( light.count > 0 ) { - light.intensity = std::max( 0.0f, std::log( (float)light.count + 1.0f ) ); - light.intensity *= ( light.owner->DimHeadlights ? 0.6f : 1.0f ); + light.intensity = std::max(0.0f, std::log((float)light.count + 1.0f)); + if (light.owner->DimHeadlights && !light.owner->HighBeamLights) // tylko przyciemnione + light.intensity *= light.owner->MoverParameters->dimMultiplier; + else if (!light.owner->DimHeadlights && !light.owner->HighBeamLights) // normalne + light.intensity *= light.owner->MoverParameters->normMultiplier; + else if (light.owner->DimHeadlights && light.owner->HighBeamLights) // przyciemnione dlugie + light.intensity *= light.owner->MoverParameters->highDimMultiplier; + else if (!light.owner->DimHeadlights && light.owner->HighBeamLights) // dlugie zwykle + light.intensity *= light.owner->MoverParameters->highMultiplier; + // TBD, TODO: intensity can be affected further by other factors light.state = { - ( ( lights & light::headlight_left ) ? 1.f : 0.f ), - ( ( lights & light::headlight_upper ) ? 1.f : 0.f ), - ( ( lights & light::headlight_right ) ? 1.f : 0.f ) }; - light.state *= ( light.owner->DimHeadlights ? 0.6f : 1.0f ); + ( ( lights & light::headlight_left | light::highbeamlight_left ) ? 1.f : 0.f ), + ( ( lights & light::headlight_upper ) ? 1.f : 0.f ), + ( ( lights & light::headlight_right | light::highbeamlight_right) ? 1.f : 0.f ) }; + + light.color = { + light.owner->MoverParameters->refR / 255, + light.owner->MoverParameters->refG / 255, + light.owner->MoverParameters->refB / 255 + }; + + if (light.owner->DimHeadlights && !light.owner->HighBeamLights) // tylko przyciemnione + light.state *= light.owner->MoverParameters->dimMultiplier; + else if (!light.owner->DimHeadlights && !light.owner->HighBeamLights) + light.state *= light.owner->MoverParameters->normMultiplier; + else if (light.owner->DimHeadlights && light.owner->HighBeamLights) // przyciemnione dlugie + light.state *= light.owner->MoverParameters->highDimMultiplier; + else if (!light.owner->DimHeadlights && light.owner->HighBeamLights) // dlugie zwykle + light.state *= light.owner->MoverParameters->highMultiplier; + } else { light.intensity = 0.0f; diff --git a/translation.cpp b/translation.cpp index ac31091c..74a4e35a 100644 --- a/translation.cpp +++ b/translation.cpp @@ -249,6 +249,7 @@ std::string locale::label_cab_control(std::string const &Label) { "leftlight_sw:", STRN("left headlight") }, { "rightlight_sw:", STRN("right headlight") }, { "dimheadlights_sw:", STRN("headlights dimmer") }, + { "moderndimmer_sw:", STRN("headlights dimmer") }, { "leftend_sw:", STRN("left marker light") }, { "rightend_sw:", STRN("right marker light") }, { "lights_sw:", STRN("light pattern") }, @@ -319,7 +320,7 @@ std::string locale::label_cab_control(std::string const &Label) { "universal6:", STRN("interactive part") }, { "universal7:", STRN("interactive part") }, { "universal8:", STRN("interactive part") }, - { "universal9:", STRN("interactive part") } + { "universal9:", STRN("interactive part") }, }; auto const it = cabcontrols_labels.find( Label );