Implement Display settings, UnitConversion class, bump 3.2.5.

Author: Tumppi066

ETS2LA.Overlay/AR/AR.cs

@@ -22,6 +22,8 @@ public class ARRenderer
     private int thisFrameWidth = 0;
     private int thisFrameHeight = 0;
 
+    private OverlaySettings overlaySettings;
+
     // These are all variables that are needed for
     // rendering ImGui windows in 3D space.
     private GL gl;
@@ -53,7 +55,16 @@ public ARRenderer(GL gl)
         cameraData = CameraProvider.Current.GetCurrentData();
         telemetryData = GameTelemetry.Current.GetCurrentData();
 
+        overlaySettings = OverlaySettingsHandler.Current.GetSettings();
+        OverlaySettingsHandler.Current.OnSettingsUpdated += OnOverlaySettingsUpdated;
+
         ImGui.SetCurrentContext(mainContext);
+
+    }
+
+    private void OnOverlaySettingsUpdated(OverlaySettings newSettings)
+    {
+        overlaySettings = newSettings;
     }
 
     /// <summary>
@@ -65,6 +76,7 @@ public void Render()
     {
         thisFrameProjection = default;
         thisFrameView = default;
+        GetViewMatrix();
 
         thisFrameWidth = (int)OverlayHandler.Current.OverlayWidth;
         thisFrameHeight = (int)OverlayHandler.Current.OverlayHeight;
@@ -185,12 +197,11 @@ public Matrix4x4 GetProjectionMatrix()
     }
 
     /// <summary>
-    ///  This function will return the world space coordinates of the provided ARCoordinate
-    ///  while also taking into account the coordinate center. Truck positions are interpolated
-    ///  to avoid jitter.
+    ///  This function will return the camera space coordinates of the provided ARCoordinate
+    ///  while also taking into account the coordinate center.
     /// </summary>
     /// <param name="coord">ARCoordinate to convert.</param>
-    /// <returns>World space coordinates.</returns>
+    /// <returns>camera space coordinates.</returns>
     /// <exception cref="ArgumentException"></exception>
     public Vector3 ARCoordinateToVector3(ARCoordinate coord)
     {
@@ -226,6 +237,22 @@ private uint ConvertColor(uint rgba)
             ((rgba & 0x000000FF) << 24); 
     }
 
+    private bool AllPointsOutsideRenderDistance(ARCoordinate[] points)
+    {
+        float maxDistance = overlaySettings.MaxARDistance;
+        Vector3 cameraPos = cameraData.position;
+
+        foreach (var point in points)
+        {
+            Vector3 worldPos = ARCoordinateToVector3(point);
+            float distance = Vector3.Distance(worldPos, cameraPos);
+            if (distance <= maxDistance)
+                return false;
+        }
+
+        return true;
+    }
+
     /// <summary>
     ///  Draw a line in 3D space. The line will be transformed and projected
     ///  onto the AR overlay.
