Improve shader handling

TeamFluXis · Jul 14, 2024 · 64477ac · 64477ac
1 parent 063d0ad
commit 64477ac
Show file tree

Hide file tree

Showing 14 changed files with 93 additions and 209 deletions.
diff --git a/fluXis.Game/Graphics/Shaders/Bloom/BloomContainer.cs b/fluXis.Game/Graphics/Shaders/Bloom/BloomContainer.cs
@@ -1,3 +1,4 @@
+using fluXis.Game.Map.Events;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 
@@ -6,8 +7,7 @@ namespace fluXis.Game.Graphics.Shaders.Bloom;
 public partial class BloomContainer : ShaderContainer
 {
     protected override string FragmentShader => "Blur";
-
-    public float Strength { get; set; } = 0;
+    public override ShaderType Type => ShaderType.Bloom;
 
     public BloomContainer()
     {

diff --git a/fluXis.Game/Graphics/Shaders/Chromatic/ChromaticContainer.cs b/fluXis.Game/Graphics/Shaders/Chromatic/ChromaticContainer.cs
@@ -1,14 +1,11 @@
+using fluXis.Game.Map.Events;
 using osu.Framework.Graphics;
 
 namespace fluXis.Game.Graphics.Shaders.Chromatic;
 
 public partial class ChromaticContainer : ShaderContainer
 {
     protected override string FragmentShader => "ChromaticAberration";
+    public override ShaderType Type => ShaderType.Chromatic;
     protected override DrawNode CreateShaderDrawNode() => new ChromaticContainerDrawNode(this, SharedData);
-
-    /// <summary>
-    /// The strength of the chromatic aberration effect. In pixels.
-    /// </summary>
-    public float Strength { get; set; }
 }
diff --git a/fluXis.Game/Graphics/Shaders/Greyscale/GreyscaleContainer.cs b/fluXis.Game/Graphics/Shaders/Greyscale/GreyscaleContainer.cs
@@ -1,14 +1,11 @@
+using fluXis.Game.Map.Events;
 using osu.Framework.Graphics;
 
 namespace fluXis.Game.Graphics.Shaders.Greyscale;
 
 public partial class GreyscaleContainer : ShaderContainer
 {
     protected override string FragmentShader => "Greyscale";
+    public override ShaderType Type => ShaderType.Greyscale;
     protected override DrawNode CreateShaderDrawNode() => new GreyscaleDrawNode(this, SharedData);
-
-    /// <summary>
-    /// The strength of the greyscale effect. From 0 to 1.
-    /// </summary>
-    public float Strength { get; set; }
 }
diff --git a/fluXis.Game/Graphics/Shaders/Invert/InvertContainer.cs b/fluXis.Game/Graphics/Shaders/Invert/InvertContainer.cs
@@ -1,14 +1,11 @@
+using fluXis.Game.Map.Events;
 using osu.Framework.Graphics;
 
 namespace fluXis.Game.Graphics.Shaders.Invert;
 
 public partial class InvertContainer : ShaderContainer
 {
     protected override string FragmentShader => "Invert";
+    public override ShaderType Type => ShaderType.Invert;
     protected override DrawNode CreateShaderDrawNode() => new InvertContainerDrawNode(this, SharedData);
-
-    /// <summary>
-    /// The strength of the invert effect. From 0 to 1.
-    /// </summary>
-    public float Strength { get; set; }
 }
diff --git a/fluXis.Game/Graphics/Shaders/Mosaic/MosaicContainer.cs b/fluXis.Game/Graphics/Shaders/Mosaic/MosaicContainer.cs
@@ -1,29 +1,11 @@
+using fluXis.Game.Map.Events;
 using osu.Framework.Graphics;
 
 namespace fluXis.Game.Graphics.Shaders.Mosaic;
 
 public partial class MosaicContainer : ShaderContainer
 {
     protected override string FragmentShader => "Mosaic";
+    public override ShaderType Type => ShaderType.Mosaic;
     protected override DrawNode CreateShaderDrawNode() => new MosaicDrawNode(this, SharedData);
-
-    private float strength;
-
-    /// <summary>
-    /// The strength of the mosaic effect. From 0 to 1.
-    /// <br/>
-    /// 0 means its full resolution, 1 means its 1x1 pixel.
-    /// </summary>
-    public float Strength
-    {
-        get => strength;
-        set
-        {
-            if (value == strength)
-                return;
-
-            strength = value;
-            Invalidate(Invalidation.DrawNode);
-        }
-    }
 }
diff --git a/fluXis.Game/Graphics/Shaders/Noise/NoiseContainer.cs b/fluXis.Game/Graphics/Shaders/Noise/NoiseContainer.cs
@@ -1,14 +1,11 @@
+using fluXis.Game.Map.Events;
 using osu.Framework.Graphics;
 
 namespace fluXis.Game.Graphics.Shaders.Noise;
 
 public partial class NoiseContainer : ShaderContainer
 {
     protected override string FragmentShader => "Noise";
+    public override ShaderType Type => ShaderType.Noise;
     protected override DrawNode CreateShaderDrawNode() => new NoiseContainerDrawNode(this, SharedData);
-
-    /// <summary>
-    /// The strength of the invert effect. From 0 to 1.
-    /// </summary>
-    public float Strength { get; set; }
 }
diff --git a/fluXis.Game/Graphics/Shaders/Retro/RetroContainer.cs b/fluXis.Game/Graphics/Shaders/Retro/RetroContainer.cs
@@ -1,14 +1,11 @@
+using fluXis.Game.Map.Events;
 using osu.Framework.Graphics;
 
 namespace fluXis.Game.Graphics.Shaders.Retro;
 
 public partial class RetroContainer : ShaderContainer
 {
     protected override string FragmentShader => "Retro";
+    public override ShaderType Type => ShaderType.Retro;
     protected override DrawNode CreateShaderDrawNode() => new RetroContainerDrawNode(this, SharedData);
-
-    /// <summary>
-    /// The strength of the invert effect. From 0 to 1.
-    /// </summary>
-    public float Strength { get; set; }
 }
diff --git a/fluXis.Game/Graphics/Shaders/ShaderContainer.cs b/fluXis.Game/Graphics/Shaders/ShaderContainer.cs
@@ -1,3 +1,4 @@
+using fluXis.Game.Map.Events;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -14,8 +15,29 @@ public abstract partial class ShaderContainer : Container, IBufferedDrawable
 {
     protected virtual string VertexShader => VertexShaderDescriptor.TEXTURE_2;
     protected abstract string FragmentShader { get; }
+    public abstract ShaderType Type { get; }
     protected abstract DrawNode CreateShaderDrawNode();
 
+    private float strength;
+
+    /// <summary>
+    /// The strength of the mosaic effect. From 0 to 1.
+    /// <br/>
+    /// 0 means its full resolution, 1 means its 1x1 pixel.
+    /// </summary>
+    public float Strength
+    {
+        get => strength;
+        set
+        {
+            if (value == strength)
+                return;
+
+            strength = value;
+            Invalidate(Invalidation.DrawNode);
+        }
+    }
+
     public bool DrawOriginal { get; set; }
     public ColourInfo EffectColour { get; set; } = Color4.White;
     public BlendingParameters EffectBlending { get; set; } = BlendingParameters.Inherit;

diff --git a/fluXis.Game/Graphics/Shaders/ShaderStackContainer.cs b/fluXis.Game/Graphics/Shaders/ShaderStackContainer.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using fluXis.Game.Map.Events;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
@@ -40,4 +41,7 @@ public ShaderStackContainer AddContent(Drawable[] content)
 
     public T GetShader<T>() where T : ShaderContainer
         => shaders.FirstOrDefault(s => s.GetType() == typeof(T)) as T;
+
+    public ShaderContainer GetShader(ShaderType type)
+        => shaders.FirstOrDefault(s => s.Type == type);
 }
diff --git a/fluXis.Game/Graphics/Shaders/Vignette/VignetteContainer.cs b/fluXis.Game/Graphics/Shaders/Vignette/VignetteContainer.cs
@@ -1,14 +1,11 @@
+using fluXis.Game.Map.Events;
 using osu.Framework.Graphics;
 
 namespace fluXis.Game.Graphics.Shaders.Vignette;
 
 public partial class VignetteContainer : ShaderContainer
 {
     protected override string FragmentShader => "Vignette";
+    public override ShaderType Type => ShaderType.Vignette;
     protected override DrawNode CreateShaderDrawNode() => new VignetteContainerDrawNode(this, SharedData);
-
-    /// <summary>
-    /// The strength of the invert effect. From 0 to 1.
-    /// </summary>
-    public float Strength { get; set; }
 }
diff --git a/fluXis.Game/Map/Events/ShaderEvent.cs b/fluXis.Game/Map/Events/ShaderEvent.cs
@@ -1,5 +1,7 @@
+using System;
 using fluXis.Game.Map.Structures;
 using Newtonsoft.Json;
+using osu.Framework.Logging;
 
 namespace fluXis.Game.Map.Events;
 
@@ -9,29 +11,42 @@ public class ShaderEvent : ITimedObject, IHasDuration
     public double Time { get; set; }
 
     [JsonProperty("shader")]
-    public string ShaderName { get; set; } = string.Empty;
+    public string ShaderName
+    {
+        get => Type.ToString();
+        set
+        {
+            if (Enum.TryParse<ShaderType>(value, out var type))
+                Type = type;
+            else
+                Logger.Log($"Failed to parse {value} as {nameof(ShaderType)}!", LoggingTarget.Runtime, LogLevel.Error);
+        }
+    }
+
+    [JsonIgnore]
+    public ShaderType Type { get; set; } = ShaderType.Bloom;
 
     [JsonProperty("duration")]
     public double Duration { get; set; }
 
     [JsonProperty("params")]
     public ShaderParameters Parameters { get; set; } = new();
 
-    public static string[] ShaderNames =
-    {
-        "Bloom",
-        "Greyscale",
-        "Invert",
-        "Chromatic",
-        "Mosaic",
-        "Noise",
-        "Vignette",
-        "Retro"
-    };
-
     public class ShaderParameters
     {
         [JsonProperty("strength")]
         public float Strength { get; set; }
     }
 }
+
+public enum ShaderType
+{
+    Bloom,
+    Greyscale,
+    Invert,
+    Chromatic,
+    Mosaic,
+    Noise,
+    Vignette,
+    Retro
+}
diff --git a/fluXis.Game/Screens/Edit/Tabs/Design/Points/Entries/ShaderEntry.cs b/fluXis.Game/Screens/Edit/Tabs/Design/Points/Entries/ShaderEntry.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using fluXis.Game.Graphics.Sprites;
@@ -22,7 +23,7 @@ private float maxStrength
     {
         get
         {
-            if (shader.ShaderName == "Chromatic")
+            if (shader.Type == ShaderType.Chromatic)
                 return 20f;
 
             return 1f;
@@ -33,7 +34,7 @@ private float step
     {
         get
         {
-            if (shader.ShaderName == "Chromatic")
+            if (shader.Type == ShaderType.Chromatic)
                 return 1f;
 
             return .01f;
@@ -51,7 +52,7 @@ public override ITimedObject CreateClone()
         {
             Time = Object.Time,
             Duration = shader.Duration,
-            ShaderName = shader.ShaderName,
+            Type = shader.Type,
             Parameters = new ShaderEvent.ShaderParameters
             {
                 Strength = shader.Parameters.Strength
@@ -76,15 +77,15 @@ protected override IEnumerable<Drawable> CreateSettings()
         return base.CreateSettings().Concat(new Drawable[]
         {
             new PointSettingsLength<ShaderEvent>(Map, shader, BeatLength),
-            new PointSettingsDropdown<string>
+            new PointSettingsDropdown<ShaderType>
             {
                 Text = "Shader",
                 TooltipText = "The shader to apply to the playfield.",
-                CurrentValue = shader.ShaderName,
-                Items = ShaderEvent.ShaderNames.ToList(),
+                CurrentValue = shader.Type,
+                Items = Enum.GetValues<ShaderType>().ToList(),
                 OnValueChanged = value =>
                 {
-                    shader.ShaderName = value;
+                    shader.Type = value;
                     Map.Update(shader);
                 }
             },

diff --git a/fluXis.Game/Screens/Gameplay/GameplayScreen.cs b/fluXis.Game/Screens/Gameplay/GameplayScreen.cs
@@ -23,6 +23,7 @@
 using fluXis.Game.Graphics.Shaders.Vignette;
 using fluXis.Game.Input;
 using fluXis.Game.Map;
+using fluXis.Game.Map.Events;
 using fluXis.Game.Mods;
 using fluXis.Game.Online.Activity;
 using fluXis.Game.Online.API.Requests.Scores;
@@ -217,20 +218,20 @@ private void load()
         dependencies.Cache(Playfield = new Playfield());
 
         var shaders = new ShaderStackContainer();
-        var shaderTypes = MapEvents.ShaderEvents.Select(e => e.ShaderName).Distinct().ToList();
+        var shaderTypes = MapEvents.ShaderEvents.Select(e => e.Type).Distinct().ToList();
 
         foreach (var shaderType in shaderTypes)
         {
             ShaderContainer shader = shaderType switch
             {
-                "Chromatic" => new ChromaticContainer(),
-                "Greyscale" => new GreyscaleContainer(),
-                "Invert" => new InvertContainer(),
-                "Bloom" => new BloomContainer(),
-                "Mosaic" => new MosaicContainer(),
-                "Noise" => new NoiseContainer(),
-                "Vignette" => new VignetteContainer(),
-                "Retro" => new RetroContainer(),
+                ShaderType.Chromatic => new ChromaticContainer(),
+                ShaderType.Greyscale => new GreyscaleContainer(),
+                ShaderType.Invert => new InvertContainer(),
+                ShaderType.Bloom => new BloomContainer(),
+                ShaderType.Mosaic => new MosaicContainer(),
+                ShaderType.Noise => new NoiseContainer(),
+                ShaderType.Vignette => new VignetteContainer(),
+                ShaderType.Retro => new RetroContainer(),
                 _ => null
             };