Merge branch 'tmj-dev' into nogfx

AnimModel.cpp

@@ -205,8 +205,9 @@ void TAnimContainer::AnimSetVMD(double fNewSpeed)
     // "+AnsiString(pMovementData->f3Vector.y)+" "+AnsiString(pMovementData->f3Vector.z));
 }
 
-void TAnimContainer::UpdateModel()
+// przeliczanie animacji wykonać tylko raz na model
-{ // przeliczanie animacji wykonać tylko raz na model
+void TAnimContainer::UpdateModel() {
+
     if (pSubModel) // pozbyć się tego - sprawdzać wcześniej
     {
         if (fTranslateSpeed != 0.0)
@@ -236,7 +237,7 @@ void TAnimContainer::UpdateModel()
                 // zakończeniu
             }
         }
-        if (fRotateSpeed != 0)
+        if (fRotateSpeed != 0.0)
         {
 
             /*
@@ -303,8 +304,9 @@ void TAnimContainer::UpdateModel()
                 // zakończeniu
             }
         }
-        if (fAngleSpeed != 0.0)
+        if( fAngleSpeed != 0.f ) {
-        { // obrót kwaternionu (interpolacja)
+            // NOTE: this is angle- not quaternion-based rotation TBD, TODO: switch to quaternion rotations?
+            fAngleCurrent += fAngleSpeed * Timer::GetDeltaTime(); // aktualny parametr interpolacji
         }
     }
 };
@@ -322,15 +324,14 @@ void TAnimContainer::PrepareModel()
         {
             if (fAngleSpeed > 0.0f)
             {
-                fAngleCurrent +=
-                    fAngleSpeed * Timer::GetDeltaTime(); // aktualny parametr interpolacji
                 if (fAngleCurrent >= 1.0f)
                 { // interpolacja zakończona, ustawienie na pozycję końcową
                     qCurrent = qDesired;
                     fAngleSpeed = 0.0; // wyłączenie przeliczania wektora
-                    if (evDone)
+                    if( evDone ) {
-                        Global::AddToQuery(evDone,
+                        // wykonanie eventu informującego o zakończeniu
-                                           NULL); // wykonanie eventu informującego o zakończeniu
+                        Global::AddToQuery( evDone, NULL );
+                    }
                 }
                 else
                 { // obliczanie pozycji pośredniej
@@ -412,9 +413,9 @@ TAnimModel::TAnimModel()
     iNumLights = 0;
     fBlinkTimer = 0;
 
-    for (int i = 0; i < iMaxNumLights; i++)
+    for (int i = 0; i < iMaxNumLights; ++i)
     {
-        LightsOn[i] = LightsOff[i] = NULL; // normalnie nie ma
+        LightsOn[i] = LightsOff[i] = nullptr; // normalnie nie ma
         lsLights[i] = ls_Off; // a jeśli są, to wyłączone
     }
     vAngle.x = vAngle.y = vAngle.z = 0.0; // zerowanie obrotów egzemplarza
@@ -550,8 +551,15 @@ TAnimContainer * TAnimModel::GetContainer(char *pName)
     return AddContainer(pName);
 }
 
-void TAnimModel::RaAnimate()
+// przeliczenie animacji - jednorazowo na klatkę
-{ // przeliczenie animacji - jednorazowo na klatkę
+void TAnimModel::RaAnimate( unsigned int const Framestamp ) {
+    
+    if( Framestamp == m_framestamp ) { return; }
+
+    fBlinkTimer -= Timer::GetDeltaTime();
+    if( fBlinkTimer <= 0 )
+        fBlinkTimer += fOffTime;
+
     // Ra 2F1I: to by można pomijać dla modeli bez animacji, których jest większość
     TAnimContainer *pCurrent;
     for (pCurrent = pRoot; pCurrent != NULL; pCurrent = pCurrent->pNext)
@@ -560,15 +568,14 @@ void TAnimModel::RaAnimate()
     // if () //tylko dla modeli z IK !!!!
     for (pCurrent = pRoot; pCurrent != NULL; pCurrent = pCurrent->pNext) // albo osobny łańcuch
         pCurrent->UpdateModelIK(); // przeliczenie odwrotnej kinematyki
+
+    m_framestamp = Framestamp;
 };
 
 void TAnimModel::RaPrepare()
 { // ustawia światła i animacje we wzorcu modelu przed renderowaniem egzemplarza
-    fBlinkTimer -= Timer::GetDeltaTime();
-    if (fBlinkTimer <= 0)
-        fBlinkTimer = fOffTime;
     bool state; // stan światła
-    for (int i = 0; i < iNumLights; i++)
+    for (int i = 0; i < iNumLights; ++i)
     {
         switch (lsLights[i])
         {

AnimModel.h

@@ -149,8 +149,9 @@ class TAnimModel {
     TLightState lsLights[iMaxNumLights];
     float fDark; // poziom zapalanie światła (powinno być chyba powiązane z danym światłem?)
     float fOnTime, fOffTime; // były stałymi, teraz mogą być zmienne dla każdego egzemplarza
+    unsigned int m_framestamp { 0 }; // id of last rendered gfx frame
 private:
-    void RaAnimate(); // przeliczenie animacji egzemplarza
+    void RaAnimate( unsigned int const Framestamp ); // przeliczenie animacji egzemplarza
     void RaPrepare(); // ustawienie animacji egzemplarza na wzorcu
   public:
     static TAnimContainer *acAnimList; // lista animacji z eventem, które muszą być przeliczane również bez wyświetlania

Driver.cpp

@@ -1250,10 +1250,11 @@ TCommandType TController::TableUpdate(double &fVelDes, double &fDist, double &fN
                     else {
                         // przyspieszenie: ujemne, gdy trzeba hamować
                         a = ( v * v - mvOccupied->Vel * mvOccupied->Vel ) / ( 25.92 * d );
-                        if( fBrakeDist > 0.0 ) {
+                        auto const brakingdistance = fBrakeDist * braking_distance_multiplier( v );
+                        if( brakingdistance > 0.0 ) {
                             // maintain desired acc while we have enough room to brake safely, when close enough start paying attention
                             // try to make a smooth transition instead of sharp change
-                            a = interpolate( a, fAcc, clamp( ( d - fBrakeDist ) / fBrakeDist, 0.0, 1.0 ) );
+                            a = interpolate( a, AccPreferred, clamp( ( d - brakingdistance ) / brakingdistance, 0.0, 1.0 ) );
                         }
                         if( ( d < fMinProximityDist )
                          && ( v < fVelDes ) ) {
@@ -1318,6 +1319,16 @@ TCommandType TController::TableUpdate(double &fVelDes, double &fDist, double &fN
     return go;
 };
 
+// modifies brake distance for low target speeds, to ease braking rate in such situations
+float
+TController::braking_distance_multiplier( float const Targetvelocity ) {
+
+    if( Targetvelocity > 65.f ) { return 1.f; }
+    if( Targetvelocity <  5.f ) { return 1.f; }
+    // stretch the braking distance up to 3 times; the lower the speed, the greater the stretch
+    return interpolate( 3.f, 1.f, ( Targetvelocity - 5.f ) / 60.f );
+}
+
 void TController::TablePurger()
 { // odtykacz: usuwa mniej istotne pozycje ze środka tabelki, aby uniknąć zatkania
     //(np. brak ograniczenia pomiędzy zwrotnicami, usunięte sygnały, minięte odcinki łuku)
@@ -2002,10 +2013,11 @@ void TController::SetVelocity(double NewVel, double NewVelNext, TStopReason r)
 
 double TController::BrakeAccFactor()
 {
-//	double Factor = 1 + fBrakeReaction*mvOccupied->Vel / (std::max(0.0, ActualProximityDist) + 1);
+	double Factor = 1.0;
-	double Factor = 1;
+    if( ( ActualProximityDist > fMinProximityDist )
-	if((ActualProximityDist>fMinProximityDist)||(mvOccupied->Vel<VelDesired+fVelPlus))
+     || ( mvOccupied->Vel > VelDesired + fVelPlus ) ) {
         Factor += ( fBrakeReaction * ( mvOccupied->BrakeCtrlPosR < 0.5 ? 1.5 : 1 ) ) * mvOccupied->Vel / ( std::max( 0.0, ActualProximityDist ) + 1 ) * ( ( AccDesired - AbsAccS_pub ) / fAccThreshold );
+    }
 	return Factor;
 }
 
@@ -2379,8 +2391,12 @@ bool TController::IncBrake()
 
                     if( deltaAcc > fBrake_a1[0])
 					{
-						if (mvOccupied->BrakeCtrlPosR<0.1)
+                        if( mvOccupied->BrakeCtrlPosR < 0.1 ) {
-	                        OK = mvOccupied->BrakeLevelAdd(1.0);
+                            OK = mvOccupied->BrakeLevelAdd( (
+                                mvOccupied->BrakeDelayFlag > bdelay_G ?
+                                    1.0 :
+                                    1.25 ) );
+                        }
 						else
 						{
 							OK = mvOccupied->BrakeLevelAdd(0.25);
@@ -3617,11 +3633,11 @@ bool TController::UpdateSituation(double dt)
             }
             // basic emergency stop handling, while at it
             if( ( true == mvOccupied->EmergencyBrakeFlag ) // radio-stop
-             && ( mvOccupied->Vel < 0.01 ) // and actual stop
+             && ( mvOccupied->Vel == 0.0 ) // and actual stop
              && ( true == mvOccupied->Radio ) ) { // and we didn't touch the radio yet
                 // turning off the radio should reset the flag, during security system check
-                if( m_radiocontroltime > 2.5 ) {
+                if( m_radiocontroltime > 5.0 ) {
-                    // arbitrary 2.5 sec delay between stop and disabling the radio
+                    // arbitrary delay between stop and disabling the radio
                     mvOccupied->Radio = false;
                     m_radiocontroltime = 0.0;
                 }
@@ -3632,7 +3648,7 @@ bool TController::UpdateSituation(double dt)
             if( ( false == mvOccupied->Radio )
              && ( false == mvOccupied->EmergencyBrakeFlag ) ) {
                 // otherwise if it's safe to do so, turn the radio back on
-                if( m_radiocontroltime > 5.0 ) {
+                if( m_radiocontroltime > 10.0 ) {
                     // arbitrary 5 sec delay before switching radio back on
                     mvOccupied->Radio = true;
                     m_radiocontroltime = 0.0;
@@ -3863,7 +3879,8 @@ bool TController::UpdateSituation(double dt)
                     // margines prędkości powodujący załączenie napędu; min 1.0 żeby nie ruszał przy 0.1
                     fVelMinus = clamp( std::round( 0.05 * VelDesired ), 1.0, 5.0 );
                     // normalnie dopuszczalne przekroczenie to 5% prędkości ale nie więcej niż 5km/h
-                    fVelPlus = std::min( 5.0, std::ceil( 0.05 * VelDesired ) );
+                    // bottom margin raised to 2 km/h to give the AI more leeway at low speed limits
+                    fVelPlus = clamp( std::ceil( 0.05 * VelDesired ), 2.0, 5.0 );
                 }
             }
             else {
@@ -4062,17 +4079,13 @@ bool TController::UpdateSituation(double dt)
                 switch (comm)
                 { // ustawienie VelSignal - trochę proteza = do przemyślenia
                 case cm_Ready: // W4 zezwolił na jazdę
-                    TableCheck(
+                    // ewentualne doskanowanie trasy za W4, który zezwolił na jazdę
-                        scanmax); // ewentualne doskanowanie trasy za W4, który zezwolił na jazdę
+                    TableCheck( scanmax);
-                    TableUpdate(VelDesired, ActualProximityDist, VelNext,
+                    TableUpdate(VelDesired, ActualProximityDist, VelNext, AccDesired); // aktualizacja po skanowaniu
-                                AccDesired); // aktualizacja po skanowaniu
-                    // if (comm!=cm_SetVelocity) //jeśli dalej jest kolejny W4, to ma zwrócić
-                    // cm_SetVelocity
                     if (VelNext == 0.0)
                         break; // ale jak coś z przodu zamyka, to ma stać
                     if (iDrivigFlags & moveStopCloser)
-                        VelSignal = -1.0; // niech jedzie, jak W4 puściło - nie, ma czekać na
+                        VelSignal = -1.0; // ma czekać na sygnał z sygnalizatora!
-                // sygnał z sygnalizatora!
                 case cm_SetVelocity: // od wersji 357 semafor nie budzi wyłączonej lokomotywy
                     if (!(OrderList[OrderPos] &
                           ~(Obey_train | Shunt))) // jedzie w dowolnym trybie albo Wait_for_orders
@@ -4334,24 +4347,24 @@ bool TController::UpdateSituation(double dt)
                     // gdy zbliża się i jest za szybki do nowej prędkości, albo stoi na zatrzymaniu
                     if (vel > 0.0) {
                         // jeśli jedzie
-                        if ((vel < VelNext) ?
+                        if( ( vel < VelNext )
-                                (ActualProximityDist > fMaxProximityDist * (1 + 0.1 * vel)) :
+                         && ( ActualProximityDist > fMaxProximityDist * ( 1.0 + 0.1 * vel ) ) ) {
-                                false) // dojedz do semafora/przeszkody
+                            // dojedz do semafora/przeszkody
-                        { // jeśli jedzie wolniej niż można i jest wystarczająco daleko, to można
+                            // jeśli jedzie wolniej niż można i jest wystarczająco daleko, to można przyspieszyć
-                            // przyspieszyć
                             if (AccPreferred > 0.0) // jeśli nie ma zawalidrogi
                                 AccDesired = AccPreferred;
-                            // VelDesired:=Min0R(VelDesired,VelReduced+VelNext);
                         }
                         else if (ActualProximityDist > fMinProximityDist) {
                             // jedzie szybciej, niż trzeba na końcu ActualProximityDist, ale jeszcze jest daleko
 							if (ActualProximityDist < fMaxProximityDist) {
                                 // jak minął już maksymalny dystans po prostu hamuj (niski stopień)
                                 // ma stanąć, a jest w drodze hamowania albo ma jechać
+                                VelDesired = VelNext;
+                                if( VelDesired == 0.0 ) {
                                     // hamowanie tak, aby stanąć
                                     AccDesired = ( VelNext * VelNext - vel * vel ) / ( 25.92 * ( ActualProximityDist + 0.1 - 0.5*fMinProximityDist ) );
                                     AccDesired = std::min( AccDesired, fAccThreshold );
-								VelDesired = 0.0;
+                                }
 							}
 							else if ((vel <	VelNext + fVelPlus)||((vel<VelNext+2*fVelPlus)&&
 								(vel*vel<(VelNext + fVelPlus)*(VelNext + fVelPlus)-12.96*ActualProximityDist*std::min(0.0,AbsAccS)))) // jeśli niewielkie przekroczenie
@@ -4362,13 +4375,12 @@ bool TController::UpdateSituation(double dt)
 							{ // jeśli ma stanąć, a mieści się w drodze hamowania
 								AccDesired = AccPreferred;
 							}
-                            else if ((vel <
+/*
-                                VelNext + 20.0)&&(false)) // dwustopniowe hamowanie - niski przy małej różnicy
+                            else if ((vel < VelNext + 20.0)&&(false)) // dwustopniowe hamowanie - niski przy małej różnicy
                             { // jeśli jedzie wolniej niż VelNext+35km/h //Ra: 40, żeby nie
                                 // kombinował na zwrotnicach
                                 if (VelNext == 0.0)
-                                { // jeśli ma się zatrzymać, musi być to robione precyzyjnie i
+                                { // jeśli ma się zatrzymać, musi być to robione precyzyjnie i skutecznie
-                                    // skutecznie
                                     if (ActualProximityDist > fBrakeDist)
                                     { // jeśli ma stanąć, a mieści się w drodze hamowania
                                         if (vel < 10.0) // jeśli prędkość jest łatwa do zatrzymania
@@ -4412,7 +4424,9 @@ bool TController::UpdateSituation(double dt)
                                     }
                                 }
                             }
-							else { // przy dużej różnicy wysoki stopień (1,00 potrzebnego opoznienia)
+*/
+							else {
+                                // przy dużej różnicy wysoki stopień (1,00 potrzebnego opoznienia)
 								double dist = 0;// (VelNext * VelNext - (VelNext + 20) * (VelNext + 20)) / (25.92)*(-1 / fBrake_a0[0] - 1 / fAccThreshold);
                                 // ensure some minimal coasting speed, otherwise a vehicle entering this zone at very low speed will be crawling forever
                                 AccDesired =
@@ -4425,21 +4439,14 @@ bool TController::UpdateSituation(double dt)
                                                 VelNext + dist ) )
                                         + 0.1 ); // najpierw hamuje mocniej, potem zluzuje
 							}