@@ -236,6 +263,9 @@ private uint ConvertColor(uint rgba)
     /// <param name="thickness">Thickness of the line in pixels.</param>
     public void Draw3DLine(ARCoordinate start, ARCoordinate end, UInt32 color, float thickness = 1.0f)
     {
+        if (AllPointsOutsideRenderDistance(new ARCoordinate[] { start, end }))
+            return;
+        
         Vector2? p1 = WorldToScreen(ARCoordinateToVector3(start), thisFrameWidth, thisFrameHeight);
         Vector2? p2 = WorldToScreen(ARCoordinateToVector3(end), thisFrameWidth, thisFrameHeight);
 
@@ -257,6 +287,9 @@ public void Draw3DLine(ARCoordinate start, ARCoordinate end, UInt32 color, float
     /// <param name="thickness">The thickness of the circle outline.</param>
     public void Draw3DCircle(ARCoordinate center, float radius, UInt32 color, bool filled = false, float thickness = 1)
     {
+        if (AllPointsOutsideRenderDistance(new ARCoordinate[] { center }))
+            return;
+
         Vector2? centerScreen = WorldToScreen(ARCoordinateToVector3(center), thisFrameWidth, thisFrameHeight);
         if (!centerScreen.HasValue) 
             return;
@@ -282,6 +315,9 @@ public void Draw3DCircle(ARCoordinate center, float radius, UInt32 color, bool f
     /// <param name="thickness">The thickness of the polygon outline.</param>
     public void Draw3DPolygon(ARCoordinate[] points, UInt32 color, bool filled = false, float thickness = 1)
     {
+        if (AllPointsOutsideRenderDistance(points))
+            return;
+
         if (points == null || points.Length < 3)
             return;
 
@@ -328,6 +364,9 @@ public void Draw3DPolygon(ARCoordinate[] points, UInt32 color, bool filled = fal
     /// <param name="thickness">The thickness of a non filled quad.</param>
     public void Draw3DQuad(ARCoordinate p1, ARCoordinate p2, ARCoordinate p3, ARCoordinate p4, UInt32 color, bool filled = false, float thickness = 1)
     {
+        if (AllPointsOutsideRenderDistance(new ARCoordinate[] { p1, p2, p3, p4 }))
+            return;
+        
         Vector2? p1s = WorldToScreen(ARCoordinateToVector3(p1), thisFrameWidth, thisFrameHeight);
         Vector2? p2s = WorldToScreen(ARCoordinateToVector3(p2), thisFrameWidth, thisFrameHeight);
         Vector2? p3s = WorldToScreen(ARCoordinateToVector3(p3), thisFrameWidth, thisFrameHeight);
@@ -363,6 +402,9 @@ public void Draw3DQuad(ARCoordinate p1, ARCoordinate p2, ARCoordinate p3, ARCoor
     /// <param name="thickness">The thickness of a non filled triangle.</param>
     public void Draw3DTriangle(ARCoordinate p1, ARCoordinate p2, ARCoordinate p3, UInt32 color, bool filled = false, float thickness = 1)
     {
+        if (AllPointsOutsideRenderDistance(new ARCoordinate[] { p1, p2, p3 }))
+            return;
+
         Vector2? p1s = WorldToScreen(ARCoordinateToVector3(p1), thisFrameWidth, thisFrameHeight);
         Vector2? p2s = WorldToScreen(ARCoordinateToVector3(p2), thisFrameWidth, thisFrameHeight);
         Vector2? p3s = WorldToScreen(ARCoordinateToVector3(p3), thisFrameWidth, thisFrameHeight);
@@ -396,6 +438,9 @@ public void Draw3DTriangle(ARCoordinate p1, ARCoordinate p2, ARCoordinate p3, UI
     /// <param name="color"></param>
     public void Draw3DText(ARCoordinate position, string text, UInt32 color)
     {
+        if (AllPointsOutsideRenderDistance(new ARCoordinate[] { position }))
+            return;
+
         Vector2? screenPos = WorldToScreen(ARCoordinateToVector3(position), thisFrameWidth, thisFrameHeight);
         if (!screenPos.HasValue) return;
 
@@ -471,6 +516,12 @@ public void EndWindow(ARCoordinate center, Quaternion rotation, float width, boo
         // onto the main overlay background.
         ImGui.SetCurrentContext(oldContext);
 
+        if (AllPointsOutsideRenderDistance(new ARCoordinate[] { center }))
+        {
+            isWindowContextInitialized = false;
+            return;
+        }
+
         float windowAspectRatio = windowSize.Y / windowSize.X;
         float height = width * windowAspectRatio;
 

ETS2LA.Overlay/Overlay.cs

@@ -36,6 +36,7 @@ public class OverlayHandler
     };
 
     public ARRenderer AR;
+    private OverlaySettings overlaySettings;
 
     private bool isInteracting = false;
     private float bgOpacityTarget = 0.0f;
@@ -60,6 +61,8 @@ public OverlayHandler()
     {
         ControlsBackend.Current.RegisterControl(Interact);
         ControlsBackend.Current.On(Interact.Id, HandleInput);
+        overlaySettings = OverlaySettingsHandler.Current.GetSettings();
+        OverlaySettingsHandler.Current.OnSettingsUpdated += OnOverlaySettingsUpdated;
 
         Task.Run(() => RenderLoop());
 
@@ -69,6 +72,11 @@ public OverlayHandler()
         windows.Add(new StateWindow());
     }
 
+    private void OnOverlaySettingsUpdated(OverlaySettings newSettings)
+    {
+        overlaySettings = newSettings;
+    }
+
     private void HandleInput(object sender, ControlChangeEventArgs e)
     {
         bool b = (bool)e.NewValue;
@@ -100,6 +108,11 @@ private void RenderLoop()
 
         while (GLFW.WindowShouldClose(glfwWindow) == 0 && !shutdown)
         {
+            if (overlaySettings.LimitFramerate)
+                interval = 1000.0 / overlaySettings.MaxFramerate;
+            else
+                interval = 1000.0 / targetFramerate;
+
             start = fs.Elapsed.TotalMilliseconds;
             next += interval;
 
@@ -150,8 +163,8 @@ private void RenderLoop()
             // all other calls are just setup.
             Stopwatch ARStopwatch = Stopwatch.StartNew();
             try { 
-                if (AR == null) { AR = new ARRenderer(gl); }
-                AR.Render(); 
+                if (AR == null) AR = new ARRenderer(gl);
+                if (overlaySettings.RenderAR) AR.Render(); 
             }
             catch (Exception ex) {
                 Logger.Error($"Error in AR rendering: {ex}");

ETS2LA.Overlay/Settings.cs

@@ -0,0 +1,48 @@
+using ETS2LA.Settings;
+
+namespace ETS2LA.Overlay;
+
+[Serializable]
+public class OverlaySettings
+{
+    public bool LimitFramerate = true;
+    public int MaxFramerate = 30;
+
+    // AR
+    public bool RenderAR = true;
+    public float MaxARDistance = 150.0f;
+}
+
+public class OverlaySettingsHandler
+{
+    private static readonly Lazy<OverlaySettingsHandler> _instance = new(() => new OverlaySettingsHandler());
+    public static OverlaySettingsHandler Current => _instance.Value;
+
+    private SettingsHandler _settingsHandler;
+    private OverlaySettings _settings;
+
+    public event Action<OverlaySettings>? OnSettingsUpdated;
+
+    public OverlaySettingsHandler()
+    {
+        _settingsHandler = new SettingsHandler();
+        _settings = _settingsHandler.Load<OverlaySettings>("OverlaySettings.json");
+        _settingsHandler.RegisterListener<OverlaySettings>("OverlaySettings.json", OnSettingsChanged);
+    }
+
+    public void Save()
+    {
+        _settingsHandler.Save<OverlaySettings>("OverlaySettings.json", _settings);
+    }
+
+    public OverlaySettings GetSettings()
+    {
+        return _settings;
+    }
+
+    private void OnSettingsChanged(OverlaySettings overlaySettings)
+    {
+        _settings = overlaySettings;
+        OnSettingsUpdated?.Invoke(_settings);
+    }
+}

ETS2LA.Overlay/Window/StateWindow.cs

@@ -43,8 +43,11 @@ public StateWindow()
 
             DescriptionText("Pause Longitudinal Assist: "); ImGui.SameLine(); ColoredBoolean(ApplicationState.Current.PauseLongitudinalAssist, invert: true);
 
-            float speedInUnits = ApplicationState.Current.FromScientificUnits(ApplicationState.Current.DesiredSpeed);
-            DescriptionText("Desired Speed: "); ImGui.SameLine(); Text($"{ApplicationState.Current.DesiredSpeed:F1} m/s ({speedInUnits:F1} in {ApplicationState.Current.DisplayUnits})");
+            float speed = ApplicationState.Current.DesiredSpeed;
+            Units displayUnits = ApplicationState.Current.DisplayUnits;
+            float speedInUnits = UnitConversions.FromScientificUnits(UnitType.Speed, speed, displayUnits);
+            string unitAbbreviation = UnitConversions.GetUnitAbbreviation(UnitType.Speed, displayUnits);
+            DescriptionText("Desired Speed: "); ImGui.SameLine(); Text($"{speed:F1} m/s ({speedInUnits:F1} in {unitAbbreviation})");
 
             DescriptionText("Display Units: "); ImGui.SameLine(); Text(ApplicationState.Current.DisplayUnits.ToString());
         };

ETS2LA.State/Program.cs

@@ -22,13 +22,6 @@ public enum LongitudinalAssists
     AdaptiveCruiseControl
 }
 
-public enum Units
-{
-    Metric,
-    Imperial,
-    Scientific
-}
-
 /// <summary>
 ///  This state contains the most important ETS2LA variables. Most plugins
 ///  will use it to follow the user's preferences and read the game data.
@@ -50,6 +43,15 @@ public ApplicationState()
         ControlsBackend.Current.On(DefaultControls.Assist.Id, HandleAssist);
 
         assistanceSettings = AssistanceSettings.Current;
+
+        StateSettingsHandler.Current.OnSettingsChanged += HandleSettingsChanged;
+        HandleSettingsChanged(StateSettingsHandler.Current.GetSettings());
+    }
+
+    private void HandleSettingsChanged(StateSettings newStateSettings)
+    {
+        stateSettings = newStateSettings;
+        DisplayUnits = newStateSettings.DisplayUnits;
     }
 
     private void HandleTelemetryUpdate(GameTelemetryData data)
@@ -76,6 +78,7 @@ public void Shutdown()
     }
 
 
+
     // MARK: Self-Driving Related
     // NOTE: This class is organized by *category* and not variable/function type.
     //       This makes the most sense to avoid having lots of variables back to back
@@ -121,37 +124,14 @@ public void Shutdown()
     ///  is automatically changed by ETS2LA, either when the user sets it in the settings, or when we
     ///  detect a change in the game's units. This unit should determine the units used everywhere, e.g.
     ///  the units used when increasing and decreasing the target speed. (+-1 mph/kph/ms) <br/><br/>
-    ///  **Use FromScientificUnits and ToScientificUnits to convert values to and from the current display units.**
+    ///  **Use UnitConversions.FromScientificUnits and UnitConversions.ToScientificUnits to convert values to and from the current display units.**
     /// </summary>
     public Units DisplayUnits { get; set; } = Units.Metric;
 
     // Internal value to keep track of the latest telemetry we received.
     private GameTelemetryData latestTelemetryData = new();
     private AssistanceSettings assistanceSettings;
-
-    public float FromScientificUnits(float speedInMps, Units? overrideDisplayUnits = null)
-    {
-        var units = overrideDisplayUnits ?? DisplayUnits;
-        return units switch
-        {
-            Units.Metric => speedInMps * 3.6f,       // m/s to km/h
-            Units.Imperial => speedInMps * 2.23693f, // m/s to mph
-            Units.Scientific => speedInMps,          // m/s
-            _ => speedInMps
-        };
-    }
-
-    public float ToScientificUnits(float speedInDisplayUnits, Units? overrideDisplayUnits = null)
-    {
-        var units = overrideDisplayUnits ?? DisplayUnits;
-        return units switch
-        {
-            Units.Metric => speedInDisplayUnits / 3.6f,       // km/h to m/s
-            Units.Imperial => speedInDisplayUnits / 2.23693f, // mph to m/s
-            Units.Scientific => speedInDisplayUnits,          // m/s
-            _ => speedInDisplayUnits
-        };
-    }
+    private StateSettings stateSettings;
 
     // The functions below are for handling control events.
     // If determining what they do is hard via code, then take a look at the 
@@ -193,10 +173,10 @@ private void HandleIncrease(object sender, ControlChangeEventArgs e)
         switch (DisplayUnits)
         {
             case Units.Metric:
-                DesiredSpeed += ToScientificUnits(1.0f, Units.Metric); // 1 km/h in m/s
+                DesiredSpeed += UnitConversions.ToScientificUnits(UnitType.Speed, 1.0f, Units.Metric); // 1 km/h in m/s
                 break;
             case Units.Imperial:
-                DesiredSpeed += ToScientificUnits(1.0f, Units.Imperial); // 1 mph in m/s
+                DesiredSpeed += UnitConversions.ToScientificUnits(UnitType.Speed, 1.0f, Units.Imperial); // 1 mph in m/s
                 break;
             case Units.Scientific:
                 DesiredSpeed += 1f; // 1 m/s
@@ -219,10 +199,10 @@ private void HandleDecrease(object sender, ControlChangeEventArgs e)
         switch (DisplayUnits)
         {
             case Units.Metric:
-                DesiredSpeed -= ToScientificUnits(1.0f, Units.Metric); // 1 km/h in m/s
+                DesiredSpeed -= UnitConversions.ToScientificUnits(UnitType.Speed, 1.0f, Units.Metric); // 1 km/h in m/s
                 break;
             case Units.Imperial:
-                DesiredSpeed -= ToScientificUnits(1.0f, Units.Imperial); // 1 mph in m/s
+                DesiredSpeed -= UnitConversions.ToScientificUnits(UnitType.Speed, 1.0f, Units.Imperial); // 1 mph in m/s
                 break;
             case Units.Scientific:
                 DesiredSpeed -= 1f; // 1 m/s