Directional Fading

i18n/default.json

@@ -28,5 +28,14 @@
   "gmcm.MenuKeybind.tooltip": "The keybinding to open the Nightshade menu.",
   "gmcm.Explainer.text": "Nightshade has its own config menu, which provides live preview of the slider settings. Please use that menu after configuring an appropriate keybinding.",
 
-  "EOF": ""
+  "EOF": "",
+
+  "menu.DirectionalFading.Text": "Directional fading",
+  "menu.DirectionalFading.Hover": "Bias the in-focus band based on facing direction (Up/Down).",
+  "menu.DirectionalFadingDuringEvents.Text": "Enable during events",
+  "menu.DirectionalFadingDuringEvents.Hover": "If unchecked, directional fading is disabled during cutscenes/events.",
+  "menu.DirectionalFadingTime.Text": "Fade time",
+  "menu.DirectionalFadingTime.Hover": "How quickly the focus bias changes when you turn (seconds).",
+  "menu.DirectionalFadingMinStrength.Text": "Minimum strength",
+  "menu.DirectionalFadingMinStrength.Hover": "Lower = stronger directional effect. Higher = more subtle."
 }

src/Main.cs

@@ -27,7 +27,12 @@ internal sealed class Nightshade : Mod
         private static bool usingColorizeUI = false;
         private static bool usingDepthOfField = false;
 
+
+        // Depth of field directional fading (Tilt-Shift style)
+        private static float dofDirectionalTarget = 0f; // -1 up, +1 down, 0 none
+        private static float dofDirectionalCurrent = 0f;
         public static ModConfig Config;
+        private static ModConfig AppliedConfig;
 
         public static Nightshade instance;
 
