cleaning up GameRenderer

pandinocoder · pandinocoder · commit 561ccfb63994 · 2025-02-20T01:08:57.000+01:00
diff --git a/Intersect.Client.Core/Core/Graphics.cs b/Intersect.Client.Core/Core/Graphics.cs
@@ -552,15 +552,15 @@ public static void Render(TimeSpan deltaTime, TimeSpan totalTime)
             return;
         }
 
-        if (renderer.GetScreenWidth() != sOldWidth ||
-            renderer.GetScreenHeight() != sOldHeight ||
+        if (renderer.ScreenWidth != sOldWidth ||
+            renderer.ScreenHeight != sOldHeight ||
             renderer.DisplayModeChanged())
         {
             sDarknessTexture = null;
             Interface.Interface.DestroyGwen();
             Interface.Interface.InitGwen();
-            sOldWidth = renderer.GetScreenWidth();
-            sOldHeight = renderer.GetScreenHeight();
+            sOldWidth = renderer.ScreenWidth;
+            sOldHeight = renderer.ScreenHeight;
         }
 
         renderer.Clear(Color.Black);
@@ -811,22 +811,22 @@ public static void DrawFullScreenTexture(IGameTexture tex, float alpha = 1f)
             return;
         }
 
-        var bgx = Renderer.GetScreenWidth() / 2 - tex.Width / 2;
-        var bgy = Renderer.GetScreenHeight() / 2 - tex.Height / 2;
+        var bgx = Renderer.ScreenWidth / 2 - tex.Width / 2;
+        var bgy = Renderer.ScreenHeight / 2 - tex.Height / 2;
         var bgw = tex.Width;
         var bgh = tex.Height;
         int diff;
 
-        if (bgw < Renderer.GetScreenWidth())
+        if (bgw < Renderer.ScreenWidth)
         {
-            diff = Renderer.GetScreenWidth() - bgw;
+            diff = Renderer.ScreenWidth - bgw;
             bgx -= diff / 2;
             bgw += diff;
         }
 
-        if (bgh < Renderer.GetScreenHeight())
+        if (bgh < Renderer.ScreenHeight)
         {
-            diff = Renderer.GetScreenHeight() - bgh;
+            diff = Renderer.ScreenHeight - bgh;
             bgy -= diff / 2;
             bgh += diff;
         }
@@ -845,8 +845,8 @@ public static void DrawFullScreenTextureCentered(IGameTexture tex, float alpha =
             return;
         }
 
-        var bgx = Renderer.GetScreenWidth() / 2 - tex.Width / 2;
-        var bgy = Renderer.GetScreenHeight() / 2 - tex.Height / 2;
+        var bgx = Renderer.ScreenWidth / 2 - tex.Width / 2;
+        var bgy = Renderer.ScreenHeight / 2 - tex.Height / 2;
         var bgw = tex.Width;
         var bgh = tex.Height;
 
@@ -867,7 +867,7 @@ public static void DrawFullScreenTextureStretched(IGameTexture tex)
         DrawGameTexture(
             tex, GetSourceRect(tex),
             new FloatRect(
-                Renderer.GetView().X, Renderer.GetView().Y, Renderer.GetScreenWidth(), Renderer.GetScreenHeight()
+                Renderer.GetView().X, Renderer.GetView().Y, Renderer.ScreenWidth, Renderer.ScreenHeight
             ), Color.White
         );
     }
@@ -879,13 +879,13 @@ public static void DrawFullScreenTextureFitWidth(IGameTexture tex)
             return;
         }
 
-        var scale = Renderer.GetScreenWidth() / (float)tex.Width;
+        var scale = Renderer.ScreenWidth / (float)tex.Width;
         var scaledHeight = tex.Height * scale;
-        var offsetY = (Renderer.GetScreenHeight() - tex.Height) / 2f;
+        var offsetY = (Renderer.ScreenHeight - tex.Height) / 2f;
         DrawGameTexture(
             tex, GetSourceRect(tex),
             new FloatRect(
-                Renderer.GetView().X, Renderer.GetView().Y + offsetY, Renderer.GetScreenWidth(), scaledHeight
+                Renderer.GetView().X, Renderer.GetView().Y + offsetY, Renderer.ScreenWidth, scaledHeight
             ), Color.White
         );
     }
