Merge pull request #626 from cjakeman/timetable-progress-bar

Timetable loading bar added

Author: cjakeman

Source/Documentation/Manual/driving.rst

@@ -9,8 +9,20 @@ Game Loading
 
 Once you have pressed ``Start``, Open Rails loads and processes all the 
 data needed to run the game. During this phase, the route's splash screen 
-is shown. If the same session was loaded previously, a bar showing loading 
-progress is shown at the bottom of the display. During loading, if logging 
+is shown with an indicator bar at the bottom.
+
+.. image:: images/loading_bars.png
+
+The first time a session is loaded, an animated bar just shows activity. 
+Subsequent loads of that session show the bar growing across the screen to indicate
+progress.
+
+If a timetable has been selected, then the game also simulates the progress of the timetable
+from the first train in the timetable up to start time of the player's train.
+This is done at high speed, but may still take some time. A second bar appears
+above the first one to show the progress of this stage.
+
+During loading, if logging 
 is selected, the log file ``OpenRailsLog.txt`` will already begin storing 
 data.
 

Source/Documentation/Manual/images/loading_bars.png

@@ -374,6 +374,9 @@ private void PrerunAI(int playerTrainOriginalTrain, TTTrain.FormCommand playerTr
                 bool activeTrains = false;
                 for (double runTime = firstAITime; runTime < Simulator.ClockTime && !endPreRun; runTime += 5.0) // update with 5 secs interval
                 {
+                    var loaderSpan = (float)TimetableInfo.PlayerTrainOriginalStartTime - firstAITime;
+                    Simulator.TimetableLoadedFraction = ((float)runTime - firstAITime) / loaderSpan;
+
                     int fullsec = Convert.ToInt32(runTime);
                     if (fullsec % 3600 < 5) Trace.Write(" " + (fullsec / 3600).ToString("00") + ":00 ");
 

Source/Orts.Simulation/Simulation/AIs/AI.cs

@@ -252,6 +252,8 @@ public QueryCarViewerLoadedEventArgs(TrainCar car)
         public event System.EventHandler<QueryCarViewerLoadedEventArgs> QueryCarViewerLoaded;
         public event System.EventHandler RequestTTDetachWindow;
 
+        public float TimetableLoadedFraction = 0.0f;    // Set by AI.PrerunAI(), Get by GameStateRunActivity.Update()
+
         public Simulator(UserSettings settings, string activityPath, bool useOpenRailsDirectory)
         {
             Catalog = new GettextResourceManager("Orts.Simulation");

Source/Orts.Simulation/Simulation/Simulator.cs

@@ -80,6 +80,8 @@ private enum rowType
 
         public bool BinaryPaths = false;
 
+        public static int? PlayerTrainOriginalStartTime; // Set by TimetableInfo.ProcessTimetable() and read by AI.PrerunAI()
+
         //================================================================================================//
         /// <summary>
         ///  Constructor - empty constructor
@@ -171,7 +173,7 @@ public List<TTTrain> ProcessTimetable(string[] arguments, CancellationToken canc
                     addPathNoLoadFailure = playerTrain.ProcessDisposeInfo(ref trainList, null, simulator);
                     if (!addPathNoLoadFailure) loadPathNoFailure = false;
                 }
-
+                PlayerTrainOriginalStartTime = playerTrain.StartTime; // Saved here for use after playerTrain.StartTime gets changed.
                 reqPlayerTrain = InitializePlayerTrain(playerTrain, ref Paths, ref trainList);
                 simulator.TrainDictionary.Add(reqPlayerTrain.Number, reqPlayerTrain);
                 simulator.NameDictionary.Add(reqPlayerTrain.Name.ToLower(), reqPlayerTrain);

Source/Orts.Simulation/Simulation/Timetables/ProcessTimetable.cs

@@ -71,6 +71,7 @@ struct savedValues
         LoadingPrimitive Loading;
         LoadingScreenPrimitive LoadingScreen;
         LoadingBarPrimitive LoadingBar;
+        TimetableLoadingBarPrimitive TimetableLoadingBar;
         Matrix LoadingMatrix = Matrix.Identity;
 
         public GameStateRunActivity(string[] args)
@@ -83,6 +84,7 @@ internal override void Dispose()
             Loading.Dispose();
             LoadingScreen.Dispose();
             LoadingBar.Dispose();
+            TimetableLoadingBar.Dispose();
             base.Dispose();
         }
 
@@ -106,6 +108,14 @@ internal override void Update(RenderFrame frame, double totalRealSeconds)
                 frame.AddPrimitive(LoadingBar.Material, LoadingBar, RenderPrimitiveGroup.Overlay, ref LoadingMatrix);
             }
 
+            if (Simulator != null && Simulator.TimetableMode && TimetableLoadingBar != null 
+                && Simulator.TimetableLoadedFraction < 0.99f    // 0.99 to hide loading bar at end of timetable pre-run
+            )
+            {
+                TimetableLoadingBar.Material.Shader.LoadingPercent = Simulator.TimetableLoadedFraction;
+                frame.AddPrimitive(TimetableLoadingBar.Material, TimetableLoadingBar, RenderPrimitiveGroup.Overlay, ref LoadingMatrix);
+            }
+
             base.Update(frame, totalRealSeconds);
         }
 
