Merge pull request #383 from YoRyan/antialiasing

Add a video options setting for MultiSampleCount anti-aliasing

Author: cjakeman

Source/Documentation/Manual/options.rst

@@ -367,6 +367,17 @@ Ambient daylight brightness
 
 With this slider you can set the daylight brightness.
 
+Anti-aliasing
+-------------
+
+Controls the anti-aliasing method used by Open Rails. Anti-aliasing is a
+computer graphics technique that smooths any harsh edges, otherwise known as
+"jaggies," present in the video image. Currently, Open Rails only supports the
+multisample anti-aliasing (MSAA) method. Higher applications of anti-aliasing
+will require exponentially more graphics computing power.
+
+The default setting is MSAA with 2x sampling.
+
 .. _options-simulation:
 
 Simulation Options

Source/Menu/Options.Designer.cs

@@ -179,6 +179,8 @@ public OptionsForm(UserSettings settings, UpdateManager updateManager, bool init
             comboWindowSize.Text = Settings.WindowSize;
             trackDayAmbientLight.Value = Settings.DayAmbientLight;
             trackDayAmbientLight_ValueChanged(null, null);
+            trackAntiAliasing.Value = Settings.AntiAliasing;
+            trackAntiAliasing_ValueChanged(null, null);
             checkDoubleWire.Checked = Settings.DoubleWire;
 
             // Simulation tab
@@ -467,6 +469,7 @@ void buttonOK_Click(object sender, EventArgs e)
 
             Settings.DayAmbientLight = (int)trackDayAmbientLight.Value;
             Settings.DoubleWire = checkDoubleWire.Checked;
+            Settings.AntiAliasing = trackAntiAliasing.Value;
 
             // Simulation tab
             Settings.SimpleControlPhysics = checkSimpleControlsPhysics.Checked;
@@ -627,6 +630,36 @@ private void trackDayAmbientLight_ValueChanged(object sender, EventArgs e)
             labelDayAmbientLight.Text = catalog.GetStringFmt("{0}%", trackDayAmbientLight.Value * 5);
         }
 
+        private void trackAntiAliasing_ValueChanged(object sender, EventArgs e)
+        {
+            string method;
+            switch ((UserSettings.AntiAliasingMethod)trackAntiAliasing.Value)
+            {
+                case UserSettings.AntiAliasingMethod.None:
+                    method = "Disabled";
+                    break;
+                case UserSettings.AntiAliasingMethod.MSAA2x:
+                    method = "2x MSAA";
+                    break;
+                case UserSettings.AntiAliasingMethod.MSAA4x:
+                    method = "4x MSAA";
+                    break;
+                case UserSettings.AntiAliasingMethod.MSAA8x:
+                    method = "8x MSAA";
+                    break;
+                case UserSettings.AntiAliasingMethod.MSAA16x:
+                    method = "16x MSAA";
+                    break;
+                case UserSettings.AntiAliasingMethod.MSAA32x:
+                    method = "32x MSAA";
+                    break;
+                default:
+                    method = "";
+                    break;
+            }
+            labelAntiAliasingValue.Text = method;
+        }
+
         private void trackLODBias_ValueChanged(object sender, EventArgs e)
         {
             if (trackLODBias.Value == -100)

Source/Menu/Options.cs

@@ -90,6 +90,37 @@ public enum Menu_SelectionIndex
         }
         #endregion
 