@@ -897,13 +897,13 @@ public static void DrawFullScreenTextureFitHeight(IGameTexture tex)
             return;
         }
 
-        var scale = Renderer.GetScreenHeight() / (float)tex.Height;
+        var scale = Renderer.ScreenHeight / (float)tex.Height;
         var scaledWidth = tex.Width * scale;
-        var offsetX = (Renderer.GetScreenWidth() - scaledWidth) / 2f;
+        var offsetX = (Renderer.ScreenWidth - scaledWidth) / 2f;
         DrawGameTexture(
             tex, GetSourceRect(tex),
             new FloatRect(
-                Renderer.GetView().X + offsetX, Renderer.GetView().Y, scaledWidth, Renderer.GetScreenHeight()
+                Renderer.GetView().X + offsetX, Renderer.GetView().Y, scaledWidth, Renderer.ScreenHeight
             ), Color.White
         );
     }
@@ -915,7 +915,7 @@ public static void DrawFullScreenTextureFitMinimum(IGameTexture tex)
             return;
         }
 
-        if (Renderer.GetScreenWidth() > Renderer.GetScreenHeight())
+        if (Renderer.ScreenWidth > Renderer.ScreenHeight)
         {
             DrawFullScreenTextureFitHeight(tex);
         }
@@ -932,7 +932,7 @@ public static void DrawFullScreenTextureFitMaximum(IGameTexture tex)
             return;
         }
 
-        if (Renderer.GetScreenWidth() < Renderer.GetScreenHeight())
+        if (Renderer.ScreenWidth < Renderer.ScreenHeight)
         {
             DrawFullScreenTextureFitHeight(tex);
         }
@@ -953,8 +953,8 @@ private static void UpdateView()
 
         if (Globals.GameState != GameStates.InGame || !MapInstance.TryGet(Globals.Me?.MapId ?? Guid.Empty, out var map))
         {
-            var sw = Renderer.GetScreenWidth();
-            var sh = Renderer.GetScreenHeight();
+            var sw = Renderer.ScreenWidth;
+            var sh = Renderer.ScreenHeight;
             var sx = 0;
             var sy = 0;
             CurrentView = new FloatRect(sx, sy, sw / scale, sh / scale);
@@ -1062,7 +1062,7 @@ private static void ClearDarknessTexture()
             return;
         }
 
-        sDarknessTexture ??= Renderer.CreateRenderTexture(Renderer.GetScreenWidth(), Renderer.GetScreenHeight());
+        sDarknessTexture ??= Renderer.CreateRenderTexture(Renderer.ScreenWidth, Renderer.ScreenHeight);
         sDarknessTexture.Clear(Color.Black);
     }
 
diff --git a/Intersect.Client.Core/Interface/Debugging/DebugWindow.cs b/Intersect.Client.Core/Interface/Debugging/DebugWindow.cs
@@ -314,7 +314,7 @@ private Table CreateGPUStatisticsTable(Base parent)
             scroller.MinimumSize = minimumSize;
         };
 
-        table.AddRow(Strings.Debug.Fps, name: "FPSRow").Listen(1, new DelegateDataProvider<int>(() => Graphics.Renderer.Fps), NoValue);
+        table.AddRow(Strings.Debug.Fps, name: "FPSRow").Listen(1, new DelegateDataProvider<int>(() => Graphics.Renderer.FPS), NoValue);
         // table.AddRow(Strings.Debug.Draws, name: "DrawsRow").Listen(1, new DelegateDataProvider<int>(() => Graphics.DrawCalls), NoValue);
 
         table.AddRow(Strings.Debug.MapsDrawn, name: "MapsDrawnRow").Listen(1, new DelegateDataProvider<int>(() => Graphics.MapsDrawn), NoValue);
@@ -717,7 +717,7 @@ private Table CreateInfoTableDebugStats(Base parent)
         };
         table.SizeChanged += ResizeTableToChildrenOnSizeChanged;
 