@@ -75,6 +80,7 @@ public override void Entry(IModHelper helper)
 
         public void ApplyConfig(ModConfig conf)
         {
+            AppliedConfig = conf;
             int index = conf.ColorizerActiveProfile;
             if (conf.ColorizeBySeason) {
                 index = Game1.currentLocation?.GetSeasonIndex() ?? Game1.seasonIndex;
@@ -275,6 +281,44 @@ public void OnRenderedWorld(object sender, RenderedWorldEventArgs e)
             float ypos = Game1.player.getLocalPosition(Game1.viewport).Y;
             ypos += Game1.player.GetBoundingBox().Height / 2;
             ypos /= Game1.viewport.Height;
+
+            // Directional fading (Tilt-Shift style): bias the focus band toward facing direction.
+            // Note: Nightshade's DoF shader supports asymmetric focus via Center around 0.5.
+            {
+                var dof = AppliedConfig?.DepthOfFieldSettings;
+                bool enabled = usingDepthOfField && (dof?.DirectionalFadingEnabled ?? false);
+                bool inEvent = Game1.eventUp || Game1.CurrentEvent != null;
+                if (enabled && inEvent && !(dof?.DirectionalFadingDuringEvents ?? false))
+                    enabled = false;
+
+                float target = 0f;
+                if (enabled) {
+                    // Stardew facing directions: 0 up, 1 right, 2 down, 3 left
+                    int fd = Game1.player.FacingDirection;
+                    if (fd == 0) target = -1f;
+                    else if (fd == 2) target = 1f;
+                }
+
+                dofDirectionalTarget = target;
+
+                float fadeTime = Math.Clamp(dof?.DirectionalFadingTime ?? 0.5f, 0f, 1f);
+                if (!enabled || fadeTime <= 0f) {
+                    dofDirectionalCurrent = dofDirectionalTarget;
+                } else {
+                    float dt = (float)Game1.currentGameTime.ElapsedGameTime.TotalSeconds;
+                    float t = Math.Clamp(dt / fadeTime, 0f, 1f);
+                    dofDirectionalCurrent = MathHelper.Lerp(dofDirectionalCurrent, dofDirectionalTarget, t);
+                }
+
+                if (enabled && dofDirectionalCurrent != 0f) {
+                    float minStrength = Math.Clamp(dof?.DirectionalFadingMinStrength ?? 0.30f, 0f, 1f);
+                    float shiftPct = 1f - minStrength; // 0=no effect, 1=max effect
+                    float field = Math.Clamp(dof?.Field ?? 0.6f, 0f, 1f);
+                    float maxShift = field / 2f;
+                    ypos = Math.Clamp(ypos + (dofDirectionalCurrent * maxShift * shiftPct), 0f, 1f);
+                }
+            }
+
             if (ypos < 0f || ypos > 1.0f) {
                 ypos = 0.5f;
             }

src/ModConfig.cs

@@ -45,6 +45,12 @@ public sealed class DepthOfFieldPreset
     {
         public float Field = 0.6f;
         public float Intensity = 6.0f;
+
+        // Tilt-Shift style "Directional fading"
+        public bool DirectionalFadingEnabled = false;
+        public bool DirectionalFadingDuringEvents = false;
+        public float DirectionalFadingTime = 0.5f;
+        public float DirectionalFadingMinStrength = 0.30f;
     }
 
     public enum LumaType {

ui/ShaderMenu.cs

@@ -1,3 +1,4 @@
+using System;
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using Microsoft.Xna.Framework.Input;
@@ -189,12 +190,49 @@ private void AddChildWidgets()
             var sld_intensity = new Slider(this, new Rectangle(126, y, 201, 20),
                     name: "Intensity", range: new int[]{0, 100});
             sld_intensity.ValueDelegate = sld_intensity.FloatRenderer(denom:10f);
-            y += lbl_intensity.Bounds.Height + 16;
+            y += lbl_intensity.Bounds.Height + 8;
+
+            var chk_directionalFading = new Checkbox(this, 20, y, "DirectionalFadingEnabled");
+            var lbl_directionalFading = new Label(this,
+                    new Rectangle(56, y, 0, 27),
+                    text: TR.Get("menu.DirectionalFading.Text"),
+                    hoverText: TR.Get("menu.DirectionalFading.Hover"),
+                    activate: chk_directionalFading);
+            y += chk_directionalFading.Bounds.Height + 8;
+
+            var chk_directionalFadingEvents = new Checkbox(this, 20, y, "DirectionalFadingDuringEvents");
+            var lbl_directionalFadingEvents = new Label(this,
+                    new Rectangle(56, y, 0, 27),
+                    text: TR.Get("menu.DirectionalFadingDuringEvents.Text"),
+                    hoverText: TR.Get("menu.DirectionalFadingDuringEvents.Hover"),
+                    activate: chk_directionalFadingEvents);
+            y += chk_directionalFadingEvents.Bounds.Height + 16;
+
+            var lbl_directionalFadingTime = new Label(this,
+                    new Rectangle(20, y, 96, 20),
+                    text: TR.Get("menu.DirectionalFadingTime.Text"),
+                    hoverText: TR.Get("menu.DirectionalFadingTime.Hover"));
+            var sld_directionalFadingTime = new Slider(this, new Rectangle(126, y, 201, 20),
+                    name: "DirectionalFadingTime", range: new int[]{0, 100});
+            sld_directionalFadingTime.ValueDelegate = sld_directionalFadingTime.FloatRenderer(denom:100f);
+            y += lbl_directionalFadingTime.Bounds.Height + 8;
+
+            var lbl_directionalFadingMin = new Label(this,
+                    new Rectangle(20, y, 96, 20),
+                    text: TR.Get("menu.DirectionalFadingMinStrength.Text"),
+                    hoverText: TR.Get("menu.DirectionalFadingMinStrength.Hover"));
+            var sld_directionalFadingMin = new Slider(this, new Rectangle(126, y, 201, 20),
+                    name: "DirectionalFadingMinStrength", range: new int[]{0, 100});
+            sld_directionalFadingMin.ValueDelegate = sld_directionalFadingMin.FloatRenderer(denom:100f);
+            y += lbl_directionalFadingMin.Bounds.Height + 16;
 
             var btn_save = new TextButton(this, 0, 0,
                     text: TR.Get("menu.Save.Text"), onClick: SaveSettings);
             btn_save.Bounds.X = defaultWidth/2 - btn_save.Bounds.Width/2;
-            btn_save.Bounds.Y = defaultHeight - btn_save.Bounds.Height - 8;
+            btn_save.Bounds.Y = y;
+
+            // expand the menu height so the Save button never overlaps controls
+            this.height = btn_save.Bounds.Y + btn_save.Bounds.Height + 8;
 
             this.children.AddRange(new List<Widget>() {
                 lbl_colorizer, lbl_colorizeWorld, chk_colorizeWorld,
@@ -215,6 +253,10 @@ private void AddChildWidgets()
                 lbl_enableDepthOfField, chk_enableDepthOfField,
                 lbl_field, sld_field,
                 lbl_intensity, sld_intensity,
+                lbl_directionalFading, chk_directionalFading,
+                lbl_directionalFadingEvents, chk_directionalFadingEvents,
+                lbl_directionalFadingTime, sld_directionalFadingTime,
+                lbl_directionalFadingMin, sld_directionalFadingMin,
                 btn_save,
             });
         }
@@ -305,14 +347,30 @@ public void LoadColorizerPreset(ColorizerPreset set)
         public void LoadDepthOfFieldPreset(DepthOfFieldPreset set)
         {
             foreach (var child in this.children) {
-                if ((child is Slider ch)) {
+                if (child is Slider ch) {
                     switch (ch.Name) {
                     case "Field":
                         ch.Value = (int)(set.Field * 100);
                         break;
                     case "Intensity":
                         ch.Value = (int)(set.Intensity * 10);
                         break;
+                    case "DirectionalFadingTime":
+                        ch.Value = (int)(Math.Clamp(set.DirectionalFadingTime, 0f, 1f) * 100);
+                        break;
+                    case "DirectionalFadingMinStrength":
+                        ch.Value = (int)(Math.Clamp(set.DirectionalFadingMinStrength, 0f, 1f) * 100);
+                        break;
+                    }
+                }
+                else if (child is Checkbox cb) {
+                    switch (cb.Name) {
+                    case "DirectionalFadingEnabled":
+                        cb.Value = set.DirectionalFadingEnabled;
+                        break;
+                    case "DirectionalFadingDuringEvents":
+                        cb.Value = set.DirectionalFadingDuringEvents;
+                        break;
                     }
                 }
             }
@@ -339,6 +397,18 @@ public void SaveSettings()
                 case "Intensity":
                     built.DepthOfFieldSettings.Intensity = (float)(ch as Slider).Value / 10f;
                     break;
+                case "DirectionalFadingEnabled":
+                    built.DepthOfFieldSettings.DirectionalFadingEnabled = (ch as Checkbox).Value;
+                    break;
+                case "DirectionalFadingDuringEvents":
+                    built.DepthOfFieldSettings.DirectionalFadingDuringEvents = (ch as Checkbox).Value;
+                    break;
+                case "DirectionalFadingTime":
+                    built.DepthOfFieldSettings.DirectionalFadingTime = (float)(ch as Slider).Value / 100f;
+                    break;
+                case "DirectionalFadingMinStrength":
+                    built.DepthOfFieldSettings.DirectionalFadingMinStrength = (float)(ch as Slider).Value / 100f;
+                    break;
                 }
             }
             for (int i = 0; i < ColorizerActiveStates.Length; ++i) {
@@ -507,6 +577,18 @@ public void onChildChange(Widget child)
                 case "Intensity":
                     built.DepthOfFieldSettings.Intensity = (float)(ch as Slider).Value / 10f;
                     break;
+                case "DirectionalFadingEnabled":
+                    built.DepthOfFieldSettings.DirectionalFadingEnabled = (ch as Checkbox).Value;
+                    break;
+                case "DirectionalFadingDuringEvents":
+                    built.DepthOfFieldSettings.DirectionalFadingDuringEvents = (ch as Checkbox).Value;
+                    break;
+                case "DirectionalFadingTime":
+                    built.DepthOfFieldSettings.DirectionalFadingTime = (float)(ch as Slider).Value / 100f;
+                    break;
+                case "DirectionalFadingMinStrength":
+                    built.DepthOfFieldSettings.DirectionalFadingMinStrength = (float)(ch as Slider).Value / 100f;
+                    break;
                 }
             }
             // TODO use initial state if missing toggle is off