+        /// <summary>
+        /// Specifies an anti-aliasing method. Currently, Monogame's MSAA is the only supported method.
+        /// </summary>
+        public enum AntiAliasingMethod
+        {
+            /// <summary>
+            /// No antialiasing
+            /// </summary>
+            None = 1,
+            /// <summary>
+            /// 2x multisampling
+            /// </summary>
+            MSAA2x = 2,
+            /// <summary>
+            /// 4x multisampling
+            /// </summary>
+            MSAA4x = 3,
+            /// <summary>
+            /// 8x multisampling
+            /// </summary>
+            MSAA8x = 4,
+            /// <summary>
+            /// 16x multisampling
+            /// </summary>
+            MSAA16x = 5,
+            /// <summary>
+            /// 32x multisampling
+            /// </summary>
+            MSAA32x = 6,
+        }
+
         public enum DirectXFeature
         {
             Level9_1,
@@ -195,6 +226,8 @@ public enum DirectXFeature
         public string WindowSize { get; set; }
         [Default(20)]
         public int DayAmbientLight { get; set; }
+        [Default(AntiAliasingMethod.MSAA2x)]
+        public int AntiAliasing { get; set; }
 
         // Simulation settings:
 

Source/ORTS.Settings/UserSettings.cs

@@ -24,6 +24,7 @@
 using System;
 using System.Diagnostics;
 using System.Windows.Forms;
+using static ORTS.Settings.UserSettings;
 
 namespace Orts.Viewer3D.Processes
 {
@@ -98,7 +99,7 @@ internal RenderProcess(Game game)
             GraphicsDeviceManager.PreferredBackBufferFormat = SurfaceFormat.Color;
             GraphicsDeviceManager.PreferredDepthStencilFormat = DepthFormat.Depth24Stencil8;
             GraphicsDeviceManager.IsFullScreen = Game.Settings.FullScreen;
-            GraphicsDeviceManager.PreferMultiSampling = true;
+            GraphicsDeviceManager.PreferMultiSampling = (AntiAliasingMethod)Game.Settings.AntiAliasing != AntiAliasingMethod.None;
             GraphicsDeviceManager.HardwareModeSwitch = !Game.Settings.FastFullScreenAltTab;
             GraphicsDeviceManager.PreparingDeviceSettings += new EventHandler<PreparingDeviceSettingsEventArgs>(GDM_PreparingDeviceSettings);
         }
@@ -118,19 +119,38 @@ void GDM_PreparingDeviceSettings(object sender, PreparingDeviceSettingsEventArgs
 
             e.GraphicsDeviceInformation.GraphicsProfile = e.GraphicsDeviceInformation.Adapter.IsProfileSupported(GraphicsProfile.HiDef) ? GraphicsProfile.HiDef : GraphicsProfile.Reach;
 
-            // TODO: XNA defaults to lowest multisample anti-aliasing quality (2x), so we'll do the same here until we add a setting for it.
-            e.GraphicsDeviceInformation.PresentationParameters.MultiSampleCount = 2;
-
-            if (e.GraphicsDeviceInformation.PresentationParameters.IsFullScreen)
+            var pp = e.GraphicsDeviceInformation.PresentationParameters;
+            switch ((AntiAliasingMethod)Game.Settings.AntiAliasing)
+            {
+                case AntiAliasingMethod.None:
+                default:
+                    break;
+                case AntiAliasingMethod.MSAA2x:
+                    pp.MultiSampleCount = 2;
+                    break;
+                case AntiAliasingMethod.MSAA4x:
+                    pp.MultiSampleCount = 4;
+                    break;
+                case AntiAliasingMethod.MSAA8x:
+                    pp.MultiSampleCount = 8;
+                    break;
+                case AntiAliasingMethod.MSAA16x:
+                    pp.MultiSampleCount = 16;
+                    break;
+                case AntiAliasingMethod.MSAA32x:
+                    pp.MultiSampleCount = 32;
+                    break;
+            }
+            if (pp.IsFullScreen)
             {
                 var screen = Screen.FromControl(GameForm);
-                e.GraphicsDeviceInformation.PresentationParameters.BackBufferWidth = screen.Bounds.Width;
-                e.GraphicsDeviceInformation.PresentationParameters.BackBufferHeight = screen.Bounds.Height;
+                pp.BackBufferWidth = screen.Bounds.Width;
+                pp.BackBufferHeight = screen.Bounds.Height;
             }
             else
             {
-                e.GraphicsDeviceInformation.PresentationParameters.BackBufferWidth = GameWindowSize.X;
-                e.GraphicsDeviceInformation.PresentationParameters.BackBufferHeight = GameWindowSize.Y;
+                pp.BackBufferWidth = GameWindowSize.X;
+                pp.BackBufferHeight = GameWindowSize.Y;
             }
         }
 
@@ -141,7 +161,7 @@ internal void Start()
             DisplaySize = new Point(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height);
 
             // Validate that the DirectX feature level is one we understand
-            if (!Enum.IsDefined(typeof(ORTS.Settings.UserSettings.DirectXFeature), "Level" + Game.Settings.DirectXFeatureLevel))
+            if (!Enum.IsDefined(typeof(DirectXFeature), "Level" + Game.Settings.DirectXFeatureLevel))
                 Game.Settings.DirectXFeatureLevel = "";
 
             if (Game.Settings.DirectXFeatureLevel == "")
@@ -159,7 +179,7 @@ internal void Start()
             ShadowMapCount = Game.Settings.ShadowMapCount;
             if (!Game.Settings.DynamicShadows)
                 ShadowMapCount = 0;
-            else if ((ShadowMapCount > 1) && !Game.Settings.IsDirectXFeatureLevelIncluded(ORTS.Settings.UserSettings.DirectXFeature.Level9_3))
+            else if ((ShadowMapCount > 1) && !Game.Settings.IsDirectXFeatureLevelIncluded(DirectXFeature.Level9_3))
                 ShadowMapCount = 1;
             else if (ShadowMapCount < 0)
                 ShadowMapCount = 0;