-        table.AddRow(Strings.Debug.Fps, name: "FPSRow").Listen(1, new DelegateDataProvider<int>(() => Graphics.Renderer.Fps), NoValue);
+        table.AddRow(Strings.Debug.Fps, name: "FPSRow").Listen(1, new DelegateDataProvider<int>(() => Graphics.Renderer.FPS), NoValue);
         table.AddRow(Strings.Debug.Draws, name: "DrawsRow").Listen(1, new DelegateDataProvider<int>(() => Graphics.DrawCalls), NoValue);
         table.AddRow(Strings.Debug.Ping, name: "PingRow").Listen(1, new DelegateDataProvider<int>(() => Networking.Network.Ping, delayMilliseconds: 5000), NoValue);
 
diff --git a/Intersect.Client.Core/Interface/Interface.cs b/Intersect.Client.Core/Interface/Interface.cs
@@ -167,8 +167,8 @@ public static void InitGwen()
         };
 
         _canvasMainMenu.SetSize(
-            (int)(Graphics.Renderer.GetScreenWidth() / _canvasMainMenu.Scale),
-            (int)(Graphics.Renderer.GetScreenHeight() / _canvasMainMenu.Scale)
+            (int)(Graphics.Renderer.ScreenWidth / _canvasMainMenu.Scale),
+            (int)(Graphics.Renderer.ScreenHeight / _canvasMainMenu.Scale)
         );
 
         _canvasMainMenu.ShouldDrawBackground = false;
@@ -180,8 +180,8 @@ public static void InitGwen()
 
         //_gameCanvas.Scale = (GameGraphics.Renderer.GetScreenWidth() / 1920f);
         _canvasInGame.SetSize(
-            (int)(Graphics.Renderer.GetScreenWidth() / _canvasInGame.Scale),
-            (int)(Graphics.Renderer.GetScreenHeight() / _canvasInGame.Scale)
+            (int)(Graphics.Renderer.ScreenWidth / _canvasInGame.Scale),
+            (int)(Graphics.Renderer.ScreenHeight / _canvasInGame.Scale)
         );
 
         _canvasInGame.ShouldDrawBackground = false;