-                            if (AccPreferred < AccDesired)
+                            AccDesired = std::min( AccDesired, AccPreferred );
-                                AccDesired = AccPreferred; //(1+abs(AccDesired))
-                            // ReactionTime=0.5*mvOccupied->BrakeDelay[2+2*mvOccupied->BrakeDelayFlag];
-                            // //aby szybkosc hamowania zalezala od przyspieszenia i opoznienia
-                            // hamulcow
-                            // fBrakeTime=0.5*mvOccupied->BrakeDelay[2+2*mvOccupied->BrakeDelayFlag];
-                            // //aby szybkosc hamowania zalezala od przyspieszenia i opoznienia
-                            // hamulcow
                         }
                         else {
                             // jest bliżej niż fMinProximityDist
                             VelDesired = Global::Min0RSpeed( VelDesired, VelNext ); // utrzymuj predkosc bo juz blisko
-                            if( vel < VelNext + fVelPlus ) {
+                            if( vel <= VelNext + fVelPlus ) {
                                 // jeśli niewielkie przekroczenie, ale ma jechać
-                                AccDesired = std::min( 0.0, AccPreferred ); // to olej (zacznij luzować)
+                                AccDesired = std::max( 0.0, AccPreferred ); // to olej (zacznij luzować)
                             }
                             ReactionTime = 0.1; // i orientuj się szybciej
                         }
@@ -4504,13 +4511,47 @@ bool TController::UpdateSituation(double dt)
                 // last step sanity check, until the whole calculation is straightened out
                 AccDesired = std::min( AccDesired, AccPreferred );
 
-                if (AIControllFlag)
+
-                { // część wykonawcza tylko dla AI, dla człowieka jedynie napisy
+
+                if (AIControllFlag) {
+                    // część wykonawcza tylko dla AI, dla człowieka jedynie napisy
+
+                    // zapobieganie poslizgowi u nas
+                    if (mvControlling->SlippingWheels) {
+
+                        if (!mvControlling->DecScndCtrl(2)) // bocznik na zero
+                            mvControlling->DecMainCtrl(1);
+/*
+                        if (mvOccupied->BrakeCtrlPos ==
+                            mvOccupied->BrakeCtrlPosNo) // jeśli ostatnia pozycja hamowania
+							//yB: ten warunek wyżej nie ma sensu
+                            mvOccupied->DecBrakeLevel(); // to cofnij hamulec
+                            DecBrake(); // to cofnij hamulec
+                        else
+                            mvControlling->AntiSlippingButton();
+*/
+                        DecBrake(); // to cofnij hamulec
+                        mvControlling->AntiSlippingButton();
+                        ++iDriverFailCount;
+                        mvControlling->SlippingWheels = false; // flaga już wykorzystana
+                    }
+                    if (iDriverFailCount > maxdriverfails)
+                    {
+                        Psyche = Easyman;
+                        if (iDriverFailCount > maxdriverfails * 2)
+                            SetDriverPsyche();
+                    }
+
+                    if( ( true == mvOccupied->EmergencyBrakeFlag ) // radio-stop
+                     && ( mvOccupied->Vel > 0.0 ) ) { // and still moving
+                        // if the radio-stop was issued don't waste effort trying to fight it
+                        while( true == DecSpeed() ) { ; } // just throttle down...
+                        goto maintenance; // ...and don't touch any other controls
+                    }
+
                     if (mvControlling->ConvOvldFlag ||
                         !mvControlling->Mains) // WS może wywalić z powodu błędu w drutach
                     { // wywalił bezpiecznik nadmiarowy przetwornicy
-                        // while (DecSpeed()); //zerowanie napędu
-                        // Controlling->ConvOvldFlag=false; //reset nadmiarowego
                         PrepareEngine(); // próba ponownego załączenia
                     }
                     // włączanie bezpiecznika
@@ -4519,14 +4560,10 @@ bool TController::UpdateSituation(double dt)
                         (mvControlling->EngineType == DieselElectric))
                         if (mvControlling->FuseFlag || Need_TryAgain)
                         {
-                            Need_TryAgain =
+                            Need_TryAgain = false; // true, jeśli druga pozycja w elektryku nie załapała
-                                false; // true, jeśli druga pozycja w elektryku nie załapała
-                            // if (!Controlling->DecScndCtrl(1)) //kręcenie po mału
-                            // if (!Controlling->DecMainCtrl(1)) //nastawnik jazdy na 0
                             mvControlling->DecScndCtrl(2); // nastawnik bocznikowania na 0
                             mvControlling->DecMainCtrl(2); // nastawnik jazdy na 0
-                            mvControlling->MainSwitch(
+                            mvControlling->MainSwitch(true); // Ra: dodałem, bo EN57 stawały po wywaleniu
-                                true); // Ra: dodałem, bo EN57 stawały po wywaleniu
                             if (!mvControlling->FuseOn())
                                 HelpMeFlag = true;
                             else
@@ -4538,13 +4575,19 @@ bool TController::UpdateSituation(double dt)
                                     SetDriverPsyche();
                             }
                         }
-                    // NOTE: stop-gap measure, effect limited to trains only while car calculations seem off
+                    // NOTE: as a stop-gap measure the routine is limited to trains only while car calculations seem off
                     if( mvControlling->CategoryFlag == 1 ) {
-                        if( -AccDesired * BrakeAccFactor() < ( ( fReady > 0.4 ) || ( VelNext > vel - 40.0 ) ? fBrake_a0[ 0 ] * 0.8 : -fAccThreshold ) )
+                        if( -AccDesired * BrakeAccFactor() < (
+                            ( ( fReady > 0.4 ) || ( VelNext > vel - 40.0 ) ) ?
+                                fBrake_a0[ 0 ] * 0.8 :
+                                -fAccThreshold )
+                            / braking_distance_multiplier( VelNext ) ) {
                             AccDesired = std::max( -0.06, AccDesired );
-                        else
+                        }
+                        else {
                             ReactionTime = 0.25; // i orientuj się szybciej, jeśli hamujesz
                         }
+                    }
                     if (mvOccupied->BrakeSystem == Pneumatic) // napełnianie uderzeniowe
                         if (mvOccupied->BrakeHandle == FV4a)
                         {
@@ -4699,6 +4742,8 @@ bool TController::UpdateSituation(double dt)
                     } // type & dt_ezt
                     else {
                         // a stara wersja w miarę dobrze działa na składy wagonowe
+                        if( ( VelNext == 0.0 )
+                         || ( vel > VelNext + fVelPlus ) ) {
                             if( ( ( fAccGravity < -0.05 ) && ( vel < 0.0 ) )
                              || ( ( AccDesired < fAccGravity - 0.1 ) && ( AbsAccS > AccDesired + fBrake_a1[ 0 ] ) ) ) {
                                 // u góry ustawia się hamowanie na fAccThreshold
@@ -4719,6 +4764,7 @@ bool TController::UpdateSituation(double dt)
                                     }
                                 }
                             }
+                        }
                         if ((AccDesired < fAccGravity - 0.05) && (AbsAccS < AccDesired - fBrake_a1[0]*0.51)) {
                             // jak hamuje, to nie tykaj kranu za często
                             // yB: luzuje hamulec dopiero przy różnicy opóźnień rzędu 0.2
@@ -4750,31 +4796,6 @@ bool TController::UpdateSituation(double dt)
                     WriteLog("BrakePos=" + AnsiString(mvOccupied->BrakeCtrlPos) + ", MainCtrl=" +
                              AnsiString(mvControlling->MainCtrlPos));
 #endif
-                    // zapobieganie poslizgowi u nas
-                    if (mvControlling->SlippingWheels)
-                    {
-                        if (!mvControlling->DecScndCtrl(2)) // bocznik na zero
-                            mvControlling->DecMainCtrl(1);
-/*
-                        if (mvOccupied->BrakeCtrlPos ==
-                            mvOccupied->BrakeCtrlPosNo) // jeśli ostatnia pozycja hamowania
-							//yB: ten warunek wyżej nie ma sensu
-                            mvOccupied->DecBrakeLevel(); // to cofnij hamulec
-                            DecBrake(); // to cofnij hamulec
-                        else
-                            mvControlling->AntiSlippingButton();
-*/
-                        DecBrake(); // to cofnij hamulec
-                        mvControlling->AntiSlippingButton();
-                        ++iDriverFailCount;
-                        mvControlling->SlippingWheels = false; // flaga już wykorzystana
-                    }
-                    if (iDriverFailCount > maxdriverfails)
-                    {
-                        Psyche = Easyman;
-                        if (iDriverFailCount > maxdriverfails * 2)
-                            SetDriverPsyche();
-                    }
                 } // if (AIControllFlag)
             } // kierunek różny od zera
             else
