Automatic merge of T1.5.1-684-gc6e0de1c4 and 8 pull requests

- Pull request #570 at c59c788: Experimental glTF 2.0 support with PBR lighting
- Pull request #839 at d00beb9: First phase of https://blueprints.launchpad.net/or/+spec/additional-cruise-control-parameters
- Pull request #865 at a1318b5: Dispatcher window improvements
- Pull request #874 at f8dbeab: Dynamic brake controller refactoring
- Pull request #875 at 43bf33e: Bug fix for https://bugs.launchpad.net/or/+bug/2036346 Player train switching doesn't work with 3D cabs
- Pull request #876 at f92de76: docs: add source for documents previously on website to source Documentation folder
- Pull request #878 at aafbfac: Implement Polach Adhesion
- Pull request #883 at aac4d3f: SwitchPanel disconnect/connect handling

Author: openrails-bot

Source/Orts.Simulation/Simulation/RollingStocks/SubSystems/PowerTransmissions/Axle.cs

@@ -878,13 +878,13 @@ void Integrate(float elapsedClockSeconds)
         {
             if (elapsedClockSeconds <= 0) return;
             double prevSpeedMpS = AxleSpeedMpS;
-
+/*
             if (Math.Abs(integratorError) > Math.Max((Math.Abs(SlipSpeedMpS) - 1) * 0.01, 0.001))
             {
                 ++NumOfSubstepsPS;
                 waitBeforeSpeedingUp = 100;
 
-          //      Trace.TraceInformation("Algorithim Increase - Steps {0} Err {1}", NumOfSubstepsPS, integratorError);
+                //      Trace.TraceInformation("Algorithim Increase - Steps {0} Err {1}", NumOfSubstepsPS, integratorError);
 
             }
             else
@@ -894,34 +894,43 @@ void Integrate(float elapsedClockSeconds)
                     --NumOfSubstepsPS;
                     waitBeforeSpeedingUp = 10;      //not so fast ;)
 
-        //            Trace.TraceInformation("Algorithim Decrease - Steps {0} Err {1}", NumOfSubstepsPS, integratorError);
+                    //            Trace.TraceInformation("Algorithim Decrease - Steps {0} Err {1}", NumOfSubstepsPS, integratorError);
                 }
             }
 
             NumOfSubstepsPS = Math.Max(Math.Min(NumOfSubstepsPS, 130), 1);
-
-            //      use straight line graph approximation
-            // Points are 1 = (0, 150) and 2 = (threshold, 0)
-
-
-            if (SlipSpeedMpS > 0.7 * WheelSlipThresholdMpS)
+*/
+            // use straight line graph approximation
+            // Points are 1 = (0, upperLimit) and 2 = (threshold, lowerLimit)
+
+            var upperLimit = 130;
+            var lowerLimit = 10;
+            var AdhesGrad = ((upperLimit - lowerLimit) / (WheelSlipThresholdMpS - 0));
+            var targetNumOfSubstepsPS = Math.Abs((AdhesGrad * SlipSpeedMpS) + lowerLimit);
+            if (float.IsNaN((float)targetNumOfSubstepsPS)) targetNumOfSubstepsPS = 1;
+            //                 Trace.TraceInformation("Grad - {0} AdhesGrad {1} SlipSpeedMps {2} Threshold {3}", temp, AdhesGrad, SlipSpeedMpS, WheelSlipThresholdMpS);
+
+            if (targetNumOfSubstepsPS > NumOfSubstepsPS) // increase substeps
             {
-                var upperLimit = 130;
-                var AdhesGrad = ((0 - upperLimit) / (WheelSlipThresholdMpS - 0));
-                var temp = Math.Abs((AdhesGrad * SlipSpeedMpS) + upperLimit);
-                if (float.IsNaN((float)temp)) temp = 1;
-           //                 Trace.TraceInformation("Grad - {0} AdhesGrad {1} SlipSpeedMps {2} Threshold {3}", temp, AdhesGrad, SlipSpeedMpS, WheelSlipThresholdMpS);
-
-                NumOfSubstepsPS = (int)temp;
+                if (--waitBeforeSpeedingUp <= 0) //wait for a while before speeding up the integration
+                {
+                    NumOfSubstepsPS += 5;
+                    waitBeforeSpeedingUp = 5;      //not so fast ;)
+                }
+            }
+            else if (targetNumOfSubstepsPS < NumOfSubstepsPS) // decrease sub steps
+            {
+                NumOfSubstepsPS -= 5;
+                waitBeforeSpeedingUp = 5;
+            }
 
-                if (NumOfSubstepsPS < 1)
-                    NumOfSubstepsPS = 1;
+            if (NumOfSubstepsPS < lowerLimit)
+                NumOfSubstepsPS = lowerLimit;
 
-                if (NumOfSubstepsPS > upperLimit)
-                    NumOfSubstepsPS = upperLimit;
+            if (NumOfSubstepsPS > upperLimit)
+                NumOfSubstepsPS = upperLimit;        
 
-                //            Trace.TraceInformation("Number of Steps {0}", NumOfSubstepsPS);
-            }
+      //      Trace.TraceInformation("Grad - {0} AdhesGrad {1} SlipSpeedMps {2} Threshold {3} NumStepsPS {4}", targetNumOfSubstepsPS, AdhesGrad, SlipSpeedMpS, WheelSlipThresholdMpS, NumOfSubstepsPS);
 
             double dt = elapsedClockSeconds / NumOfSubstepsPS;
             double hdt = dt / 2;
@@ -934,16 +943,16 @@ void Integrate(float elapsedClockSeconds)
                 {
                     if (k1.Item1 * dt > Math.Max((Math.Abs(SlipSpeedMpS) - 1) * 10, 1) / 100)
                     {
-                        NumOfSubstepsPS = Math.Min(NumOfSubstepsPS + 5, 130);
-               //         Trace.TraceInformation("Algorithim Change - k1 - Number of Steps {0}", NumOfSubstepsPS);
+                        //        NumOfSubstepsPS = Math.Min(NumOfSubstepsPS + 5, 130);
+                        //         Trace.TraceInformation("Algorithim Change - k1 - Number of Steps {0}", NumOfSubstepsPS);
                         dt = elapsedClockSeconds / NumOfSubstepsPS;
                         hdt = dt / 2;
-                    }       
+                    }
                 }
                 var k2 = GetAxleMotionVariation(AxleSpeedMpS + k1.Item1 * hdt, hdt);
                 var k3 = GetAxleMotionVariation(AxleSpeedMpS + k2.Item1 * hdt, hdt);
                 var k4 = GetAxleMotionVariation(AxleSpeedMpS + k3.Item1 * dt, dt);
-                
+
                 AxleSpeedMpS += (integratorError = (k1.Item1 + 2 * (k2.Item1 + k3.Item1) + k4.Item1) * dt / 6);
                 AxlePositionRad += (k1.Item2 + 2 * (k2.Item2 + k3.Item2) + k4.Item2) * dt / 6;
                 axleOutForceSumN += (k1.Item3 + 2 * (k2.Item3 + k3.Item3) + k4.Item3);