Automatic merge of T1.5.1-351-gc9abcd22b and 8 pull requests

- Pull request #570 at 14abf7a: Experimental glTF 2.0 support with PBR lighting
- Pull request #732 at 1edb2e5: Improvements for air brakes
- Pull request #751 at 00981a2: Web interface to control cab controls with external hardware
- Pull request #767 at 82c5f1c: Refine sunrise and sunset
- Pull request #799 at eb92d81: Consolidated wind simulation
- Pull request #803 at 7157e08: Various adjustments to steam adhesion
- Pull request #809 at f67822a: Some on-screen messages not suppressed, Bug #2008012
- Pull request #813 at a8e9d9b: Refactored garbage generators

Author: openrails-bot

Source/ORTS.Common/Conversions.cs

@@ -573,6 +573,7 @@ public static class FormatStrings
         public static string kN = Catalog.GetString("kN");
         public static string lbf = Catalog.GetString("lbf");
         public static string klbf = Catalog.GetString("klbf");
+        public static string deg = Catalog.GetString("°");
 
         /// <summary>
         /// Formatted unlocalized speed string, used in reports and logs.
@@ -814,6 +815,11 @@ public static string FormatPressure(float pressure, PressureUnit inputUnit, Pres
             return String.Format(CultureInfo.CurrentCulture, format, pressureOut);
         }
 
+        public static string FormatAngleDeg(float angleDeg)
+        {
+            return String.Format(CultureInfo.CurrentCulture, "{0:F0} {1}", angleDeg, deg);
+        }
+
         /// <summary>
         /// Converts duration in floating-point seconds to whole hours, minutes and seconds (rounded down).
         /// </summary>

Source/Orts.Simulation/Simulation/AIs/AITrain.cs