@@ -4807,6 +4828,8 @@ bool TController::UpdateSituation(double dt)
     else
         LastReactionTime += dt;
 
+maintenance:
+
     if ((fLastStopExpDist > 0.0) && (mvOccupied->DistCounter > fLastStopExpDist))
     {
         iStationStart = TrainParams->StationIndex; // zaktualizować wyświetlanie rozkładu
@@ -4823,9 +4846,8 @@ bool TController::UpdateSituation(double dt)
                 ReactionTime =
                     fWarningDuration; // wcześniejszy przebłysk świadomości, by zakończyć trąbienie
         }
-        if (mvOccupied->Vel >=
+        if (mvOccupied->Vel >= 3.0) {
-            3.0) // jesli jedzie, można odblokować trąbienie, bo się wtedy nie włączy
+            // jesli jedzie, można odblokować trąbienie, bo się wtedy nie włączy
-        {
             iDrivigFlags &= ~moveStartHornDone; // zatrąbi dopiero jak następnym razem stanie
             iDrivigFlags |= moveStartHorn; // i trąbić przed następnym ruszeniem
         }

Driver.h

@@ -369,6 +369,9 @@ class TController
     void TableTraceRoute(double fDistance, TDynamicObject *pVehicle = nullptr);
     void TableCheck(double fDistance);
     TCommandType TableUpdate(double &fVelDes, double &fDist, double &fNext, double &fAcc);
+    // modifies brake distance for low target speeds, to ease braking rate in such situations
+    float
+        braking_distance_multiplier( float const Targetvelocity );
     void TablePurger();
 public:
     std::size_t TableSize() const { return sSpeedTable.size(); }

Globals.cpp

@@ -51,7 +51,6 @@ bool Global::ControlPicking = false; // indicates controls pick mode is enabled
 bool Global::InputMouse = true; // whether control pick mode can be activated
 int Global::iTextMode = 0; // tryb pracy wyświetlacza tekstowego
 int Global::iScreenMode[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // numer ekranu wyświetlacza tekstowego
-double Global::fSunDeclination = 0.0; // deklinacja Słońca
 double Global::fTimeAngleDeg = 0.0; // godzina w postaci kąta
 float Global::fClockAngleDeg[6]; // kąty obrotu cylindrów dla zegara cyfrowego
 std::string Global::szTexturesTGA = ".tga"; // lista tekstur od TGA
@@ -63,7 +62,6 @@ int Global::iErorrCounter = 0; // licznik sprawdzań do śledzenia błędów Ope
 int Global::iTextures = 0; // licznik użytych tekstur
 TWorld *Global::pWorld = NULL;
 cParser *Global::pParser = NULL;
-int Global::iSegmentsRendered = 90; // ilość segmentów do regulacji wydajności
 TCamera *Global::pCamera = NULL; // parametry kamery
 TDynamicObject *Global::pUserDynamic = NULL; // pojazd użytkownika, renderowany bez trzęsienia
 TTranscripts Global::tranTexts; // obiekt obsługujący stenogramy dźwięków na ekranie
@@ -130,6 +128,7 @@ int Global::iDynamicFiltering = 5; // domyślne rozmywanie tekstur pojazdów
 std::string Global::LastGLError;
 GLint Global::iMaxTextureSize = 4096; // maksymalny rozmiar tekstury
 bool Global::bSmoothTraction = false; // wygładzanie drutów starym sposobem
+float Global::SplineFidelity { 1.f }; // determines segment size during conversion of splines to geometry
 std::string Global::szDefaultExt = Global::szTexturesDDS; // domyślnie od DDS
 int Global::iMultisampling = 2; // tryb antyaliasingu: 0=brak,1=2px,2=4px,3=8px,4=16px
 bool Global::DLFont{ false }; // switch indicating presence of basic font
@@ -148,7 +147,6 @@ double Global::fFpsMax = 65.0; // górna granica FPS, przy której promień scen
 double Global::fFpsRadiusMax = 3000.0; // maksymalny promień renderowania
 int Global::iFpsRadiusMax = 225; // maksymalny promień renderowania
 double Global::fRadiusFactor = 1.1; // współczynnik jednorazowej zmiany promienia scenerii
-bool Global::bOldSmudge = false; // Używanie starej smugi
 
 // parametry testowe (do testowania scenerii i obiektów)
 bool Global::bWireFrame = false;
@@ -588,6 +586,13 @@ void Global::ConfigParse(cParser &Parser)
             Parser.getTokens();
             Parser >> Global::bSmoothTraction;
         }
+        else if( token == "splinefidelity" ) {
+            // segment size during spline->geometry conversion
+            float splinefidelity;
+            Parser.getTokens();
+            Parser >> splinefidelity;
+            Global::SplineFidelity = clamp( splinefidelity, 1.f, 4.f );
+        }
         else if (token == "timespeed")
         {
             // przyspieszenie czasu, zmienna do testów
@@ -647,12 +652,6 @@ void Global::ConfigParse(cParser &Parser)
             Parser.getTokens();
             Parser >> Global::bHideConsole;
         }
-        else if (token == "oldsmudge")
-        {
-
-            Parser.getTokens();
-            Parser >> Global::bOldSmudge;
-        }
         else if (token == "rollfix")
         {
             // Ra: poprawianie przechyłki, aby wewnętrzna szyna była "pozioma"

Globals.h

@@ -272,7 +272,7 @@ class Global
     static double fMoveLight; // numer dnia w roku albo -1
     static bool FakeLight; // toggle between fixed and dynamic daylight
     static bool bSmoothTraction; // wygładzanie drutów
-    static double fSunDeclination; // deklinacja Słońca
+    static float SplineFidelity; // determines segment size during conversion of splines to geometry
     static double fTimeSpeed; // przyspieszenie czasu, zmienna do testów
     static double fTimeAngleDeg; // godzina w postaci kąta
     static float fClockAngleDeg[6]; // kąty obrotu cylindrów dla zegara cyfrowego
@@ -293,14 +293,12 @@ class Global
     static int iSlowMotionMask; // maska wyłączanych właściwości
     static int iModifyTGA; // czy korygować pliki TGA dla szybszego wczytywania
     static bool bHideConsole; // hunter-271211: ukrywanie konsoli
-	static bool bOldSmudge; // Używanie starej smugi
 	
     static TWorld *pWorld; // wskaźnik na świat do usuwania pojazdów
     static TAnimModel *pTerrainCompact; // obiekt terenu do ewentualnego zapisania w pliku
     static std::string asTerrainModel; // nazwa obiektu terenu do zapisania w pliku
     static bool bRollFix; // czy wykonać przeliczanie przechyłki
     static cParser *pParser;
-    static int iSegmentsRendered; // ilość segmentów do regulacji wydajności
     static double fFpsAverage; // oczekiwana wartosć FPS
     static double fFpsDeviation; // odchylenie standardowe FPS
     static double fFpsMin; // dolna granica FPS, przy której promień scenerii będzie zmniejszany

Ground.cpp

@@ -351,13 +351,17 @@ bool TSubRect::RaTrackAnimAdd(TTrack *t)
     return false; // będzie animowane...
 }
 
-void TSubRect::RaAnimate()
+// wykonanie animacji
-{ // wykonanie animacji
+void TSubRect::RaAnimate( unsigned int const Framestamp ) {
-    if( tTrackAnim == nullptr ) {
+    
+    if( ( tTrackAnim == nullptr )
+     || ( Framestamp == m_framestamp ) ) {
         // nie ma nic do animowania
         return;
     }
     tTrackAnim = tTrackAnim->RaAnimate(); // przeliczenie animacji kolejnego
+
+    m_framestamp = Framestamp;
 };
 
 TTraction * TSubRect::FindTraction(glm::dvec3 const &Point, int &iConnection, TTraction *Exclude)
@@ -427,8 +431,6 @@ void TSubRect::RenderSounds()
 //---------------------------------------------------------------------------
 //------------------ Kwadrat kilometrowy ------------------------------------
 //---------------------------------------------------------------------------
-int TGroundRect::iFrameNumber = 0; // licznik wyświetlanych klatek
-
 TGroundRect::~TGroundRect()
 {
     SafeDeleteArray(pSubRects);

Ground.h

@@ -171,6 +171,7 @@ class TSubRect : /*public Resource,*/ public CMesh
 { // sektor składowy kwadratu kilometrowego
   public:
     bounding_area m_area;
+    unsigned int m_framestamp { 0 }; // id of last rendered gfx frame
     int iTracks = 0; // ilość torów w (tTracks)
     TTrack **tTracks = nullptr; // tory do renderowania pojazdów
   protected:
@@ -192,15 +193,12 @@ class TSubRect : /*public Resource,*/ public CMesh
     void LoadNodes(); // utworzenie VBO sektora
   public:
     virtual ~TSubRect();
-/*
-    virtual void Release(); // zwalnianie VBO sektora
-*/
     virtual void NodeAdd(TGroundNode *Node); // dodanie obiektu do sektora na etapie rozdzielania na sektory
     void Sort(); // optymalizacja obiektów w sektorze (sortowanie wg tekstur)
     TTrack * FindTrack(vector3 *Point, int &iConnection, TTrack *Exclude);
     TTraction * FindTraction(glm::dvec3 const &Point, int &iConnection, TTraction *Exclude);
     bool RaTrackAnimAdd(TTrack *t); // zgłoszenie toru do animacji
-    void RaAnimate(); // przeliczenie animacji torów
+    void RaAnimate( unsigned int const Framestamp ); // przeliczenie animacji torów
     void RenderSounds(); // dźwięki pojazdów z niewidocznych sektorów
 };
 
@@ -221,7 +219,6 @@ class TGroundRect : public TSubRect
 
 private:
     TSubRect *pSubRects { nullptr };
-    int iLastDisplay; // numer klatki w której był ostatnio wyświetlany
 
     void Init();
 
@@ -251,7 +248,6 @@ public:
                 // optymalizacja obiektów w sektorach
                 pSubRects[ i ].Sort(); } } };
 
-    static int iFrameNumber; // numer kolejny wyświetlanej klatki
     TGroundNode *nTerrain { nullptr }; // model terenu z E3D - użyć nRootMesh?
 };
 