diff --git a/Intersect.Client.Core/Interface/Shared/FPSPanel.cs b/Intersect.Client.Core/Interface/Shared/FPSPanel.cs
@@ -39,7 +39,7 @@ public FPSPanel(Base parent, string name = nameof(FPSPanel)) : base(parent: pare
 
         MinimumSize = Graphics.Renderer.MeasureText(Strings.General.FpsLabelFormat.ToString(10_000), font) + new Pointf(16, 8);
 
-        DelegateDataProvider<int> fpsProvider = new(() => Graphics.Renderer.Fps)
+        DelegateDataProvider<int> fpsProvider = new(() => Graphics.Renderer.FPS)
         {
             UserData = _label,
         };
diff --git a/Intersect.Client.Core/Interface/Shared/SettingsWindow.cs b/Intersect.Client.Core/Interface/Shared/SettingsWindow.cs
@@ -373,7 +373,7 @@ public SettingsWindow(Base parent) : base(parent: parent, title: Strings.Setting
             TextPadding = new Padding(8, 4, 0, 4),
         };
 
-        var availableVideoModes = Graphics.Renderer?.GetValidVideoModes().ToArray() ?? [];
+        var availableVideoModes = (Graphics.Renderer?.ValidVideoModes).ToArray() ?? [];
         for (var videoModeIndex = 0; videoModeIndex < availableVideoModes.Length; videoModeIndex++)
         {
             var availableVideoMode = availableVideoModes[videoModeIndex];
@@ -931,7 +931,7 @@ public void Show(Base? returnTo)
 
         // _uiScale.Value = Globals.Database.UIScale;
 
-        if (Graphics.Renderer?.GetValidVideoModes().Count > 0)
+        if ((Graphics.Renderer?.ValidVideoModes).Count > 0)
         {
             if (Graphics.Renderer.HasOverrideResolution)
             {
diff --git a/Intersect.Client.Core/Maps/MapInstance.cs b/Intersect.Client.Core/Maps/MapInstance.cs
@@ -1374,7 +1374,7 @@ public void DrawWeather()
                 var spawnTime = 25 + (int)(475 * (1f - WeatherIntensity / 100f));
                 spawnTime = (int)(spawnTime *
                                    (480000f /
-                                    (Graphics.Renderer.GetScreenWidth() * Graphics.Renderer.GetScreenHeight())));
+                                    (Graphics.Renderer.ScreenWidth * Graphics.Renderer.ScreenHeight)));
 
                 _weatherParticleSpawnTime = Timing.Global.MillisecondsUtc + spawnTime;
             }
diff --git a/Intersect.Client.Core/Maps/WeatherParticle.cs b/Intersect.Client.Core/Maps/WeatherParticle.cs
@@ -43,7 +43,7 @@ public partial class WeatherParticle : IWeatherParticle
     public WeatherParticle(List<IWeatherParticle> RemoveParticle, int xvelocity, int yvelocity, AnimationBase anim)
     {
         TransmittionTimer = Timing.Global.MillisecondsUtc;
-        bounds = new Rectangle(0, 0, Graphics.Renderer.GetScreenWidth(), Graphics.Renderer.GetScreenHeight());
+        bounds = new Rectangle(0, 0, Graphics.Renderer.ScreenWidth, Graphics.Renderer.ScreenHeight);
 
         xVelocity = xvelocity;
         yVelocity = yvelocity;
@@ -55,19 +55,19 @@ public WeatherParticle(List<IWeatherParticle> RemoveParticle, int xvelocity, int
         if (xVelocity > 0)
         {
             originalX = Globals.Random.Next(
-                -Graphics.Renderer.GetScreenWidth() / 4 - animSize.X,
-                Graphics.Renderer.GetScreenWidth() + animSize.X
+                -Graphics.Renderer.ScreenWidth / 4 - animSize.X,
+                Graphics.Renderer.ScreenWidth + animSize.X
             );
         }
         else if (xVelocity < 0)
         {
             originalX = Globals.Random.Next(
-                animSize.X, (int)(Graphics.Renderer.GetScreenWidth() * 1.25f) + animSize.X
+                animSize.X, (int)(Graphics.Renderer.ScreenWidth * 1.25f) + animSize.X
             );
         }
         else
         {
-            originalX = Globals.Random.Next(-animSize.X, Graphics.Renderer.GetScreenWidth() + animSize.X);
+            originalX = Globals.Random.Next(-animSize.X, Graphics.Renderer.ScreenWidth + animSize.X);
         }
 
         if (yVelocity > 0)
@@ -76,18 +76,18 @@ public WeatherParticle(List<IWeatherParticle> RemoveParticle, int xvelocity, int
         }
         else if (yVelocity < 0)
         {
-            originalY = Graphics.Renderer.GetScreenHeight() + animSize.Y;
+            originalY = Graphics.Renderer.ScreenHeight + animSize.Y;
         }
         else
         {
-            originalY = Globals.Random.Next(-animSize.Y, Graphics.Renderer.GetScreenHeight() + animSize.Y);
+            originalY = Globals.Random.Next(-animSize.Y, Graphics.Renderer.ScreenHeight + animSize.Y);
             if (xVelocity > 0)
             {
                 originalX = -animSize.X;
             }
             else if (xVelocity < 0)
             {
-                originalX = Graphics.Renderer.GetScreenWidth();
+                originalX = Graphics.Renderer.ScreenWidth;
             }
         }
 
@@ -103,12 +103,12 @@ public WeatherParticle(List<IWeatherParticle> RemoveParticle, int xvelocity, int
             bounds.Height += Math.Abs(originalY);
         }
 
-        if (originalY > Graphics.Renderer.GetScreenHeight())
+        if (originalY > Graphics.Renderer.ScreenHeight)
         {
             bounds.Height = originalY;
         }
 
-        if (originalX > Graphics.Renderer.GetScreenWidth())
+        if (originalX > Graphics.Renderer.ScreenWidth)
         {
             bounds.Width = originalX;
         }
diff --git a/Intersect.Client.Core/MonoGame/Graphics/MonoRenderer.cs b/Intersect.Client.Core/MonoGame/Graphics/MonoRenderer.cs
diff --git a/Intersect.Client.Framework/Graphics/GameRenderer.cs b/Intersect.Client.Framework/Graphics/GameRenderer.cs
diff --git a/Intersect.Client.Framework/Graphics/IGameRenderer.cs b/Intersect.Client.Framework/Graphics/IGameRenderer.cs

Original file line number	Diff line number	Diff line change
`@@ -552,15 +552,15 @@ public static void Render(TimeSpan deltaTime, TimeSpan totalTime)`
`552`	`552`	`return;`
`553`	`553`	`}`
`554`	`554`
`555`		`- if (renderer.GetScreenWidth() != sOldWidth \|\|`
`556`		`- renderer.GetScreenHeight() != sOldHeight \|\|`
	`555`	`+ if (renderer.ScreenWidth != sOldWidth \|\|`
	`556`	`+ renderer.ScreenHeight != sOldHeight \|\|`
`557`	`557`	`renderer.DisplayModeChanged())`
`558`	`558`	`{`
`559`	`559`	`sDarknessTexture = null;`
`560`	`560`	`Interface.Interface.DestroyGwen();`
`561`	`561`	`Interface.Interface.InitGwen();`
`562`		`- sOldWidth = renderer.GetScreenWidth();`
`563`		`- sOldHeight = renderer.GetScreenHeight();`
	`562`	`+ sOldWidth = renderer.ScreenWidth;`
	`563`	`+ sOldHeight = renderer.ScreenHeight;`
`564`	`564`	`}`
`565`	`565`
`566`	`566`	`renderer.Clear(Color.Black);`
`@@ -811,22 +811,22 @@ public static void DrawFullScreenTexture(IGameTexture tex, float alpha = 1f)`
`811`	`811`	`return;`
`812`	`812`	`}`
`813`	`813`
`814`		`- var bgx = Renderer.GetScreenWidth() / 2 - tex.Width / 2;`
`815`		`- var bgy = Renderer.GetScreenHeight() / 2 - tex.Height / 2;`
	`814`	`+ var bgx = Renderer.ScreenWidth / 2 - tex.Width / 2;`
	`815`	`+ var bgy = Renderer.ScreenHeight / 2 - tex.Height / 2;`
`816`	`816`	`var bgw = tex.Width;`
`817`	`817`	`var bgh = tex.Height;`
`818`	`818`	`int diff;`
`819`	`819`
`820`		`- if (bgw < Renderer.GetScreenWidth())`
	`820`	`+ if (bgw < Renderer.ScreenWidth)`
`821`	`821`	`{`
`822`		`- diff = Renderer.GetScreenWidth() - bgw;`
	`822`	`+ diff = Renderer.ScreenWidth - bgw;`
`823`	`823`	`bgx -= diff / 2;`
`824`	`824`	`bgw += diff;`
`825`	`825`	`}`
`826`	`826`
`827`		`- if (bgh < Renderer.GetScreenHeight())`
	`827`	`+ if (bgh < Renderer.ScreenHeight)`
`828`	`828`	`{`
`829`		`- diff = Renderer.GetScreenHeight() - bgh;`
	`829`	`+ diff = Renderer.ScreenHeight - bgh;`
`830`	`830`	`bgy -= diff / 2;`
`831`	`831`	`bgh += diff;`
`832`	`832`	`}`
`@@ -845,8 +845,8 @@ public static void DrawFullScreenTextureCentered(IGameTexture tex, float alpha =`
`845`	`845`	`return;`
`846`	`846`	`}`
`847`	`847`
`848`		`- var bgx = Renderer.GetScreenWidth() / 2 - tex.Width / 2;`
`849`		`- var bgy = Renderer.GetScreenHeight() / 2 - tex.Height / 2;`
	`848`	`+ var bgx = Renderer.ScreenWidth / 2 - tex.Width / 2;`
	`849`	`+ var bgy = Renderer.ScreenHeight / 2 - tex.Height / 2;`
`850`	`850`	`var bgw = tex.Width;`
`851`	`851`	`var bgh = tex.Height;`
`852`	`852`
`@@ -867,7 +867,7 @@ public static void DrawFullScreenTextureStretched(IGameTexture tex)`
`867`	`867`	`DrawGameTexture(`
`868`	`868`	`tex, GetSourceRect(tex),`
`869`	`869`	`new FloatRect(`
`870`		`- Renderer.GetView().X, Renderer.GetView().Y, Renderer.GetScreenWidth(), Renderer.GetScreenHeight()`
	`870`	`+ Renderer.GetView().X, Renderer.GetView().Y, Renderer.ScreenWidth, Renderer.ScreenHeight`
`871`	`871`	`), Color.White`
`872`	`872`	`);`
`873`	`873`	`}`
`@@ -879,13 +879,13 @@ public static void DrawFullScreenTextureFitWidth(IGameTexture tex)`
`879`	`879`	`return;`
`880`	`880`	`}`
`881`	`881`
`882`		`- var scale = Renderer.GetScreenWidth() / (float)tex.Width;`
	`882`	`+ var scale = Renderer.ScreenWidth / (float)tex.Width;`
`883`	`883`	`var scaledHeight = tex.Height * scale;`
`884`		`- var offsetY = (Renderer.GetScreenHeight() - tex.Height) / 2f;`
	`884`	`+ var offsetY = (Renderer.ScreenHeight - tex.Height) / 2f;`
`885`	`885`	`DrawGameTexture(`
`886`	`886`	`tex, GetSourceRect(tex),`
`887`	`887`	`new FloatRect(`
`888`		`- Renderer.GetView().X, Renderer.GetView().Y + offsetY, Renderer.GetScreenWidth(), scaledHeight`
	`888`	`+ Renderer.GetView().X, Renderer.GetView().Y + offsetY, Renderer.ScreenWidth, scaledHeight`
`889`	`889`	`), Color.White`
`890`	`890`	`);`
`891`	`891`	`}`
`@@ -897,13 +897,13 @@ public static void DrawFullScreenTextureFitHeight(IGameTexture tex)`
`897`	`897`	`return;`
`898`	`898`	`}`
`899`	`899`
`900`		`- var scale = Renderer.GetScreenHeight() / (float)tex.Height;`
	`900`	`+ var scale = Renderer.ScreenHeight / (float)tex.Height;`
`901`	`901`	`var scaledWidth = tex.Width * scale;`
`902`		`- var offsetX = (Renderer.GetScreenWidth() - scaledWidth) / 2f;`
	`902`	`+ var offsetX = (Renderer.ScreenWidth - scaledWidth) / 2f;`
`903`	`903`	`DrawGameTexture(`
`904`	`904`	`tex, GetSourceRect(tex),`
`905`	`905`	`new FloatRect(`
`906`		`- Renderer.GetView().X + offsetX, Renderer.GetView().Y, scaledWidth, Renderer.GetScreenHeight()`
	`906`	`+ Renderer.GetView().X + offsetX, Renderer.GetView().Y, scaledWidth, Renderer.ScreenHeight`
`907`	`907`	`), Color.White`
`908`	`908`	`);`
`909`	`909`	`}`
`@@ -915,7 +915,7 @@ public static void DrawFullScreenTextureFitMinimum(IGameTexture tex)`
`915`	`915`	`return;`
`916`	`916`	`}`
`917`	`917`
`918`		`- if (Renderer.GetScreenWidth() > Renderer.GetScreenHeight())`
	`918`	`+ if (Renderer.ScreenWidth > Renderer.ScreenHeight)`
`919`	`919`	`{`
`920`	`920`	`DrawFullScreenTextureFitHeight(tex);`
`921`	`921`	`}`
`@@ -932,7 +932,7 @@ public static void DrawFullScreenTextureFitMaximum(IGameTexture tex)`
`932`	`932`	`return;`
`933`	`933`	`}`
`934`	`934`
`935`		`- if (Renderer.GetScreenWidth() < Renderer.GetScreenHeight())`
	`935`	`+ if (Renderer.ScreenWidth < Renderer.ScreenHeight)`
`936`	`936`	`{`
`937`	`937`	`DrawFullScreenTextureFitHeight(tex);`
`938`	`938`	`}`
`@@ -953,8 +953,8 @@ private static void UpdateView()`
`953`	`953`
`954`	`954`	`if (Globals.GameState != GameStates.InGame \|\| !MapInstance.TryGet(Globals.Me?.MapId ?? Guid.Empty, out var map))`
`955`	`955`	`{`
`956`		`- var sw = Renderer.GetScreenWidth();`
`957`		`- var sh = Renderer.GetScreenHeight();`
	`956`	`+ var sw = Renderer.ScreenWidth;`
	`957`	`+ var sh = Renderer.ScreenHeight;`
`958`	`958`	`var sx = 0;`
`959`	`959`	`var sy = 0;`
`960`	`960`	`CurrentView = new FloatRect(sx, sy, sw / scale, sh / scale);`
`@@ -1062,7 +1062,7 @@ private static void ClearDarknessTexture()`
`1062`	`1062`	`return;`
`1063`	`1063`	`}`
`1064`	`1064`
`1065`		`- sDarknessTexture ??= Renderer.CreateRenderTexture(Renderer.GetScreenWidth(), Renderer.GetScreenHeight());`
	`1065`	`+ sDarknessTexture ??= Renderer.CreateRenderTexture(Renderer.ScreenWidth, Renderer.ScreenHeight);`
`1066`	`1066`	`sDarknessTexture.Clear(Color.Black);`
`1067`	`1067`	`}`
`1068`	`1068`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ public FPSPanel(Base parent, string name = nameof(FPSPanel)) : base(parent: pare`
`39`	`39`
`40`	`40`	`MinimumSize = Graphics.Renderer.MeasureText(Strings.General.FpsLabelFormat.ToString(10_000), font) + new Pointf(16, 8);`
`41`	`41`
`42`		`- DelegateDataProvider<int> fpsProvider = new(() => Graphics.Renderer.Fps)`
	`42`	`+ DelegateDataProvider<int> fpsProvider = new(() => Graphics.Renderer.FPS)`
`43`	`43`	`{`
`44`	`44`	`UserData = _label,`
`45`	`45`	`};`
Original file line number	Diff line number	Diff line change
`@@ -373,7 +373,7 @@ public SettingsWindow(Base parent) : base(parent: parent, title: Strings.Setting`
`373`	`373`	`TextPadding = new Padding(8, 4, 0, 4),`
`374`	`374`	`};`
`375`	`375`
`376`		`- var availableVideoModes = Graphics.Renderer?.GetValidVideoModes().ToArray() ?? [];`
	`376`	`+ var availableVideoModes = (Graphics.Renderer?.ValidVideoModes).ToArray() ?? [];`
`377`	`377`	`for (var videoModeIndex = 0; videoModeIndex < availableVideoModes.Length; videoModeIndex++)`
`378`	`378`	`{`
`379`	`379`	`var availableVideoMode = availableVideoModes[videoModeIndex];`
`@@ -931,7 +931,7 @@ public void Show(Base? returnTo)`
`931`	`931`
`932`	`932`	`// _uiScale.Value = Globals.Database.UIScale;`
`933`	`933`
`934`		`- if (Graphics.Renderer?.GetValidVideoModes().Count > 0)`
	`934`	`+ if ((Graphics.Renderer?.ValidVideoModes).Count > 0)`
`935`	`935`	`{`
`936`	`936`	`if (Graphics.Renderer.HasOverrideResolution)`
`937`	`937`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1374,7 +1374,7 @@ public void DrawWeather()`
`1374`	`1374`	`var spawnTime = 25 + (int)(475 * (1f - WeatherIntensity / 100f));`
`1375`	`1375`	`spawnTime = (int)(spawnTime *`
`1376`	`1376`	`(480000f /`
`1377`		`- (Graphics.Renderer.GetScreenWidth() * Graphics.Renderer.GetScreenHeight())));`
	`1377`	`+ (Graphics.Renderer.ScreenWidth * Graphics.Renderer.ScreenHeight)));`
`1378`	`1378`
`1379`	`1379`	`_weatherParticleSpawnTime = Timing.Global.MillisecondsUtc + spawnTime;`
`1380`	`1380`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public partial class WeatherParticle : IWeatherParticle`
`43`	`43`	`public WeatherParticle(List<IWeatherParticle> RemoveParticle, int xvelocity, int yvelocity, AnimationBase anim)`
`44`	`44`	`{`
`45`	`45`	`TransmittionTimer = Timing.Global.MillisecondsUtc;`
`46`		`- bounds = new Rectangle(0, 0, Graphics.Renderer.GetScreenWidth(), Graphics.Renderer.GetScreenHeight());`
	`46`	`+ bounds = new Rectangle(0, 0, Graphics.Renderer.ScreenWidth, Graphics.Renderer.ScreenHeight);`
`47`	`47`
`48`	`48`	`xVelocity = xvelocity;`
`49`	`49`	`yVelocity = yvelocity;`
`@@ -55,19 +55,19 @@ public WeatherParticle(List<IWeatherParticle> RemoveParticle, int xvelocity, int`
`55`	`55`	`if (xVelocity > 0)`
`56`	`56`	`{`
`57`	`57`	`originalX = Globals.Random.Next(`
`58`		`- -Graphics.Renderer.GetScreenWidth() / 4 - animSize.X,`
`59`		`- Graphics.Renderer.GetScreenWidth() + animSize.X`
	`58`	`+ -Graphics.Renderer.ScreenWidth / 4 - animSize.X,`
	`59`	`+ Graphics.Renderer.ScreenWidth + animSize.X`
`60`	`60`	`);`
`61`	`61`	`}`
`62`	`62`	`else if (xVelocity < 0)`
`63`	`63`	`{`
`64`	`64`	`originalX = Globals.Random.Next(`
`65`		`- animSize.X, (int)(Graphics.Renderer.GetScreenWidth() * 1.25f) + animSize.X`
	`65`	`+ animSize.X, (int)(Graphics.Renderer.ScreenWidth * 1.25f) + animSize.X`
`66`	`66`	`);`
`67`	`67`	`}`
`68`	`68`	`else`
`69`	`69`	`{`
`70`		`- originalX = Globals.Random.Next(-animSize.X, Graphics.Renderer.GetScreenWidth() + animSize.X);`
	`70`	`+ originalX = Globals.Random.Next(-animSize.X, Graphics.Renderer.ScreenWidth + animSize.X);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`if (yVelocity > 0)`
`@@ -76,18 +76,18 @@ public WeatherParticle(List<IWeatherParticle> RemoveParticle, int xvelocity, int`
`76`	`76`	`}`
`77`	`77`	`else if (yVelocity < 0)`
`78`	`78`	`{`
`79`		`- originalY = Graphics.Renderer.GetScreenHeight() + animSize.Y;`
	`79`	`+ originalY = Graphics.Renderer.ScreenHeight + animSize.Y;`
`80`	`80`	`}`
`81`	`81`	`else`
`82`	`82`	`{`
`83`		`- originalY = Globals.Random.Next(-animSize.Y, Graphics.Renderer.GetScreenHeight() + animSize.Y);`
	`83`	`+ originalY = Globals.Random.Next(-animSize.Y, Graphics.Renderer.ScreenHeight + animSize.Y);`
`84`	`84`	`if (xVelocity > 0)`
`85`	`85`	`{`
`86`	`86`	`originalX = -animSize.X;`
`87`	`87`	`}`
`88`	`88`	`else if (xVelocity < 0)`
`89`	`89`	`{`
`90`		`- originalX = Graphics.Renderer.GetScreenWidth();`
	`90`	`+ originalX = Graphics.Renderer.ScreenWidth;`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`@@ -103,12 +103,12 @@ public WeatherParticle(List<IWeatherParticle> RemoveParticle, int xvelocity, int`
`103`	`103`	`bounds.Height += Math.Abs(originalY);`
`104`	`104`	`}`
`105`	`105`
`106`		`- if (originalY > Graphics.Renderer.GetScreenHeight())`
	`106`	`+ if (originalY > Graphics.Renderer.ScreenHeight)`
`107`	`107`	`{`
`108`	`108`	`bounds.Height = originalY;`
`109`	`109`	`}`
`110`	`110`
`111`		`- if (originalX > Graphics.Renderer.GetScreenWidth())`
	`111`	`+ if (originalX > Graphics.Renderer.ScreenWidth)`
`112`	`112`	`{`
`113`	`113`	`bounds.Width = originalX;`
`114`	`114`	`}`