@@ -116,7 +126,8 @@ internal override void Load()
                 Loading = new LoadingPrimitive(Game);
             if (LoadingBar == null)
                 LoadingBar = new LoadingBarPrimitive(Game);
-
+            if (TimetableLoadingBar == null)
+                TimetableLoadingBar = new TimetableLoadingBarPrimitive(Game);
             var args = Arguments;
 
             // Look for an action to perform.
@@ -1329,7 +1340,7 @@ protected override VertexPositionTexture[] GetVerticies(Game game)
 
         class LoadingBarPrimitive : LoadingPrimitive
         {
-            public LoadingBarPrimitive(Game game)
+            public LoadingBarPrimitive(Game game )
                 : base(game)
             {
             }
@@ -1341,17 +1352,42 @@ protected override LoadingMaterial GetMaterial(Game game)
 
             protected override VertexPositionTexture[] GetVerticies(Game game)
             {
-                var w = game.RenderProcess.DisplaySize.X;
-                var h = 10;
-                var x = -w / 2 - 0.5f;
-                var y = game.RenderProcess.DisplaySize.Y / 2 - h - 0.5f;
+                GetLoadingBarSize(game, out int w, out int h, out float x, out float y);
+                return GetLoadingBarCoords(w, h, x, y);
+            }
+
+            protected VertexPositionTexture[] GetLoadingBarCoords(int w, int h, float x, float y)
+            {
                 return new[] {
                     new VertexPositionTexture(new Vector3(x + 0, -y - 0, -1), new Vector2(0, 0)),
                     new VertexPositionTexture(new Vector3(x + w, -y - 0, -1), new Vector2(1, 0)),
                     new VertexPositionTexture(new Vector3(x + 0, -y - h, -1), new Vector2(0, 1)),
                     new VertexPositionTexture(new Vector3(x + w, -y - h, -1), new Vector2(1, 1)),
                 };
             }
+
+            protected static void GetLoadingBarSize(Game game, out int w, out int h, out float x, out float y)
+            {
+                w = game.RenderProcess.DisplaySize.X;
+                h = 10;
+                x = -w / 2 - 0.5f;
+                y = game.RenderProcess.DisplaySize.Y / 2 - h - 0.5f;
+            }
+        }
+
+        class TimetableLoadingBarPrimitive : LoadingBarPrimitive
+        {
+            public TimetableLoadingBarPrimitive(Game game)
+                : base(game)
+            {
+            }
+
+            protected override VertexPositionTexture[] GetVerticies(Game game)
+            {
+                GetLoadingBarSize(game, out int w, out int h, out float x, out float y);
+                y -= h + 1; // Allow for second bar and 1 pixel gap between
+                return GetLoadingBarCoords(w, h, x, y);
+            }
         }
 
         class LoadingMaterial : Material, IDisposable
@@ -1481,6 +1517,20 @@ public override void SetState(GraphicsDevice graphicsDevice, Material previousMa
             }
         }
 
+        class TimetableLoadingBarMaterial : LoadingMaterial
+        {
+            public TimetableLoadingBarMaterial(Game game)
+                : base(game)
+            {
+            }
+
+            public override void SetState(GraphicsDevice graphicsDevice, Material previousMaterial)
+            {
+                base.SetState(graphicsDevice, previousMaterial);
+                Shader.CurrentTechnique = Shader.Techniques["LoadingBar"];
+            }
+        }
+
         class LoadingShader : Shader
         {
             readonly EffectParameter worldViewProjection;