Model3d.cpp

@@ -31,7 +31,7 @@ extern TWorld World;
 
 using namespace Mtable;
 
-double TSubModel::fSquareDist = 0;
+float TSubModel::fSquareDist = 0.f;
 size_t TSubModel::iInstance; // numer renderowanego egzemplarza obiektu
 texture_handle const *TSubModel::ReplacableSkinId = NULL;
 int TSubModel::iAlpha = 0x30300030; // maska do testowania flag tekstur wymiennych

Model3d.h

@@ -155,7 +155,7 @@ public:
 	static size_t iInstance; // identyfikator egzemplarza, który aktualnie renderuje model
 	static material_handle const *ReplacableSkinId;
 	static int iAlpha; // maska bitowa dla danego przebiegu
-	static double fSquareDist;
+	static float fSquareDist;
 	static TModel3d *pRoot;
 	static std::string *pasText; // tekst dla wyświetlacza (!!!! do przemyślenia)
 	~TSubModel();

Track.cpp

@@ -527,7 +527,7 @@ void TTrack::Load(cParser *parser, vector3 pOrigin, std::string name)
             // na przechyłce doliczyć jeszcze pół przechyłki
         }
         if( fRadius != 0 ) // gdy podany promień
-            segsize = clamp( 0.2 + std::fabs( fRadius ) * 0.02, 2.0, 10.0 );
+            segsize = clamp( std::fabs( fRadius ) * ( 0.02 / Global::SplineFidelity ), 2.0 / Global::SplineFidelity, 10.0 );
         else
             segsize = 10.0; // for straights, 10m per segment works good enough
 