@@ -722,7 +722,7 @@ public void AIUpdate(float elapsedClockSeconds, double clockTime, bool preUpdate
 
                 if (Cars[0] is MSTSLocomotive leadingLoco)
                 {
-                    var isRainingOrSnowing = Simulator.Weather.PricipitationIntensityPPSPM2 > 0;
+                    var isRainingOrSnowing = Simulator.Weather.PrecipitationIntensityPPSPM2 > 0;
                     if (leadingLoco.Wiper && !isRainingOrSnowing)
                         leadingLoco.SignalEvent(Event.WiperOff);
                     else if (!leadingLoco.Wiper && isRainingOrSnowing)

Source/Orts.Simulation/Simulation/Physics/Train.cs

@@ -2111,14 +2111,14 @@ public virtual void physicsUpdate(float elapsedClockSeconds)
         public void UpdateWindComponents()
         {
             // Gets wind direction and speed, and determines HUD display values for the train as a whole. 
-            //These will be representative of the train whilst it is on a straight track, but each wagon will vary when going around a curve.
+            // These will be representative of the train whilst it is on a straight track, but each wagon will vary when going around a curve.
             // Note both train and wind direction will be positive between 0 (north) and 180 (south) through east, and negative between 0 (north) and 180 (south) through west
             // Wind and train direction to be converted to an angle between 0 and 360 deg.
                 // Calculate Wind speed and direction, and train direction
                 // Update the value of the Wind Speed and Direction for the train
-                PhysicsWindDirectionDeg = MathHelper.ToDegrees(Simulator.Weather.WindDirection);
-                PhysicsWindSpeedMpS = Simulator.Weather.WindSpeed;
-                float TrainSpeedMpS = Math.Abs(SpeedMpS);
+            PhysicsWindDirectionDeg = MathHelper.ToDegrees(Simulator.Weather.WindInstantaneousDirectionRad);
+            PhysicsWindSpeedMpS = Simulator.Weather.WindInstantaneousSpeedMpS;
+            var speedMpS = Math.Abs(SpeedMpS);
 
                 // If a westerly direction (ie -ve) convert to an angle between 0 and 360
                 if (PhysicsWindDirectionDeg < 0)
@@ -2127,7 +2127,7 @@ public void UpdateWindComponents()
                 if (PhysicsTrainLocoDirectionDeg < 0)
                     PhysicsTrainLocoDirectionDeg += 360;
 
-                // calculate angle between train and eind direction
+            // Calculate angle between train and wind direction
                 if (PhysicsWindDirectionDeg > PhysicsTrainLocoDirectionDeg)
                     ResultantWindComponentDeg = PhysicsWindDirectionDeg - PhysicsTrainLocoDirectionDeg;
                 else if (PhysicsTrainLocoDirectionDeg > PhysicsWindDirectionDeg)
@@ -2143,9 +2143,8 @@ public void UpdateWindComponents()
                 if (ResultantWindComponentDeg > 180)
                     ResultantWindComponentDeg = 360 - ResultantWindComponentDeg;
 
-                float WindAngleRad = MathHelper.ToRadians(ResultantWindComponentDeg);
-
-                WindResultantSpeedMpS = (float)Math.Sqrt(TrainSpeedMpS * TrainSpeedMpS + PhysicsWindSpeedMpS * PhysicsWindSpeedMpS + 2.0f * TrainSpeedMpS * PhysicsWindSpeedMpS * (float)Math.Cos(WindAngleRad));
+            var windAngleRad = MathHelper.ToRadians(ResultantWindComponentDeg);
+            WindResultantSpeedMpS = (float)Math.Sqrt(speedMpS * speedMpS + PhysicsWindSpeedMpS * PhysicsWindSpeedMpS + 2.0f * speedMpS * PhysicsWindSpeedMpS * (float)Math.Cos(windAngleRad));
             }
 
 

Source/Orts.Simulation/Simulation/RollingStocks/MSTSLocomotive.cs

@@ -3136,7 +3136,7 @@ public virtual void UpdateFrictionCoefficient(float elapsedClockSeconds)
             {
                 var fogBaseFrictionCoefficientFactor = 1.0f;
                 var pricBaseFrictionCoefficientFactor = 1.0f;
-                float pric = Simulator.Weather.PricipitationIntensityPPSPM2 * 1000;
+                float pric = Simulator.Weather.PrecipitationIntensityPPSPM2 * 1000;
                 // precipitation will calculate a base coefficient value between 60% (light rain) and 90% (heavy rain) - this will be a factor that is used to adjust the base value 
                 // assume linear value between upper and lower precipitation values. Limits are set in the weather module, ie Rain = 0.01ppm (10) and Snow = 0.005ppm (5)
                 float precGrad = (0.2f - 0) / (10f - 5f);
@@ -3152,7 +3152,7 @@ public virtual void UpdateFrictionCoefficient(float elapsedClockSeconds)
                 }
 
                 // Adjust adhesion for impact of fog - default = 20000m = 20km
-                float fog = Simulator.Weather.FogDistance;
+                float fog = Simulator.Weather.VisibilityM;
                 if (fog < 20000) // as fog thickens then decrease adhesion
                 {
                     fogBaseFrictionCoefficientFactor = Math.Min((fog * 2.75e-4f + 0.6f), 1.0f); // If fog is less then 2km then it will impact friction, decrease adhesion to 60% (same as light rain transition)

Source/Orts.Simulation/Simulation/RollingStocks/MSTSWagon.cs

@@ -127,11 +127,6 @@ public class MSTSWagon : TrainCar
         float TenderWagonMaxCoalMassKG;
         float TenderWagonMaxWaterMassKG;
 
-        // Wind Impacts
-        float WagonDirectionDeg;
-        float WagonResultantWindComponentDeg;
-        float WagonWindResultantSpeedMpS;
-
         protected float FrictionC1; // MSTS Friction parameters
         protected float FrictionE1; // MSTS Friction parameters
         protected float FrictionV2; // MSTS Friction parameters
@@ -2879,130 +2874,129 @@ private void UpdateWindForce()
             // Lateral resistance - due to wheel flange being pushed against rail due to side wind.
             // Calculation based upon information provided in AREA 1942 Proceedings - https://archive.org/details/proceedingsofann431942amer - pg 56
 
-            if (!CarTunnelData.FrontPositionBeyondStartOfTunnel.HasValue && AbsSpeedMpS > 2.2352) // Only calculate wind resistance if option selected in options menu, and not in a tunnel, and speed is sufficient for wind effects (>5mph)
+            // Only calculate wind resistance if option selected in options menu, and not in a tunnel, and speed is sufficient for wind effects (>5mph)
+            if (!CarTunnelData.FrontPositionBeyondStartOfTunnel.HasValue && AbsSpeedMpS > 2.2352)
             {
-
                 // Wagon Direction
-                float direction = (float)Math.Atan2(WorldPosition.XNAMatrix.M13, WorldPosition.XNAMatrix.M11);
-                WagonDirectionDeg = MathHelper.ToDegrees((float)direction);
+                var directionRad = (float)Math.Atan2(WorldPosition.XNAMatrix.M13, WorldPosition.XNAMatrix.M11);
+                var directionDeg = MathHelper.ToDegrees(directionRad);
 
                 // If car is flipped, then the car's direction will be reversed by 180 compared to the rest of the train, and thus for calculation purposes only, 
                 // it is necessary to reverse the "assumed" direction of the car back again. This shouldn't impact the visual appearance of the car.
                 if (Flipped)
                 {
-                    WagonDirectionDeg += 180.0f; // Reverse direction of car
-                    if (WagonDirectionDeg > 360) // If this results in an angle greater then 360, then convert it back to an angle between 0 & 360.
-                    {
-                        WagonDirectionDeg -= 360;
-                    }
+                    // Reverse direction of car
+                    directionDeg += 180.0f;
+
+                    // If this results in an angle greater then 360, then convert it back to an angle between 0 & 360.
+                    if (directionDeg > 360)
+                        directionDeg -= 360;
                 }                   
 
                 // If a westerly direction (ie -ve) convert to an angle between 0 and 360
-                if (WagonDirectionDeg < 0)
-                    WagonDirectionDeg += 360;
-
-                float TrainSpeedMpS = Math.Abs(SpeedMpS);
+                if (directionDeg < 0)
+                    directionDeg += 360;
 
                 // Find angle between wind and direction of train
-                if (Train.PhysicsWindDirectionDeg > WagonDirectionDeg)
-                    WagonResultantWindComponentDeg = Train.PhysicsWindDirectionDeg - WagonDirectionDeg;
-                else if (WagonDirectionDeg > Train.PhysicsWindDirectionDeg)
-                    WagonResultantWindComponentDeg = WagonDirectionDeg - Train.PhysicsWindDirectionDeg;
-                else
-                    WagonResultantWindComponentDeg = 0.0f;
+                var resultantWindComponentDeg = 0.0f;
+                if (Train.PhysicsWindDirectionDeg > directionDeg)
+                    resultantWindComponentDeg = Train.PhysicsWindDirectionDeg - directionDeg;
+                else if (directionDeg > Train.PhysicsWindDirectionDeg)
+                    resultantWindComponentDeg = directionDeg - Train.PhysicsWindDirectionDeg;
 
                 // Correct wind direction if it is greater then 360 deg, then correct to a value less then 360
-                if (Math.Abs(WagonResultantWindComponentDeg) > 360)
-                    WagonResultantWindComponentDeg = WagonResultantWindComponentDeg - 360.0f;
+                if (Math.Abs(resultantWindComponentDeg) > 360)
+                    resultantWindComponentDeg -= 360.0f;
 
                 // Wind angle should be kept between 0 and 180 the formulas do not cope with angles > 180. If angle > 180, denotes wind of "other" side of train
-                if (WagonResultantWindComponentDeg > 180)
-                    WagonResultantWindComponentDeg = 360 - WagonResultantWindComponentDeg;
+                if (resultantWindComponentDeg > 180)
+                    resultantWindComponentDeg = 360 - resultantWindComponentDeg;
 
-                float ResultantWindComponentRad = MathHelper.ToRadians(WagonResultantWindComponentDeg);
+                var resultantWindComponentRad = MathHelper.ToRadians(resultantWindComponentDeg);
 
                 // Find the resultand wind vector for the combination of wind and train speed
-                WagonWindResultantSpeedMpS = (float)Math.Sqrt(TrainSpeedMpS * TrainSpeedMpS + Train.PhysicsWindSpeedMpS * Train.PhysicsWindSpeedMpS + 2.0f * TrainSpeedMpS * Train.PhysicsWindSpeedMpS * (float)Math.Cos(ResultantWindComponentRad));
+                var windResultantSpeedMpS = (float)Math.Sqrt(AbsSpeedMpS * AbsSpeedMpS + Train.PhysicsWindSpeedMpS * Train.PhysicsWindSpeedMpS + 2.0f * AbsSpeedMpS * Train.PhysicsWindSpeedMpS * (float)Math.Cos(resultantWindComponentRad));
 
                 // Calculate Drag Resistance
                 // The drag resistance will be the difference between the STILL firction calculated using the standard Davies equation, 
                 // and that produced using the wind resultant speed (combination of wind speed and train speed)
-                float TempStillDragResistanceForceN = AbsSpeedMpS * AbsSpeedMpS * DavisCNSSpMM;
-                float TempCombinedDragResistanceForceN = WagonWindResultantSpeedMpS * WagonWindResultantSpeedMpS * DavisCNSSpMM; // R3 of Davis formula taking into account wind
-                float WindDragResistanceForceN = 0.0f;
+                var tempStillDragResistanceForceN = AbsSpeedMpS * AbsSpeedMpS * DavisCNSSpMM;
+                var tempCombinedDragResistanceForceN = windResultantSpeedMpS * windResultantSpeedMpS * DavisCNSSpMM; // R3 of Davis formula taking into account wind
+                float windDragResistanceForceN;
 
                 // Find the difference between the Still and combined resistances
                 // This difference will be added or subtracted from the overall friction force depending upon the estimated wind direction.
-                // Wind typically headon to train - increase resistance - +ve differential
-                if (TempCombinedDragResistanceForceN > TempStillDragResistanceForceN)
+                if (tempCombinedDragResistanceForceN > tempStillDragResistanceForceN)
                 {
-                    WindDragResistanceForceN = TempCombinedDragResistanceForceN - TempStillDragResistanceForceN;
+                // Wind typically headon to train - increase resistance - +ve differential
+                    windDragResistanceForceN = tempCombinedDragResistanceForceN - tempStillDragResistanceForceN;
                 }
-                else // wind typically following train - reduce resistance - -ve differential
+                else
                 {
-                    WindDragResistanceForceN = TempStillDragResistanceForceN - TempCombinedDragResistanceForceN;
-                    WindDragResistanceForceN *= -1.0f;  // Convert to negative number to allow subtraction from ForceN
+                    // Wind typically following train - reduce resistance - -ve differential
+                    windDragResistanceForceN = tempStillDragResistanceForceN - tempCombinedDragResistanceForceN;
+                    windDragResistanceForceN *= -1.0f;  // Convert to negative number to allow subtraction from ForceN
                 }
 
                 // Calculate Lateral Resistance
 
                 // Calculate lateral resistance due to wind
                 // Resistance is due to the wheel flanges being pushed further onto rails when a cross wind is experienced by a train
-                float A = Train.PhysicsWindSpeedMpS / AbsSpeedMpS;
-                float C = (float)Math.Sqrt((1 + (A * A) + 2.0f * A * Math.Cos(ResultantWindComponentRad)));
-                float WindConstant = 8.25f;
-                float TrainSpeedMpH = Me.ToMi(pS.TopH(AbsSpeedMpS));
-                float WindSpeedMpH = Me.ToMi(pS.TopH(Train.PhysicsWindSpeedMpS));
+                var a = Train.PhysicsWindSpeedMpS / AbsSpeedMpS;
+                var c = (float)Math.Sqrt((1 + (a * a) + 2.0f * a * Math.Cos(resultantWindComponentRad)));
+                var windConstant = 8.25f;
+                var speedMpH = Me.ToMi(pS.TopH(AbsSpeedMpS));
 
-                float WagonFrontalAreaFt2 = Me2.ToFt2(WagonFrontalAreaM2);
+                var wagonFrontalAreaFt2 = Me2.ToFt2(WagonFrontalAreaM2);
 
-                LateralWindForceN = N.FromLbf(WindConstant * A * (float)Math.Sin(ResultantWindComponentRad) * DavisDragConstant * WagonFrontalAreaFt2 * TrainSpeedMpH * TrainSpeedMpH * C);
+                LateralWindForceN = N.FromLbf(windConstant * a * (float)Math.Sin(resultantWindComponentRad) * DavisDragConstant * wagonFrontalAreaFt2 * speedMpH * speedMpH * c);
 
-                float LateralWindResistanceForceN = N.FromLbf(WindConstant * A * (float)Math.Sin(ResultantWindComponentRad) * DavisDragConstant * WagonFrontalAreaFt2 * TrainSpeedMpH * TrainSpeedMpH * C * Train.WagonCoefficientFriction);
+                var lateralWindResistanceForceN = N.FromLbf(windConstant * a * (float)Math.Sin(resultantWindComponentRad) * DavisDragConstant * wagonFrontalAreaFt2 * speedMpH * speedMpH * c * Train.WagonCoefficientFriction);
 
                 // if this car is a locomotive, but not the lead one then recalculate the resistance with lower C value as drag will not be as high on trailing locomotives
                 if (WagonType == WagonTypes.Engine && Train.LeadLocomotive != this)
                 {
-                    LateralWindResistanceForceN *= TrailLocoResistanceFactor;
+                    lateralWindResistanceForceN *= TrailLocoResistanceFactor;
                 }
 
                 // Test to identify whether a tender is attached to the leading engine, if not then the resistance should also be derated as for the locomotive
-                bool IsLeadTender = false;
+                var isLeadTender = false;
                 if (WagonType == WagonTypes.Tender)
                 {
-                    bool PrevCarLead = false;
+                    var prevCarLead = false;
                     foreach (var car in Train.Cars)
                     {
                         // If this car is a tender and the previous car is the lead locomotive then set the flag so that resistance will be reduced
-                        if (car == this && PrevCarLead)
+                        if (car == this && prevCarLead)
                         {
-                            IsLeadTender = true;
+                            isLeadTender = true;
                             break;  // If the tender has been identified then break out of the loop, otherwise keep going until whole train is done.
                         }
+
                         // Identify whether car is a lead locomotive or not. This is kept for when the next iteration (next car) is checked.
                         if (Train.LeadLocomotive == car)
                         {
-                            PrevCarLead = true;
+                            prevCarLead = true;
                         }
                         else
                         {
-                            PrevCarLead = false;
+                            prevCarLead = false;
                         }
                     }
 
                     // If tender is coupled to a trailing locomotive then reduce resistance
-                    if (!IsLeadTender)
+                    if (!isLeadTender)
                     {
-                        LateralWindResistanceForceN *= TrailLocoResistanceFactor;
+                        lateralWindResistanceForceN *= TrailLocoResistanceFactor;
                     }
                 }
-                WindForceN = LateralWindResistanceForceN + WindDragResistanceForceN;
+
+                WindForceN = lateralWindResistanceForceN + windDragResistanceForceN;
             }
             else
             {
                 WindForceN = 0.0f; // Set to zero if wind resistance is not to be calculated
             }
-
         }
 
         private void UpdateTenderLoad()