World.cpp

@@ -1711,7 +1711,7 @@ TWorld::Update_UI() {
                     + ")";
 
                 uitextline2 =
-                    "HamZ=" + to_string( tmp->MoverParameters->fBrakeCtrlPos, 1 )
+                    "HamZ=" + to_string( tmp->MoverParameters->fBrakeCtrlPos, 2 )
                     + "; HamP=" + std::to_string( tmp->MoverParameters->LocalBrakePos ) + "/" + to_string( tmp->MoverParameters->LocalBrakePosA, 2 )
                     + "; NasJ=" + std::to_string( tmp->MoverParameters->MainCtrlPos ) + "(" + std::to_string( tmp->MoverParameters->MainCtrlActualPos ) + ")"
                     + "; NasB=" + std::to_string( tmp->MoverParameters->ScndCtrlPos ) + "(" + std::to_string( tmp->MoverParameters->ScndCtrlActualPos ) + ")"

renderer.cpp

@@ -322,6 +322,7 @@ opengl_renderer::Render() {
 
     m_renderpass.draw_mode = rendermode::none; // force setup anew
     m_debuginfo.clear();
+    ++m_framestamp;
     Render_pass( rendermode::color );
 
     m_drawcount = m_drawqueue.size();
@@ -1331,8 +1332,6 @@ opengl_renderer::Texture( texture_handle const Texture ) const {
 bool
 opengl_renderer::Render( TGround *Ground ) {
 
-    ++TGroundRect::iFrameNumber; // zwięszenie licznika ramek (do usuwniania nadanimacji)
-
     m_drawqueue.clear();
 
     switch( m_renderpass.draw_mode ) {
@@ -1441,8 +1440,6 @@ opengl_renderer::Render( TGroundRect *Groundcell ) {
 
     bool result { false }; // will be true if we do any rendering
 
-    if( Groundcell->iLastDisplay != Groundcell->iFrameNumber ) {
-        // tylko jezeli dany kwadrat nie był jeszcze renderowany
     Groundcell->LoadNodes(); // ewentualne tworzenie siatek
 
     switch( m_renderpass.draw_mode ) {
@@ -1457,6 +1454,7 @@ opengl_renderer::Render( TGroundRect *Groundcell ) {
                 for( TGroundNode *node = Groundcell->nRenderRect; node != nullptr; node = node->nNext3 ) {
                     Render( node );
                 }
+                result = true;
             }
             break;
         }
@@ -1468,6 +1466,7 @@ opengl_renderer::Render( TGroundRect *Groundcell ) {
                 for( TGroundNode *node = Groundcell->nRenderRect; node != nullptr; node = node->nNext3 ) {
                     Render( node );
                 }
+                result = true;
                 ::glEnable( GL_CULL_FACE );
             }
         }
@@ -1482,8 +1481,6 @@ opengl_renderer::Render( TGroundRect *Groundcell ) {
         Render( Groundcell->nTerrain );
     }
 #endif
-        Groundcell->iLastDisplay = Groundcell->iFrameNumber; // drugi raz nie potrzeba
-        result = true;
 
     // add the subcells of the cell to the draw queue
     switch( m_renderpass.draw_mode ) {
@@ -1509,7 +1506,6 @@ opengl_renderer::Render( TGroundRect *Groundcell ) {
             break;
         }
     }
-    }
     return result;
 }
 
@@ -1519,7 +1515,8 @@ opengl_renderer::Render( TSubRect *Groundsubcell ) {
     // oznaczanie aktywnych sektorów
     Groundsubcell->LoadNodes();
 
-    Groundsubcell->RaAnimate(); // przeliczenia animacji torów w sektorze
+    // przeliczenia animacji torów w sektorze
+    Groundsubcell->RaAnimate( m_framestamp );
 
     TGroundNode *node;
 
@@ -1617,16 +1614,16 @@ opengl_renderer::Render( TGroundNode *Node ) {
     switch( m_renderpass.draw_mode ) {
         case rendermode::shadows: {
             // 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
-            distancesquared = SquareMagnitude( ( Node->pCenter - Global::pCameraPosition ) / Global::ZoomFactor );
+            distancesquared = SquareMagnitude( ( Node->pCenter - Global::pCameraPosition ) / Global::ZoomFactor ) / Global::fDistanceFactor;
             break;
         }
         default: {
-            distancesquared = SquareMagnitude( ( Node->pCenter - m_renderpass.camera.position() ) / Global::ZoomFactor );
+            distancesquared = SquareMagnitude( ( Node->pCenter - m_renderpass.camera.position() ) / Global::ZoomFactor ) / Global::fDistanceFactor;
             break;
         }
     }
-    if( ( distancesquared > ( Node->fSquareRadius    * Global::fDistanceFactor ) )
+    if( ( distancesquared > Node->fSquareRadius )
-     || ( distancesquared < ( Node->fSquareMinRadius / Global::fDistanceFactor ) ) ) {
+     || ( distancesquared < Node->fSquareMinRadius ) ) {
         return false;
     }
 
@@ -1668,32 +1665,16 @@ opengl_renderer::Render( TGroundNode *Node ) {
                     break;
                 }
             }
-            Node->Model->RaAnimate(); // jednorazowe przeliczenie animacji
+            Node->Model->RaAnimate( m_framestamp ); // jednorazowe przeliczenie animacji
             Node->Model->RaPrepare();
             if( Node->Model->pModel ) {
                 // renderowanie rekurencyjne submodeli
-                switch( m_renderpass.draw_mode ) {
-                    case rendermode::shadows: {
                 Render(
                     Node->Model->pModel,
                     Node->Model->Material(),
-                            // 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
+                    distancesquared,
-                            SquareMagnitude( Node->pCenter - Global::pCameraPosition ),
                     Node->pCenter - m_renderpass.camera.position(),
                     Node->Model->vAngle );
-                        break;
-                    }
-                    default: {
-                        auto const position = Node->pCenter - m_renderpass.camera.position();
-                        Render(
-                            Node->Model->pModel,
-                            Node->Model->Material(),
-                            SquareMagnitude( position ),
-                            position,
-                            Node->Model->vAngle );
-                        break;
-                    }
-                }
             }
             return true;
         }
@@ -1727,7 +1708,7 @@ opengl_renderer::Render( TGroundNode *Node ) {
                     break;
                 }
             }
-            auto const linewidth = clamp( 0.5 * linealpha + Node->fLineThickness * Node->m_radius / 1000.0, 1.0, 32.0 );
+            auto const linewidth = clamp( 0.5 * linealpha + Node->fLineThickness * Node->m_radius / 1000.0, 1.0, 8.0 );
             if( linewidth > 1.0 ) {
                 ::glLineWidth( static_cast<float>( linewidth ) );
             }
@@ -1833,15 +1814,16 @@ opengl_renderer::Render( TDynamicObject *Dynamic ) {
     }
     // setup
     TSubModel::iInstance = ( size_t )this; //żeby nie robić cudzych animacji
-    auto const originoffset = Dynamic->vPosition - m_renderpass.camera.position();
+    glm::dvec3 const originoffset = Dynamic->vPosition - m_renderpass.camera.position();
-    double squaredistance;
+    // lod visibility ranges are defined for base (x 1.0) viewing distance. for render we adjust them for actual range multiplier and zoom
+    float squaredistance;
     switch( m_renderpass.draw_mode ) {
         case rendermode::shadows: {
-            squaredistance = SquareMagnitude( ( Dynamic->vPosition - Global::pCameraPosition ) / Global::ZoomFactor );
+            squaredistance = glm::length2( glm::vec3{ glm::dvec3{ Dynamic->vPosition - Global::pCameraPosition } } / Global::ZoomFactor ) / Global::fDistanceFactor;
             break;
         }
         default: {
-            squaredistance = SquareMagnitude( originoffset / Global::ZoomFactor );
+            squaredistance = glm::length2( glm::vec3{ originoffset } / Global::ZoomFactor ) / Global::fDistanceFactor;
             break;
         }
     }
@@ -1996,7 +1978,7 @@ opengl_renderer::Render_cab( TDynamicObject *Dynamic ) {
 }
 
 bool
-opengl_renderer::Render( TModel3d *Model, material_data const *Material, double const Squaredistance ) {
+opengl_renderer::Render( TModel3d *Model, material_data const *Material, float const Squaredistance ) {
 
     auto alpha =
         ( Material != nullptr ?
@@ -2028,7 +2010,7 @@ opengl_renderer::Render( TModel3d *Model, material_data const *Material, double
 }
 
 bool
-opengl_renderer::Render( TModel3d *Model, material_data const *Material, double const Squaredistance, Math3D::vector3 const &Position, Math3D::vector3 const &Angle ) {
+opengl_renderer::Render( TModel3d *Model, material_data const *Material, float const Squaredistance, Math3D::vector3 const &Position, Math3D::vector3 const &Angle ) {
 
     ::glPushMatrix();
     ::glTranslated( Position.x, Position.y, Position.z );
@@ -2050,8 +2032,8 @@ void
 opengl_renderer::Render( TSubModel *Submodel ) {
 
     if( ( Submodel->iVisible )
-     && ( TSubModel::fSquareDist >= ( Submodel->fSquareMinDist / std::max( 1.f, Global::fDistanceFactor ) ) )
+     && ( TSubModel::fSquareDist >= Submodel->fSquareMinDist )
-     && ( TSubModel::fSquareDist <= ( Submodel->fSquareMaxDist * std::max( 1.f, Global::fDistanceFactor ) ) ) ) {
+     && ( TSubModel::fSquareDist <= Submodel->fSquareMaxDist ) ) {
 
         if( Submodel->iFlags & 0xC000 ) {
             ::glPushMatrix();
@@ -2206,7 +2188,7 @@ opengl_renderer::Render( TSubModel *Submodel ) {
                         float const anglefactor = ( Submodel->fCosViewAngle - Submodel->fCosFalloffAngle ) / ( 1.0f - Submodel->fCosFalloffAngle );
                         // distance attenuation. NOTE: since it's fixed pipeline with built-in gamma correction we're using linear attenuation
                         // we're capping how much effect the distance attenuation can have, otherwise the lights get too tiny at regular distances
-                        float const distancefactor = static_cast<float>( std::max( 0.5, ( Submodel->fSquareMaxDist - TSubModel::fSquareDist ) / ( Submodel->fSquareMaxDist * Global::fDistanceFactor ) ) );
+                        float const distancefactor = std::max( 0.5f, ( Submodel->fSquareMaxDist - TSubModel::fSquareDist ) / Submodel->fSquareMaxDist );
 
                         if( lightlevel > 0.f ) {
                             // material configuration:
@@ -2425,16 +2407,16 @@ opengl_renderer::Render_Alpha( TGroundNode *Node ) {
     switch( m_renderpass.draw_mode ) {
         case rendermode::shadows: {
             // 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
-            distancesquared = SquareMagnitude( ( Node->pCenter - Global::pCameraPosition ) / Global::ZoomFactor );
+            distancesquared = SquareMagnitude( ( Node->pCenter - Global::pCameraPosition ) / Global::ZoomFactor ) / Global::fDistanceFactor;
             break;
         }
         default: {
-            distancesquared = SquareMagnitude( ( Node->pCenter - m_renderpass.camera.position() ) / Global::ZoomFactor );
+            distancesquared = SquareMagnitude( ( Node->pCenter - m_renderpass.camera.position() ) / Global::ZoomFactor ) / Global::fDistanceFactor;
             break;
         }
     }
-    if( ( distancesquared > ( Node->fSquareRadius    * Global::fDistanceFactor ) )
+    if( ( distancesquared > Node->fSquareRadius )
-     || ( distancesquared < ( Node->fSquareMinRadius / Global::fDistanceFactor ) ) ) {
+     || ( distancesquared < Node->fSquareMinRadius ) ) {
         return false;
     }
 
@@ -2489,28 +2471,12 @@ opengl_renderer::Render_Alpha( TGroundNode *Node ) {
             Node->Model->RaPrepare();
             if( Node->Model->pModel ) {
                 // renderowanie rekurencyjne submodeli
-                switch( m_renderpass.draw_mode ) {
-                    case rendermode::shadows: {
                 Render_Alpha(
                     Node->Model->pModel,
                     Node->Model->Material(),
-                            // 'camera' for the light pass is the light source, but we need to draw what the 'real' camera sees
+                    distancesquared,
-                            SquareMagnitude( Node->pCenter - Global::pCameraPosition ),
                     Node->pCenter - m_renderpass.camera.position(),
                     Node->Model->vAngle );
-                        break;
-                    }
-                    default: {
-                        auto const position = Node->pCenter - m_renderpass.camera.position();
-                        Render_Alpha(
-                            Node->Model->pModel,
-                            Node->Model->Material(),
-                            SquareMagnitude( position ),
-                            position,
-                            Node->Model->vAngle );
-                        break;
-                    }
-                }
             }
             return true;
         }
@@ -2532,7 +2498,7 @@ opengl_renderer::Render_Alpha( TGroundNode *Node ) {
                     glm::vec4(
                         Node->Diffuse * glm::vec3( Global::DayLight.ambient ), // w zaleznosci od koloru swiatla
                         std::min( 1.0, linealpha ) ) ) );
-            auto const linewidth = clamp( 0.5 * linealpha + Node->fLineThickness * Node->m_radius / 1000.0, 1.0, 32.0 );
+            auto const linewidth = clamp( 0.5 * linealpha + Node->fLineThickness * Node->m_radius / 1000.0, 1.0, 8.0 );
             if( linewidth > 1.0 ) {
                 ::glLineWidth( static_cast<float>(linewidth) );
             }
@@ -2590,15 +2556,16 @@ opengl_renderer::Render_Alpha( TDynamicObject *Dynamic ) {
 
     // setup
     TSubModel::iInstance = ( size_t )this; //żeby nie robić cudzych animacji
-    auto const originoffset = Dynamic->vPosition - m_renderpass.camera.position();
+    glm::dvec3 const originoffset = Dynamic->vPosition - m_renderpass.camera.position();
-    double squaredistance;
+    // lod visibility ranges are defined for base (x 1.0) viewing distance. for render we adjust them for actual range multiplier and zoom
+    float squaredistance;
     switch( m_renderpass.draw_mode ) {
         case rendermode::shadows: {
-            squaredistance = SquareMagnitude( ( Dynamic->vPosition - Global::pCameraPosition ) / Global::ZoomFactor );
+            squaredistance = glm::length2( glm::vec3{ glm::dvec3{ Dynamic->vPosition - Global::pCameraPosition } } / Global::ZoomFactor ) / Global::fDistanceFactor;
             break;
         }
         default: {
-            squaredistance = SquareMagnitude( originoffset / Global::ZoomFactor );
+            squaredistance = glm::length2( glm::vec3{ originoffset } / Global::ZoomFactor ) / Global::fDistanceFactor;
             break;
         }
     }
@@ -2657,7 +2624,7 @@ opengl_renderer::Render_Alpha( TDynamicObject *Dynamic ) {
 }
 
 bool
-opengl_renderer::Render_Alpha( TModel3d *Model, material_data const *Material, double const Squaredistance ) {
+opengl_renderer::Render_Alpha( TModel3d *Model, material_data const *Material, float const Squaredistance ) {
 
     auto alpha =
         ( Material != nullptr ?
@@ -2689,7 +2656,7 @@ opengl_renderer::Render_Alpha( TModel3d *Model, material_data const *Material, d
 }
 
 bool
-opengl_renderer::Render_Alpha( TModel3d *Model, material_data const *Material, double const Squaredistance, Math3D::vector3 const &Position, Math3D::vector3 const &Angle ) {
+opengl_renderer::Render_Alpha( TModel3d *Model, material_data const *Material, float const Squaredistance, Math3D::vector3 const &Position, Math3D::vector3 const &Angle ) {
 
     ::glPushMatrix();
     ::glTranslated( Position.x, Position.y, Position.z );
@@ -2711,8 +2678,8 @@ void
 opengl_renderer::Render_Alpha( TSubModel *Submodel ) {
     // renderowanie przezroczystych przez DL
     if( ( Submodel->iVisible )
-     && ( TSubModel::fSquareDist >= ( Submodel->fSquareMinDist / std::max( 1.f, Global::fDistanceFactor ) ) )
+     && ( TSubModel::fSquareDist >= Submodel->fSquareMinDist )
-     && ( TSubModel::fSquareDist <= ( Submodel->fSquareMaxDist * std::max( 1.f, Global::fDistanceFactor ) ) ) ) {
+     && ( TSubModel::fSquareDist <= Submodel->fSquareMaxDist ) ) {
 
         if( Submodel->iFlags & 0xC000 ) {
             ::glPushMatrix();
@@ -3010,7 +2977,7 @@ opengl_renderer::Update( double const Deltatime ) {
     m_framerate = 1000.f / ( m_drawtime / 20.f );
 
     // adjust draw ranges etc, based on recent performance
-    auto const framerate = 1000.0f / (m_drawtimecolorpass / 20.0f);
+    auto const framerate = 1000.f / (m_drawtimecolorpass / 20.f);
 
     float targetfactor;
          if( framerate > 90.0 ) { targetfactor = 3.0f; }

renderer.h

@@ -277,9 +277,9 @@ private:
     bool
         Render( TDynamicObject *Dynamic );
     bool
-        Render( TModel3d *Model, material_data const *Material, double const Squaredistance, Math3D::vector3 const &Position, Math3D::vector3 const &Angle );
+        Render( TModel3d *Model, material_data const *Material, float const Squaredistance, Math3D::vector3 const &Position, Math3D::vector3 const &Angle );
     bool
-        Render( TModel3d *Model, material_data const *Material, double const Squaredistance );
+        Render( TModel3d *Model, material_data const *Material, float const Squaredistance );
     void
         Render( TSubModel *Submodel );
     void
@@ -297,9 +297,9 @@ private:
     bool
         Render_Alpha( TDynamicObject *Dynamic );
     bool
-        Render_Alpha( TModel3d *Model, material_data const *Material, double const Squaredistance, Math3D::vector3 const &Position, Math3D::vector3 const &Angle );
+        Render_Alpha( TModel3d *Model, material_data const *Material, float const Squaredistance, Math3D::vector3 const &Position, Math3D::vector3 const &Angle );
     bool
-        Render_Alpha( TModel3d *Model, material_data const *Material, double const Squaredistance );
+        Render_Alpha( TModel3d *Model, material_data const *Material, float const Squaredistance );
     void
         Render_Alpha( TSubModel *Submodel );
     void
@@ -350,6 +350,7 @@ private:
     int m_diffusetextureunit{ GL_TEXTURE3 };
     units_state m_unitstate;
 
+    unsigned int m_framestamp; // id of currently rendered gfx frame
     float m_drawtime { 1000.f / 30.f * 20.f }; // start with presumed 'neutral' average of 30 fps
     std::chrono::steady_clock::time_point m_drawstart; // cached start time of previous frame
     float m_framerate;

version.h

@@ -1,5 +1,5 @@
 #pragma once
 
 #define VERSION_MAJOR 17
-#define VERSION_MINOR 821
+#define VERSION_MINOR 823
 #define VERSION_REVISION 0