Refactor parameters to reduce noise

Signed-off-by: Andrew Opalach <andrew@akon.city>

1 files changed, 457 insertions, 439 deletions

diff --git a/Plugin.cs b/Plugin.cs
index d93625d..9cb230e 100644
--- a/Plugin.cs
+++ b/Plugin.cs
@@ -75,10 +75,15 @@ namespace WorldTuningTool
 #endif
         }
 
-        private static nint lton(long l) { unchecked { return (nint)l; } }
+        public static nint lton(long l) { unchecked { return (nint)l; } }
 
         private static byte ByteFlag(bool f) { return f ? (byte)0x1 : (byte)0x0; }
 
+        private static int BitIndex(int mask)
+        {
+            return BitOperations.Log2((uint)(mask & (-mask)));
+        }
+
         private static Vector4 ColorVectorFromInt(int c)
         {
             return new Vector4(
@@ -288,8 +293,7 @@ namespace WorldTuningTool
 
         private static class ParameterFlags
         {
-            public const int PerFrame = 1;
-            public const int NoOverride = 1 << 1;
+            public const int ViewOnly = 1;
         }
 
         public abstract class Parameter
@@ -306,8 +310,7 @@ namespace WorldTuningTool
             private bool overrideWasOn = false;
 
             private int flags;
-            public bool NoOverride => (flags & ParameterFlags.NoOverride) == ParameterFlags.NoOverride;
-            public bool PerFrame => (flags & ParameterFlags.PerFrame) == ParameterFlags.PerFrame;
+            public bool ViewOnly => (flags & ParameterFlags.ViewOnly) == ParameterFlags.ViewOnly;
 
             protected float stepf, minf, maxf;
             protected int step, min, max;
@@ -334,19 +337,23 @@ namespace WorldTuningTool
                 Name = name;
                 hiddenName = "##" + Name;
                 Type = type;
+                switch (Type)
+                {
+                    case ParameterType.FLAG:
+                        Assert(mask != 0);
+                        break;
+                    case ParameterType.PATCH_FLOAT:
+                        valueV.X = MemoryUtil.Read<float>(offset);
+                        pendingUpdate = false;
+                        break;
+                    case ParameterType.SHADOW_RESOLUTION:
+                        valueInt = 1;
+                        pendingUpdate = false;
+                        break;
+                }
                 this.offset = offset;
                 this.mask = mask;
                 this.flags = flags;
-                if (Type == ParameterType.PATCH_FLOAT)
-                {
-                    valueV.X = MemoryUtil.Read<float>(offset);
-                    pendingUpdate = false;
-                }
-                else if (Type == ParameterType.SHADOW_RESOLUTION)
-                {
-                    valueInt = 1;
-                    pendingUpdate = false;
-                }
             }
 
             public bool PendingUpdate()
@@ -403,7 +410,7 @@ namespace WorldTuningTool
                         }
                         break;
                 }
-                if (PerFrame || lastAddr == 0x0)
+                if (lastAddr == 0x0)
                 {
                     return;
                 }
@@ -414,21 +421,34 @@ namespace WorldTuningTool
                         MemoryUtil.GetRef<byte>(lastAddr + offset) = (byte)valueInt;
                         break;
                     case ParameterType.FLAG:
+                    {
+                        ref int i1 = ref MemoryUtil.GetRef<int>(lastAddr + offset);
                         if (valueInt != 0)
                         {
-                            MemoryUtil.GetRef<int>(lastAddr + offset) |= mask;
+                            i1 |= mask;
                         }
                         else
                         {
-                            MemoryUtil.GetRef<int>(lastAddr + offset) &= ~mask;
+                            i1 &= ~mask;
                         }
                         break;
+                    }
                     case ParameterType.INT:
                     case ParameterType.ALIGNED_INT:
                     case ParameterType.HEX:
                     case ParameterType.COLOR:
-                        MemoryUtil.GetRef<int>(lastAddr + offset) = valueInt;
+                    {
+                        ref int i1 = ref MemoryUtil.GetRef<int>(lastAddr + offset);
+                        if (mask != 0)
+                        {
+                            i1 = (i1 & ~mask) | ((valueInt << BitIndex(mask)) & mask);
+                        }
+                        else
+                        {
+                            i1 = valueInt;
+                        }
                         break;
+                    }
                     case ParameterType.FLOAT:
                         MemoryUtil.GetRef<float>(lastAddr + offset) = valueV.X;
                         break;
@@ -445,6 +465,22 @@ namespace WorldTuningTool
                 }
             }
 
+            public void ForceOverrideOn()
+            {
+                if (!queuedOverride && !overrideValue)
+                {
+                    OverrideOn(false);
+                }
+            }
+
+            public void ForceOverrideOff()
+            {
+                if (queuedOverride || overrideValue)
+                {
+                    OverrideOff();
+                }
+            }
+
             public void OverrideOn(bool forStage)
             {
                 if (pendingUpdate)
@@ -527,11 +563,6 @@ namespace WorldTuningTool
                 }
             }
 
-            private int bitIndex(int mask)
-            {
-                return BitOperations.Log2((uint)(mask & (-mask)));
-            }
-
             public void Update(nint baseObject, bool fromHook = false)
             {
                 lastAddr = baseObject;
@@ -606,21 +637,29 @@ namespace WorldTuningTool
                     case ParameterType.COLOR:
                     {
                         ref int i1 = ref MemoryUtil.GetRef<int>(baseObject + offset);
+                        int m1 = i1;
                         if (mask != 0)
                         {
-                            i1 = (i1 & mask) >> bitIndex(mask);
+                            m1 = (i1 & mask) >> BitIndex(mask);
                         }
                         if (overrideValue)
                         {
-                            if (i1 != valueInt)
+                            if (m1 != valueInt)
                             {
-                                oValueInt = i1;
+                                oValueInt = m1;
+                            }
+                            if (mask != 0)
+                            {
+                                i1 = (i1 & ~mask) | ((valueInt << BitIndex(mask)) & mask);
+                            }
+                            else
+                            {
+                                i1 = valueInt;
                             }
-                            i1 = valueInt;
                         }
                         else
                         {
-                            valueInt = i1;
+                            valueInt = m1;
                         }
                         break;
                     }
@@ -947,7 +986,7 @@ namespace WorldTuningTool
             {
                 ImGui.PushID(Name);
 
-                if (NoOverride)
+                if (ViewOnly)
                 {
                     ImGui.SetCursorPos(ImGui.GetCursorPos() + new Vector2(ImGui.GetFrameHeight() + ImGui.GetStyle().ItemSpacing.X, 0.0f));
                 }
@@ -958,6 +997,8 @@ namespace WorldTuningTool
                         ImGui.PushItemFlag(ImGuiItemFlags.Disabled, true);
                         ImGui.PushItemFlag(ImGuiItemFlags.MixedValue, true);
                     }
+                    // If OverrideOn() were to set queuedOverride instead of overrideValue, this parameter shouldn't be drawn.
+                    Assert(!PendingUpdate());
                     bool toggleOverride = overrideValue;
                     if (ImGui.Checkbox("##Override", ref toggleOverride))
                     {
@@ -1155,23 +1196,6 @@ namespace WorldTuningTool
             }
         }
 
-        public static int pFlags(string s)
-        {
-            int flags = 0;
-            for (int i = 0; i < s.Length; i++)
-            {
-                switch (s[i])
-                {
-                    case 'f':
-                        flags |= ParameterFlags.PerFrame;
-                        break;
-                    default:
-                        break;
-                }
-            }
-            return flags;
-        }
-
         public static (float?, float?, float?) pStep(float step) { return (null, null, step); }
         public static (float?, float?, float?) pMin(float min) { return (min, null, null); }
         public static (float?, float?, float?) pMax(float max) { return (null, max, null); }
@@ -1186,29 +1210,19 @@ namespace WorldTuningTool
         public static (int?, int?, int?) pMinMaxStep(int min, int max, int step) { return (min, max, step); }
         public static (byte?, byte?, byte?) pStep(byte step) { return (null, null, step); }
 
-        public static Parameter<T> newParameter<T>(string name, nint offset, ParameterType type, (T? min, T? max, T? step) m = default) where T : unmanaged
+        public static Parameter<T> P<T>(string name, nint offset, ParameterType type, (T? min, T? max, T? step) m = default) where T : unmanaged
         {
             return new Parameter<T>(name, offset, 0, type, m.min, m.max, m.step, 0);
         }
 
-        public static Parameter<T> P<T>(string name, nint offset, ParameterType type, int flags, (T? min, T? max, T? step) m = default) where T : unmanaged
+        public static Parameter<T> V<T>(string name, nint offset, ParameterType type, (T? min, T? max, T? step) m = default) where T : unmanaged
         {
-            return new Parameter<T>(name, offset, 0, type, m.min, m.max, m.step, flags);
+            return new Parameter<T>(name, offset, 0, type, m.min, m.max, m.step, ParameterFlags.ViewOnly);
         }
 
-        public static Parameter<T> newFrameParameter<T>(string name, nint offset, ParameterType type, (T? min, T? max, T? step) m = default) where T : unmanaged
+        public static Parameter<T> M<T>(string name, nint offset, ParameterType type, int mask, (T? min, T? max, T? step) m = default) where T : unmanaged
         {
-            return new Parameter<T>(name, offset, 0, type, m.min, m.max, m.step, ParameterFlags.PerFrame);
-        }
-
-        public static Parameter<T> newParameterView<T>(string name, nint offset, ParameterType type, (T? min, T? max, T? step) m = default) where T : unmanaged
-        {
-            return new Parameter<T>(name, offset, 0, type, m.min, m.max, m.step, ParameterFlags.NoOverride);
-        }
-
-        public static Parameter<T> newFlag<T>(string name, nint offset, ParameterType type, int mask) where T : unmanaged
-        {
-            return new Parameter<T>(name, offset, mask, type, null, null, null, 0);
+            return new Parameter<T>(name, offset, mask, type, m.min, m.max, m.step, 0);
         }
 
         private static Parameter? getParameterByName(string name)
@@ -1383,7 +1397,7 @@ namespace WorldTuningTool
                     {
                         foreach (Parameter iterParam in allParameters)
                         {
-                            if (iterParam.NoOverride) continue;
+                            if (iterParam.ViewOnly) continue;
                             if (overridesContainsParam(currentOverrides, iterParam)) continue;
                             bool isSelected = Param == iterParam;
                             if (ImGui.Selectable(iterParam.Name, isSelected))
@@ -1551,124 +1565,124 @@ namespace WorldTuningTool
 
         private static Lights lights = new Lights();
 
-        private static Parameter hqMode = newParameter<bool>("HQ Mode", 0xE9A3, ParameterType.BOOL);
+        private static Parameter hqMode = P<bool>("HQ Mode", 0xE9A3, ParameterType.BOOL);
 
         private static Parameter[] lodParameters = {
-            newParameter<float>("LOD Bias 1", 0x21C, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<float>("LOD Bias 2", 0x220, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<float>("LOD Caster Bias", 0x1E4, ParameterType.FLOAT, pMin(0.0f)),
+            P<float>("LOD Bias 1", 0x21C, ParameterType.FLOAT, pMin(0.0f)),
+            P<float>("LOD Bias 2", 0x220, ParameterType.FLOAT, pMin(0.0f)),
+            P<float>("LOD Caster Bias", 0x1E4, ParameterType.FLOAT, pMin(0.0f)),
             // If platform is PS4/Xbox/PC it appears [2] is PC.
-            newParameter<float>("LOD Length Platform Bias[2]", 0x22C + (4 * 2), ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<float>("LOD Pixel Size Platform Bias[2]", 0x244 + (4 * 2), ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<int>("LOD Limit", 0xE898, ParameterType.INT, pStep(1)),
-            newParameter<float>("LOD Passthrough Culling Rate", 0x1F0, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<float>("LOD Far Culling Fade Length Max", 0x20C, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<float>("LOD Far Culling Fade Pixel Max", 0x210, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<float>("Speed Tree LOD Billboard Fade Range", 0x214, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<float>("LOD Culling Length Bias", 0x224, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<float>("LOD Culling Pixel Bias", 0x228, ParameterType.FLOAT, pMin(0.0f))
+            P<float>("LOD Length Platform Bias[2]", 0x22C + (4 * 2), ParameterType.FLOAT, pMin(0.0f)),
+            P<float>("LOD Pixel Size Platform Bias[2]", 0x244 + (4 * 2), ParameterType.FLOAT, pMin(0.0f)),
+            P<int>("LOD Limit", 0xE898, ParameterType.INT, pStep(1)),
+            P<float>("LOD Passthrough Culling Rate", 0x1F0, ParameterType.FLOAT, pMin(0.0f)),
+            P<float>("LOD Far Culling Fade Length Max", 0x20C, ParameterType.FLOAT, pMin(0.0f)),
+            P<float>("LOD Far Culling Fade Pixel Max", 0x210, ParameterType.FLOAT, pMin(0.0f)),
+            P<float>("Speed Tree LOD Billboard Fade Range", 0x214, ParameterType.FLOAT, pMin(0.0f)),
+            P<float>("LOD Culling Length Bias", 0x224, ParameterType.FLOAT, pMin(0.0f)),
+            P<float>("LOD Culling Pixel Bias", 0x228, ParameterType.FLOAT, pMin(0.0f))
         };
 
         private static Parameter[] snowParameters = {
-            newParameter<float>("Snow Field 4 Global LOD Param", 0x5718, ParameterType.FLOAT)
+            P<float>("Snow Field 4 Global LOD Param", 0x5718, ParameterType.FLOAT)
         };
 
         private static Parameter[] passthroughParameters = {
-            newParameter<bool>("Passthrough Active", 0xE9A0, ParameterType.BOOL),
-            newParameter<bool>("Passthrough Culling Active", 0xE9A2, ParameterType.BOOL),
-            newParameterView<float>("Passthrough Near", 0xE940, ParameterType.FLOAT),
-            newParameterView<float>("Passthrough Far", 0xE944, ParameterType.FLOAT),
-            newParameter<float>("Passthrough Near Alpha", 0xE948, ParameterType.FLOAT),
-            newParameter<float>("Passthrough Far Alpha", 0xE94C, ParameterType.FLOAT),
-            newParameter<float>("Passthrough Correct", 0xE950, ParameterType.FLOAT)
+            P<bool>("Passthrough Active", 0xE9A0, ParameterType.BOOL),
+            P<bool>("Passthrough Culling Active", 0xE9A2, ParameterType.BOOL),
+            V<float>("Passthrough Near", 0xE940, ParameterType.FLOAT),
+            V<float>("Passthrough Far", 0xE944, ParameterType.FLOAT),
+            P<float>("Passthrough Near Alpha", 0xE948, ParameterType.FLOAT),
+            P<float>("Passthrough Far Alpha", 0xE94C, ParameterType.FLOAT),
+            P<float>("Passthrough Correct", 0xE950, ParameterType.FLOAT)
         };
 
         private static Parameter[] shadowCascadeParameters = {
-            newParameter<bool>("Primary Shadow HQ", 0xE5C0, ParameterType.BOOL),
-            newParameter<bool>("Primary Shadow HQ (HQ)", 0xE5C2, ParameterType.BOOL),
-            newParameter<float>("Shadow Cascade 2Way Bias (HQ)", 0x58, ParameterType.FLOAT),
-            newParameter<int>("Primary Shadow Sample Num (HQ)", 0xE5CC, ParameterType.INT, pStep(1))
+            P<bool>("Primary Shadow HQ", 0xE5C0, ParameterType.BOOL),
+            P<bool>("Primary Shadow HQ (HQ)", 0xE5C2, ParameterType.BOOL),
+            P<float>("Shadow Cascade 2Way Bias (HQ)", 0x58, ParameterType.FLOAT),
+            P<int>("Primary Shadow Sample Num (HQ)", 0xE5CC, ParameterType.INT, pStep(1))
         };
 
         private delegate void EvalSceneParams(nint unknownPtr, nint unknownPtr2, int unknownInt, nint unknownPtr3);
         private Hook<EvalSceneParams>? evalSceneParams;
         private static Parameter[] broadAreaShadowParameters = {
-            newParameter<bool>("Broad Area Shadow Enable", 0x5534, ParameterType.BOOL),
-            newParameter<float>("Broad Area Shadow Center", 0x5540 + 0x40, ParameterType.VECTOR3),
-            newParameter<float>("Broad Area Shadow Range", 0x5560 + 0x40, ParameterType.VECTOR3),
-            newParameter<float>("Broad Area Shadow Direction", 0x5550 + 0x40, ParameterType.VECTOR3, pStep(0.00025f)),
-            newParameter<float>("Broad Area Shadow Max LOD Level", 0x5524, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<float>("Broad Area Shadow Culling Size", 0x5528, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<int>("Broad Area Shadow Precision", 0x5518, ParameterType.INT, pMinMaxStep(0, 2, 1))
+            P<bool>("Broad Area Shadow Enable", 0x5534, ParameterType.BOOL),
+            P<float>("Broad Area Shadow Center", 0x5540 + 0x40, ParameterType.VECTOR3),
+            P<float>("Broad Area Shadow Range", 0x5560 + 0x40, ParameterType.VECTOR3),
+            P<float>("Broad Area Shadow Direction", 0x5550 + 0x40, ParameterType.VECTOR3, pStep(0.00025f)),
+            P<float>("Broad Area Shadow Max LOD Level", 0x5524, ParameterType.FLOAT, pMin(0.0f)),
+            P<float>("Broad Area Shadow Culling Size", 0x5528, ParameterType.FLOAT, pMin(0.0f)),
+            P<int>("Broad Area Shadow Precision", 0x5518, ParameterType.INT, pMinMaxStep(0, 2, 1))
         };
 
         private static Parameter[] contactShadowParameters = {
-            newParameter<float>("Fake Light Intensity", 0xEC40, ParameterType.FLOAT),
+            P<float>("Fake Light Intensity", 0xEC40, ParameterType.FLOAT),
             // MonsterHunterWorld.exe+1B18711 - mov [rbx+0000EC44],3F800000 (Other unknown reference).
-            newParameter<float>("Fake Light Intensity (Gameplay)", lton(0x141B1A19F) + 0x6, ParameterType.PATCH_FLOAT),
-            newParameter<float>("Fake Light Blend", lton(0x141CDE0CE) + 0x6, ParameterType.PATCH_FLOAT),
-            newParameter<bool>("Force Disable Contact Shadows", 0xB4ED, ParameterType.BOOL),
-            newParameter<bool>("Facial Contact Shadows Enabled", 0xB4EE, ParameterType.BOOL),
-            newParameter<bool>("Facial Contact Shadows Enable Noise", 0xB501, ParameterType.BOOL),
-            newParameter<float>("Contact Shadow Accept Maximum Length", 0xB4F8, ParameterType.FLOAT),
-            newParameter<float>("Contact Shadow Accept Minimum Length", 0xB4FC, ParameterType.FLOAT)
+            P<float>("Fake Light Intensity (Gameplay)", lton(0x141B1A19F) + 0x6, ParameterType.PATCH_FLOAT),
+            P<float>("Fake Light Blend", lton(0x141CDE0CE) + 0x6, ParameterType.PATCH_FLOAT),
+            P<bool>("Force Disable Contact Shadows", 0xB4ED, ParameterType.BOOL),
+            P<bool>("Facial Contact Shadows Enabled", 0xB4EE, ParameterType.BOOL),
+            P<bool>("Facial Contact Shadows Enable Noise", 0xB501, ParameterType.BOOL),
+            P<float>("Contact Shadow Accept Maximum Length", 0xB4F8, ParameterType.FLOAT),
+            P<float>("Contact Shadow Accept Minimum Length", 0xB4FC, ParameterType.FLOAT)
         };
 
         private delegate void UpdateCapsuleAOParams(nint sceneObjectInternal);
         private Hook<UpdateCapsuleAOParams>? updateCapsuleAoParams;
         private static Parameter[] capsuleLightParameters = {
-            newParameter<bool>("Force Disable Capsule AO", 0xB503, ParameterType.BOOL),
-            newParameter<bool>("Capsule AO Enabled", 0xB502, ParameterType.BOOL),
-            newParameter<float>("Capsule AO Distance Fall Coef", 0xE5B4, ParameterType.FLOAT, pStep(0.0001f)),
-            newParameter<int>("Capsule AO Light Channel Mask", 0xE5BC, ParameterType.INT, pStep(1)),
-            newParameter<float>("Capsule Light Dir XZY", 0xE548, ParameterType.VECTOR3),
-            newParameterView<float>("Capsule Light W Dir", 0xE560, ParameterType.VECTOR3),
-            newParameter<float>("Capsule Light Angle", 0xE5B0, ParameterType.FLOAT),
-            newParameter<float>("Capsule AO Intensity", 0xE5B8, ParameterType.FLOAT, pStep(0.00025f))
+            P<bool>("Force Disable Capsule AO", 0xB503, ParameterType.BOOL),
+            P<bool>("Capsule AO Enabled", 0xB502, ParameterType.BOOL),
+            P<float>("Capsule AO Distance Fall Coef", 0xE5B4, ParameterType.FLOAT, pStep(0.0001f)),
+            P<int>("Capsule AO Light Channel Mask", 0xE5BC, ParameterType.INT, pStep(1)),
+            P<float>("Capsule Light Direction XZY", 0xE548, ParameterType.VECTOR3),
+            V<float>("Capsule Light W Direction", 0xE560, ParameterType.VECTOR3),
+            P<float>("Capsule Light Angle", 0xE5B0, ParameterType.FLOAT),
+            P<float>("Capsule AO Intensity", 0xE5B8, ParameterType.FLOAT, pStep(0.00025f))
         };
 
         private delegate void UpdateSSAOParams(nint stackOffset);
         private Hook<UpdateSSAOParams>? updateSSAOParams;
         private static Parameter[] ssaoParameters = {
-            newParameter<float>("SSAO Depth Bias", 0xB4B0, ParameterType.FLOAT, pStep(0.00001f)),
-            newParameter<float>("SSAO Sloped Depth Bias", 0xB4B4, ParameterType.FLOAT, pStep(0.00001f)),
-            newParameter<float>("SSAO Max Depth Bias", 0xB4B8, ParameterType.FLOAT, pStep(0.00001f)),
-            newParameter<float>("SSAO Dispersion", 0xB4BC, ParameterType.FLOAT),
-            newParameter<float>("SSAO Effect", 0xB430, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("SSAO Effect GI", 0xB434, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("SSAO Depth Difference", 0xB4C0, ParameterType.FLOAT, pStep(0.01f)),
-            newParameter<float>("SSAO Samples Per Pixel", 0xB4C4, ParameterType.FLOAT, pStep(1.0f)),
-            newParameter<int>("SSAO Max Sample Num", 0xB4C8, ParameterType.INT, pStep(1)),
-            newParameter<int>("SSAO Max Sample Num (HQ)", 0xB4D0, ParameterType.INT, pStep(1)),
-            newParameter<float>("SSAO Radius", 0xB4D4, ParameterType.FLOAT),
-            newParameter<float>("SSAO Bias", 0xB4D8, ParameterType.FLOAT, pStep(0.0001f)),
-            newParameter<float>("SSAO Intensity", 0xB4E0, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<bool>("SSAO Use HiZ", 0xB4E5, ParameterType.BOOL),
-            newParameter<float>("SSAO Edge Atten Rate", 0xB4DC, ParameterType.FLOAT, pStep(0.001f))
+            P<float>("SSAO Depth Bias", 0xB4B0, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("SSAO Sloped Depth Bias", 0xB4B4, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("SSAO Max Depth Bias", 0xB4B8, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("SSAO Dispersion", 0xB4BC, ParameterType.FLOAT),
+            P<float>("SSAO Effect", 0xB430, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("SSAO Effect GI", 0xB434, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("SSAO Depth Difference", 0xB4C0, ParameterType.FLOAT, pStep(0.01f)),
+            P<float>("SSAO Samples Per Pixel", 0xB4C4, ParameterType.FLOAT, pStep(1.0f)),
+            P<int>("SSAO Max Sample Num", 0xB4C8, ParameterType.INT, pStep(1)),
+            P<int>("SSAO Max Sample Num (HQ)", 0xB4D0, ParameterType.INT, pStep(1)),
+            P<float>("SSAO Radius", 0xB4D4, ParameterType.FLOAT),
+            P<float>("SSAO Bias", 0xB4D8, ParameterType.FLOAT, pStep(0.0001f)),
+            P<float>("SSAO Intensity", 0xB4E0, ParameterType.FLOAT, pMin(0.0f)),
+            P<bool>("SSAO Use HiZ", 0xB4E5, ParameterType.BOOL),
+            P<float>("SSAO Edge Atten Rate", 0xB4DC, ParameterType.FLOAT, pStep(0.001f))
         };
 
         private delegate void UpdateSSLRParams(nint stackOffset);
         private Hook<UpdateSSLRParams>? updateSSLRParams;
         private static Parameter[] sslrParameters = {
-            newParameter<int>("SSLR Loop Count", 0xE628, ParameterType.INT, pStep(1)),
-            newParameter<float>("SSLR Loop Count Factor for CBR", 0xE62C, ParameterType.FLOAT),
-            newParameter<float>("SSLR Eliminate Depth", 0xE630, ParameterType.FLOAT),
-            newParameter<float>("SSLR Accurate Threshold", 0xE644, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("SSLR Accurate Threshold (HQ)", 0xE64C, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("SSLR Dither Radius", 0xE634, ParameterType.FLOAT),
-            newParameter<float>("SSLR Importance Bias", 0xE638, ParameterType.FLOAT),
-            newParameter<float>("SSLR Mip Scale", 0xE63C, ParameterType.FLOAT),
-            newParameter<float>("SSLR Mip Bias", 0xE640, ParameterType.FLOAT),
-            newParameter<bool>("SSLR Dither Resolve", 0xB43F, ParameterType.BOOL),
-            newParameter<float>("SSLR Edge Atten Rate", 0xB428, ParameterType.FLOAT),
-            newParameter<int>("SSLR Mip 0 Count Threshold", 0xB438, ParameterType.INT, pStep(1)),
-            newParameter<float>("SSLR Depth Eliminate Rate", 0xB42C, ParameterType.FLOAT),
-            newParameter<bool>("SSLR Use Mipmap", 0xE650, ParameterType.BOOL),
-            newParameter<bool>("SSLR GBuffer Jitter", 0xB440, ParameterType.BOOL),
-            newParameter<float>("SSLR Intensity", 0xB424, ParameterType.FLOAT)
+            P<int>("SSLR Loop Count", 0xE628, ParameterType.INT, pStep(1)),
+            P<float>("SSLR Loop Count Factor for CBR", 0xE62C, ParameterType.FLOAT),
+            P<float>("SSLR Eliminate Depth", 0xE630, ParameterType.FLOAT),
+            P<float>("SSLR Accurate Threshold", 0xE644, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("SSLR Accurate Threshold (HQ)", 0xE64C, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("SSLR Dither Radius", 0xE634, ParameterType.FLOAT),
+            P<float>("SSLR Importance Bias", 0xE638, ParameterType.FLOAT),
+            P<float>("SSLR Mip Scale", 0xE63C, ParameterType.FLOAT),
+            P<float>("SSLR Mip Bias", 0xE640, ParameterType.FLOAT),
+            P<bool>("SSLR Dither Resolve", 0xB43F, ParameterType.BOOL),
+            P<float>("SSLR Edge Atten Rate", 0xB428, ParameterType.FLOAT),
+            P<int>("SSLR Mip 0 Count Threshold", 0xB438, ParameterType.INT, pStep(1)),
+            P<float>("SSLR Depth Eliminate Rate", 0xB42C, ParameterType.FLOAT),
+            P<bool>("SSLR Use Mipmap", 0xE650, ParameterType.BOOL),
+            P<bool>("SSLR GBuffer Jitter", 0xB440, ParameterType.BOOL),
+            P<float>("SSLR Intensity", 0xB424, ParameterType.FLOAT)
         };
 
-        private static Parameter shadowResParameter = newParameter<int>("Shadow Resolution Multiplier", 0, ParameterType.SHADOW_RESOLUTION, pStep(1));
+        private static Parameter shadowResParameter = P<int>("Shadow Resolution Multiplier", 0, ParameterType.SHADOW_RESOLUTION, pStep(1));
         private delegate void UpdateShadowParams(nint shadowParams, nint stackOffset);
         private delegate void StaticShadowParams(nint shadowParamsStatic, nint shadowObjectInternal);
         private Hook<UpdateShadowParams>? updateShadowParams;
@@ -1676,52 +1690,73 @@ namespace WorldTuningTool
         private static Parameter[] shadowParameters1 = {
         };
         // This is actually an InfiniteLight object.
-        // Non-PerFrame parameters will be written directly to the light object.
+        // "Min Roughness" is +0xFC in params but is never read.
         private static Parameter[] shadowParameters2 = {
-            newFrameParameter<int>("Sunlight Group", 0x14, ParameterType.INT, pMinMaxStep(1, 255, 1)),
-            newFrameParameter<float>("Sunlight Direction", 0x110, ParameterType.VECTOR3, pStep(0.00025f)),
-            newFrameParameter<float>("Sunlight Color", 0xE0, ParameterType.COLOR_FACTOR, pMaxStep(1.0f, 0.001f)),
-            newFrameParameter<float>("Sunlight Intensity", 0xF4, ParameterType.FLOAT),
-            newParameter<float>("Sunlight Min Roughness", 0x58C, ParameterType.FLOAT, pStep(0.0025f)), // +0xFC in params but is never read.
-            newFrameParameter<bool>("Sunlight Is Primary", 0x1D, ParameterType.BOOL),
-            newFrameParameter<bool>("Do Volumetric", 0x1F, ParameterType.BOOL),
-            newFrameParameter<bool>("Shadow Cast", 0x23, ParameterType.BOOL),
-            newFrameParameter<int>("Shadow Map Size", 0x30, ParameterType.ALIGNED_INT, pMinStep(0, 128)), // 0 = 64x64 no multiplier @TODO: Verify in the code.
-            newFrameParameter<float>("Shadow Near Clip Distance", 0x28, ParameterType.FLOAT),
-            newFrameParameter<int>("Shadow Cascade Mode", 0x174, ParameterType.INT, pMinMaxStep(0, 3, 1)),
-            newFrameParameter<float>("Shadow Cascade 2Way Bias", 0x17C, ParameterType.FLOAT),
-            newFrameParameter<float>("Shadow Distance", 0x6C, ParameterType.FLOAT, pStep(5.0f)),
-            newFrameParameter<float>("Shadow Backforward Distance", 0x7C, ParameterType.FLOAT, pStep(5.0f)),
-            newFrameParameter<bool>("Shadow Is Fixed Fov Mode", 0x1F9, ParameterType.BOOL),
-            newFrameParameter<float>("Shadow Fov", 0x1F4, ParameterType.FLOAT, pStep(0.0001f)),
-            newFrameParameter<bool>("Shadow Is Discretization Fov Mode", 0x205, ParameterType.BOOL),
-            newFrameParameter<float>("Shadow Discretization Angle", 0x200, ParameterType.FLOAT, pStep(0.0001f)),
-            newFrameParameter<float>("Shadow Distribution", 0x74, ParameterType.FLOAT, pStep(0.001f)),
-            newFrameParameter<bool>("Cascade Manual Split", 0x4D, ParameterType.BOOL),
-            newFrameParameter<float>("Cascade Manual Split Distance[0]", 0x54, ParameterType.FLOAT),
-            newFrameParameter<float>("Cascade Manual Split Distance[1]", 0x5C, ParameterType.FLOAT),
-            newFrameParameter<float>("Cascade Manual Split Distance[2]", 0x64, ParameterType.FLOAT),
-            newFrameParameter<float>("Shadow Sloped Depth Bias", 0x40, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Shadow Depth Bias", 0x38, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Shadow Max Depth Bias", 0x48, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<bool>("Cascade Individual Shadow Bias", 0x81, ParameterType.BOOL),
-            newFrameParameter<float>("Cascade Depth Bias[0]", 0x88, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Cascade Sloped Depth Bias[0]", 0xA0, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Cascade Max Depth Bias[0]", 0xB8, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Cascade Depth Bias[1]", 0x90, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Cascade Sloped Depth Bias[1]", 0xA8, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Cascade Max Depth Bias[1]", 0xC0, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Cascade Depth Bias[2]", 0x98, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Cascade Sloped Depth Bias[2]", 0xB0, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Cascade Max Depth Bias[2]", 0xC8, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Broad Area Shadow Depth Bias", 0x1C4, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Broad Area Shadow Sloped Depth Bias", 0x1CC, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Broad Area Shadow Max Depth Bias", 0x1D4, ParameterType.FLOAT, pStep(0.00001f)),
-            newFrameParameter<float>("Projection Scale", 0x134, ParameterType.VECTOR3),
-            newFrameParameter<float>("Projection Offset Speed", 0x144, ParameterType.FLOAT),
-            newFrameParameter<float>("Projection Up", 0x160, ParameterType.VECTOR3),
-            newFrameParameter<int>("Primary Shadow Sample Num", 0x1DC, ParameterType.INT, pStep(1)),
-            newFrameParameter<float>("Primary Shadow Radius", 0x1EC, ParameterType.FLOAT, pStep(0.0001f))
+            P<int>("Sunlight Group", 0x14, ParameterType.INT, pMinMaxStep(1, 255, 1)),
+            P<float>("Sunlight Direction", 0x110, ParameterType.VECTOR3, pStep(0.00025f)),
+            P<float>("Sunlight Color", 0xE0, ParameterType.COLOR_FACTOR, pMaxStep(1.0f, 0.001f)),
+            P<float>("Sunlight Intensity", 0xF4, ParameterType.FLOAT, pStep(0.001f)),
+            P<bool>("Sunlight Is Primary", 0x1D, ParameterType.BOOL),
+            P<bool>("Do Volumetric", 0x1F, ParameterType.BOOL),
+            P<bool>("Shadow Cast", 0x23, ParameterType.BOOL),
+            P<int>("Shadow Map Size", 0x30, ParameterType.ALIGNED_INT, pMinStep(0, 128)), // 0 = 64x64 no multiplier @TODO: Verify in the code.
+            P<float>("Shadow Near Clip Distance", 0x28, ParameterType.FLOAT),
+            P<int>("Shadow Cascade Mode", 0x174, ParameterType.INT, pMinMaxStep(0, 3, 1)),
+            P<float>("Shadow Cascade 2Way Bias", 0x17C, ParameterType.FLOAT),
+            P<float>("Shadow Distance", 0x6C, ParameterType.FLOAT, pStep(5.0f)),
+            P<float>("Shadow Backforward Distance", 0x7C, ParameterType.FLOAT, pStep(5.0f)),
+            P<bool>("Shadow Is Fixed Fov Mode", 0x1F9, ParameterType.BOOL),
+            P<float>("Shadow Fov", 0x1F4, ParameterType.FLOAT, pStep(0.0001f)),
+            P<bool>("Shadow Is Discretization Fov Mode", 0x205, ParameterType.BOOL),
+            P<float>("Shadow Discretization Angle", 0x200, ParameterType.FLOAT, pStep(0.0001f)),
+            P<float>("Shadow Distribution", 0x74, ParameterType.FLOAT, pStep(0.001f)),
+            P<bool>("Cascade Manual Split", 0x4D, ParameterType.BOOL),
+            P<float>("Cascade Manual Split Distance[0]", 0x54, ParameterType.FLOAT),
+            P<float>("Cascade Manual Split Distance[1]", 0x5C, ParameterType.FLOAT),
+            P<float>("Cascade Manual Split Distance[2]", 0x64, ParameterType.FLOAT),
+            P<float>("Shadow Sloped Depth Bias", 0x40, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Shadow Depth Bias", 0x38, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Shadow Max Depth Bias", 0x48, ParameterType.FLOAT, pStep(0.00001f)),
+            P<bool>("Cascade Individual Shadow Bias", 0x81, ParameterType.BOOL),
+            P<float>("Cascade Depth Bias[0]", 0x88, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Cascade Sloped Depth Bias[0]", 0xA0, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Cascade Max Depth Bias[0]", 0xB8, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Cascade Depth Bias[1]", 0x90, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Cascade Sloped Depth Bias[1]", 0xA8, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Cascade Max Depth Bias[1]", 0xC0, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Cascade Depth Bias[2]", 0x98, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Cascade Sloped Depth Bias[2]", 0xB0, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Cascade Max Depth Bias[2]", 0xC8, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Broad Area Shadow Depth Bias", 0x1C4, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Broad Area Shadow Sloped Depth Bias", 0x1CC, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Broad Area Shadow Max Depth Bias", 0x1D4, ParameterType.FLOAT, pStep(0.00001f)),
+            P<float>("Projection Scale", 0x134, ParameterType.VECTOR2),
+            P<float>("Projection Offset Speed", 0x144, ParameterType.VECTOR2),
+            P<float>("Projection Up", 0x160, ParameterType.VECTOR3),
+            P<int>("Primary Shadow Sample Num", 0x1DC, ParameterType.INT, pStep(1)),
+            P<float>("Primary Shadow Radius", 0x1EC, ParameterType.FLOAT, pStep(0.0001f))
+        };
+
+        private static MtObject? sLightProbes = null;
+        private delegate void UpdateLightProbesParams(nint unknownPtr, int unknownInt);
+        private Hook<UpdateLightProbesParams>? updateLightProbesParams;
+        private static Parameter[] sLightProbesParameters = {
+            P<int>("Light Probes Probe Color", 0x38, ParameterType.COLOR),
+            P<float>("Light Probes Probe Intensity", 0x3C, ParameterType.FLOAT),
+            P<int>("Light Probes Top Color", 0x44, ParameterType.COLOR),
+            P<float>("Light Probes Top Intensity", 0x48, ParameterType.FLOAT),
+            P<int>("Light Probes Bottom Color", 0x4C, ParameterType.COLOR),
+            P<float>("Light Probes Bottom Intensity", 0x50, ParameterType.FLOAT),
+            P<float>("Light Probes Direction", 0x60, ParameterType.VECTOR3),
+            P<int>("Light Probes Shadow Top Color", 0x70, ParameterType.COLOR),
+            P<float>("Light Probes Shadow Top Intensity", 0x74, ParameterType.FLOAT),
+            P<int>("Light Probes Shadow Bottom Color", 0x78, ParameterType.COLOR),
+            P<float>("Light Probes Shadow Bottom Intensity", 0x7C, ParameterType.FLOAT),
+            P<float>("Light Probes Shadow Direction", 0x80, ParameterType.VECTOR3),
+            P<int>("Light Probes Daytime State", 0x9C, ParameterType.INT, pMinMaxStep(0, 6, 1)),
+            P<float>("Light Probes Daytime Interpolation", 0xA0, ParameterType.FLOAT),
+            P<int>("Light Probes Max Iter", 0xA4, ParameterType.INT),
+            P<int>("Light Probes Debug Mode", 0x98, ParameterType.INT, pStep(1))
         };
 
         private delegate nint CreateLightingObject();
@@ -1729,42 +1764,38 @@ namespace WorldTuningTool
         private Hook<CreateLightingObject>? createLightingObject;
         private Hook<DestroyLightingObject>? destroyLightingObject;
         private nint lightingObject = 0x0;
-        private delegate void UpdateLightingParameters(nint stackOffset, nint lightingObjectInternal);
-        private Hook<UpdateLightingParameters>? updateLightingParams;
-        private Hook<UpdateLightingParameters>? updateLutBlend;
+        private delegate void UpdateLightingParams(nint stackOffset, nint lightingObjectInternal);
+        private Hook<UpdateLightingParams>? updateLightingParams;
+        private Hook<UpdateLightingParams>? updateLutBlend;
         private static LUT luts = new LUT();
         private static Parameter[] lightingParameters = {
-            newParameter<int>("Light Tone Map Type", 0x16C, ParameterType.INT, pMinMaxStep(1, 6, 1)),
-            newParameter<bool>("Light Compute Luminance", 0x170, ParameterType.BOOL),
-            newParameter<bool>("Light Luminance Version", 0x168, ParameterType.BOOL),
-            newParameter<float>("Light Shoulder Strength", 0x174, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Light Linear Strength", 0x178, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Light Linear Angle", 0x17C, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Light Toe Strength", 0x180, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Light Toe Num", 0x184, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Light Toe Denum", 0x188, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Light White Point", 0x18C, ParameterType.FLOAT, pStep(0.01f)),
-            newFrameParameter<float>("Light LUT Blend", 0x1C8, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.01f)),
-            newParameter<float>("Light Vfx LUT Blend", 0x1D0, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.01f)),
-            newParameter<bool>("Light Enable Color Grading", 0x1D8, ParameterType.BOOL),
-            newParameter<bool>("Light Is Linear To PQ", 0x1A1, ParameterType.BOOL),
-            newParameter<bool>("Light Is PQ To Linear", 0x1A0, ParameterType.BOOL),
-            newParameter<float>("Volume Dispersion", 0x19C, ParameterType.FLOAT),
-            newParameter<float>("Volume Edge Sharpness", 0x198, ParameterType.FLOAT, pStep(0.00001f)),
-            newParameter<bool>("Volume Downsample", 0x210, ParameterType.BOOL)
+            P<int>("Light Tone Map Type", 0x16C, ParameterType.INT, pMinMaxStep(1, 6, 1)),
+            P<bool>("Light Compute Luminance", 0x170, ParameterType.BOOL),
+            P<bool>("Light Luminance Version", 0x168, ParameterType.BOOL),
+            P<float>("Light Shoulder Strength", 0x174, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Light Linear Strength", 0x178, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Light Linear Angle", 0x17C, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Light Toe Strength", 0x180, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Light Toe Num", 0x184, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Light Toe Denum", 0x188, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Light White Point", 0x18C, ParameterType.FLOAT, pStep(0.01f)),
+            P<float>("Light LUT Blend", 0x1C8, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.01f)),
+            P<float>("Light Vfx LUT Blend", 0x1D0, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.01f)),
+            P<bool>("Light Enable Color Grading", 0x1D8, ParameterType.BOOL),
+            P<bool>("Light Is Linear To PQ", 0x1A1, ParameterType.BOOL),
+            P<bool>("Light Is PQ To Linear", 0x1A0, ParameterType.BOOL),
+            P<float>("Volume Dispersion", 0x19C, ParameterType.FLOAT),
+            P<float>("Volume Edge Sharpness", 0x198, ParameterType.FLOAT, pStep(0.00001f)),
+            P<bool>("Volume Downsample", 0x210, ParameterType.BOOL)
         };
         private static Parameter[] brightnessParameters = {
-            newParameter<float>("Gamma Correct", 0x1C8, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Gamma Correct EX", 0x1CC, ParameterType.FLOAT, pStep(0.001f)),
-            newParameterView<bool>("Hdr Output", 0x21A, ParameterType.BOOL),
-            newParameter<float>("Hdr Output White Level", 0x21C, ParameterType.FLOAT, pStep(0.05f)),
-            newParameter<float>("Hdr Output Gamut Mapping Ratio", 0x220, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Hdr Output Gamma", 0x224, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<bool>("Hdr Is Gui Hdr Gamma", 0x228, ParameterType.BOOL)
-        };
-        private static MtObject? sLightProbes = null;
-        private static Parameter[] sLightProbesParameters = {
-            newParameter<int>("Debug Mode", 0x98, ParameterType.INT, pStep(1))
+            P<float>("Gamma Correct", 0x1C8, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Gamma Correct EX", 0x1CC, ParameterType.FLOAT, pStep(0.001f)),
+            V<bool>("Hdr Output", 0x21A, ParameterType.BOOL),
+            P<float>("Hdr Output White Level", 0x21C, ParameterType.FLOAT, pStep(0.05f)),
+            P<float>("Hdr Output Gamut Mapping Ratio", 0x220, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Hdr Output Gamma", 0x224, ParameterType.FLOAT, pStep(0.001f)),
+            P<bool>("Hdr Is Gui Hdr Gamma", 0x228, ParameterType.BOOL)
         };
 
         private delegate nint CreateBloomObject();
@@ -1779,13 +1810,13 @@ namespace WorldTuningTool
             // can be seen when returning to title or opening a guild card for the first time. Setting 'Bloom Renormalize'
             // to 0.0 or 'Bloom Reduction Resolution' to -1 can both effectively disable bloom without that issue.
             //newFlag<byte>("Bloom Enabled", 0x14, ParameterType.FLAG, (1 << 1)), // Draw
-            newParameter<float>("Bloom Threshold", 0x204, ParameterType.FLOAT),
-            newParameter<float>("Bloom Renormalize", 0x208, ParameterType.FLOAT, pMin(0.0f)),
-            newParameter<int>("Bloom Color", 0x200, ParameterType.COLOR),
-            newParameter<int>("Bloom Downsample Count", 0x168, ParameterType.INT, pMinMaxStep(0, 8, 1)),
-            newParameter<int>("Bloom Reduction Resolution", 0x16C, ParameterType.INT, pStep(1)),
-            newParameter<bool>("Bloom Is SRGB Gamut", 0x214, ParameterType.BOOL),
-            newParameter<bool>("Bloom Compute Luminance", 0x241, ParameterType.BOOL)
+            P<float>("Bloom Threshold", 0x204, ParameterType.FLOAT),
+            P<float>("Bloom Renormalize", 0x208, ParameterType.FLOAT, pMin(0.0f)),
+            P<int>("Bloom Color", 0x200, ParameterType.COLOR),
+            P<int>("Bloom Downsample Count", 0x168, ParameterType.INT, pMinMaxStep(0, 8, 1)),
+            P<int>("Bloom Reduction Resolution", 0x16C, ParameterType.INT, pStep(1)),
+            P<bool>("Bloom Is SRGB Gamut", 0x214, ParameterType.BOOL),
+            P<bool>("Bloom Compute Luminance", 0x241, ParameterType.BOOL)
         };
 
         private delegate nint CreateDofObject();
@@ -1798,25 +1829,25 @@ namespace WorldTuningTool
         private Hook<UpdateDofParams>? updateDofParams;
         private nint dofObject = 0x0;
         private static Parameter[] dofParameters = {
-            newParameter<bool>("Dof Enabled", 0x1DD, ParameterType.BOOL),
-            newParameter<bool>("Dof New Version", 0x1DC, ParameterType.BOOL),
-            newFrameParameter<float>("Dof F Number", 0x1A0, ParameterType.FLOAT, pMinStep(0.0f, 0.001f)),
-            newFrameParameter<float>("Dof Sensor Size", 0x1A4, ParameterType.FLOAT, pStep(0.001f)),
-            newFrameParameter<float>("Dof Focus Distance", 0x1A8, ParameterType.FLOAT, pStep(0.2f)),
-            newParameter<float>("Dof Near Coef", 0x1CC, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Dof Far Coef", 0x1C8, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<bool>("Dof Near Enable", 0x1DE, ParameterType.BOOL),
-            newParameter<bool>("Dof Far Enable", 0x1DF, ParameterType.BOOL),
-            newParameter<bool>("Dof Debug Draw", 0x1E0, ParameterType.BOOL),
-            newParameter<float>("Dof Radius", 0x1D0, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Dof Depth Scale Foreground", 0x1D4, ParameterType.FLOAT, pMinStep(0.0f, 0.0001f)),
-            newParameter<float>("Dof Aspect", 0x1D8, ParameterType.FLOAT, pMinStep(0.0f, 0.001f)),
-            newFrameParameter<bool>("Vignetting Enabled", 0x200, ParameterType.BOOL),
-            newFrameParameter<bool>("Vignetting Ellipse", 0x201, ParameterType.BOOL),
-            newFrameParameter<float>("Vignetting Ellipticity", 0x204, ParameterType.FLOAT, pStep(0.01f)),
-            newFrameParameter<float>("Vignetting Offset", 0x1F8, ParameterType.FLOAT, pStep(0.001f)),
-            newFrameParameter<float>("Vignetting Pow", 0x1FC, ParameterType.FLOAT, pStep(0.01f)),
-            newFrameParameter<int>("Vignetting Color", 0x208, ParameterType.COLOR)
+            P<bool>("Dof Enabled", 0x1DD, ParameterType.BOOL),
+            P<bool>("Dof New Version", 0x1DC, ParameterType.BOOL),
+            P<float>("Dof F Number", 0x1A0, ParameterType.FLOAT, pMinStep(0.0f, 0.001f)),
+            P<float>("Dof Sensor Size", 0x1A4, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Dof Focus Distance", 0x1A8, ParameterType.FLOAT, pStep(0.2f)),
+            P<float>("Dof Near Coef", 0x1CC, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Dof Far Coef", 0x1C8, ParameterType.FLOAT, pStep(0.001f)),
+            P<bool>("Dof Near Enable", 0x1DE, ParameterType.BOOL),
+            P<bool>("Dof Far Enable", 0x1DF, ParameterType.BOOL),
+            P<bool>("Dof Debug Draw", 0x1E0, ParameterType.BOOL),
+            P<float>("Dof Radius", 0x1D0, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Dof Depth Scale Foreground", 0x1D4, ParameterType.FLOAT, pMinStep(0.0f, 0.0001f)),
+            P<float>("Dof Aspect", 0x1D8, ParameterType.FLOAT, pMinStep(0.0f, 0.001f)),
+            P<bool>("Vignetting Enabled", 0x200, ParameterType.BOOL),
+            P<bool>("Vignetting Ellipse", 0x201, ParameterType.BOOL),
+            P<float>("Vignetting Ellipticity", 0x204, ParameterType.FLOAT, pStep(0.01f)),
+            P<float>("Vignetting Offset", 0x1F8, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Vignetting Pow", 0x1FC, ParameterType.FLOAT, pStep(0.01f)),
+            P<int>("Vignetting Color", 0x208, ParameterType.COLOR)
         };
 
         private delegate nint CreateMotionBlurObject();
@@ -1829,11 +1860,11 @@ namespace WorldTuningTool
         private Hook<UpdateMotionBlurParams>? updateMotionBlurParams;
         private nint motionBlurObject = 0x0;
         private static Parameter[] motionBlurParameters = {
-            newParameter<int>("Motion Blur Type", 0x168, ParameterType.INT, pStep(1)),
-            newParameter<int>("Motion Blur Sample Num", 0x180, ParameterType.INT, pMinStep(0, 1)),
-            newFrameParameter<float>("Motion Blur Shutter Speed", 0x184, ParameterType.FLOAT, pMinStep(0.0f, 0.001f)),
-            newParameter<float>("Motion Blur Fur Shutter Speed", 0x188, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Motion Blur Threshold", 0x18C, ParameterType.FLOAT, pMinStep(0.0f, 0.01f))
+            P<int>("Motion Blur Type", 0x168, ParameterType.INT, pStep(1)),
+            P<int>("Motion Blur Sample Num", 0x180, ParameterType.INT, pMinStep(0, 1)),
+            P<float>("Motion Blur Shutter Speed", 0x184, ParameterType.FLOAT, pMinStep(0.0f, 0.001f)),
+            P<float>("Motion Blur Fur Shutter Speed", 0x188, ParameterType.FLOAT, pStep(0.001f)),
+            P<float>("Motion Blur Threshold", 0x18C, ParameterType.FLOAT, pMinStep(0.0f, 0.01f))
         };
 
         private delegate nint CreateSimpleSkyObject(nint unknownPtr);
@@ -1844,108 +1875,108 @@ namespace WorldTuningTool
         private Hook<RenderSimpleSky>? renderSimpleSky;
         private nint simpleSkyObject = 0x0;
         private static Parameter[] simpleSkyParameters = {
-            newParameter<float>("Sky Global Intensity", 0x270, ParameterType.COLOR_FACTOR, pStep(0.001f)),
-            newParameter<float>("Sky Global Cloud Speed", 0x3A8, ParameterType.FLOAT),
-            newParameter<float>("Sky Top Cloud UV Scale[0]", 0x3D0, ParameterType.FLOAT),
-            newParameter<float>("Sky Top Cloud UV Scale[1]", 0x3D8, ParameterType.FLOAT),
-            newParameter<float>("Sky Blend", 0x3B0, ParameterType.FLOAT),
-            newParameter<float>("Sky Water Reflection Factor", 0x7A0, ParameterType.COLOR_FACTOR, pStep(0.001f)),
-            newParameter<bool>("Sky Fog", 0x3B4, ParameterType.BOOL),
-            newParameter<float>("Sky Fog Blend", 0x3B8, ParameterType.FLOAT),
-            newParameter<bool>("Sky DeGamma", 0x3BC, ParameterType.BOOL),
-            newParameter<float>("Sky DeGamma Value", 0x3C0, ParameterType.FLOAT),
-            newParameter<float>("Sky Cloud Highlight Intensity", 0x3C4, ParameterType.FLOAT),
-            newParameter<float>("Sky Cloud Shadow Intensity", 0x3C8, ParameterType.FLOAT),
-            newParameter<float>("Sky Cloud Contrast", 0x3CC, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Map Factor", 0x280, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Sun Size", 0x2A8, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Rotation Y", 0x3A4, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Height", 0x39C, ParameterType.FLOAT, pStep(0.0001f)),
-            newParameter<float>("Sky Sun Light Mask Height Adjustment", 0x3A0, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Light Mask Transparency", 0x2CC, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Light Mask UV Scale", 0x2D0, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Bloom Intensity", 0x2AC, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Bloom Transparency Coefficient", 0x2B0, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Bloom Threshold", 0x2B4, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Bloom Dispersion", 0x2B8, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Bloom Downsample Count", 0x2C0, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Bloom Reduction Resolution", 0x2C4, ParameterType.FLOAT),
-            newParameter<float>("Sky Sun Light Sky Color", 0x2E0, ParameterType.COLOR_FACTOR, pStep(0.001f)),
-            newParameter<float>("Sky Sun Light Sky Mask UV Scale", 0x2F0, ParameterType.FLOAT),
-            newParameter<float>("Sky Base Fov", 0x2BC, ParameterType.FLOAT),
-            newParameter<float>("Sky Base Map Factor", 0x3E0, ParameterType.COLOR_FACTOR, pStep(0.001f)),
-            newParameter<float>("Sky Base Side Cloud UV Offset", 0x3F0, ParameterType.FLOAT),
-            newParameter<float>("Sky Base Top Cloud0 UV Offset", 0x3F8, ParameterType.FLOAT),
-            newParameter<float>("Sky Base Top Cloud1 UV Offset", 0x400, ParameterType.FLOAT),
-            newParameter<float>("Sky Base Sun Cloud Highlight Color[0]", 0x440, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Sun Cloud Shadow Color[0]", 0x480, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Middle Highlight Color[0]", 0x4C0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Middle Shadow Color[0]", 0x500, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Background Highlight Color[0]", 0x540, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Background Shadow Color[0]", 0x580, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Cloud Speed[0]", 0x408, ParameterType.VECTOR2),
-            newParameter<float>("Sky Base Cloud Alpha[0]", 0x428, ParameterType.FLOAT),
-            newParameter<float>("Sky Base Sun Cloud Highlight Color[1]", 0x450, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Sun Cloud Shadow Color[1]", 0x490, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Middle Highlight Color[1]", 0x4D0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Middle Shadow Color[1]", 0x510, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Background Highlight Color[1]", 0x550, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Background Shadow Color[1]", 0x590, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Cloud Speed[1]", 0x410, ParameterType.VECTOR2),
-            newParameter<float>("Sky Base Cloud Alpha[1]", 0x42C, ParameterType.FLOAT),
-            newParameter<float>("Sky Base Sun Cloud Highlight Color[2]", 0x460, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Sun Cloud Shadow Color[2]", 0x4A0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Middle Highlight Color[2]", 0x4E0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Middle Shadow Color[2]", 0x520, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Background Highlight Color[2]", 0x560, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Background Shadow Color[2]", 0x5A0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Cloud Speed[2]", 0x418, ParameterType.VECTOR2),
-            newParameter<float>("Sky Base Cloud Alpha[2]", 0x430, ParameterType.FLOAT),
-            newParameter<float>("Sky Base Sun Cloud Highlight Color[3]", 0x470, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Sun Cloud Shadow Color[3]", 0x4B0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Middle Highlight Color[3]", 0x4F0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Middle Shadow Color[3]", 0x530, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Background Highlight Color[3]", 0x570, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Background Shadow Color[3]", 0x5B0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Base Cloud Speed[3]", 0x420, ParameterType.VECTOR2),
-            newParameter<float>("Sky Base Cloud Alpha[3]", 0x434, ParameterType.FLOAT),
-            newParameter<float>("Sky Blend Base Map Factor", 0x5C0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Side Cloud UV Offset", 0x5D0, ParameterType.FLOAT),
-            newParameter<float>("Sky Blend Top Cloud0 UV Offset", 0x5D8, ParameterType.FLOAT),
-            newParameter<float>("Sky Blend Top Cloud1 UV Offset", 0x5E0, ParameterType.FLOAT),
-            newParameter<float>("Sky Blend Sun Cloud Highlight Color[0]", 0x620, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Sun Cloud Shadow Color[0]", 0x660, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Middle Highlight Color[0]", 0x6A0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Middle Shadow Color[0]", 0x6E0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Background Highlight Color[0]", 0x720, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Background Shadow Color[0]", 0x760, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Cloud Speed[0]", 0x5E8, ParameterType.VECTOR2),
-            newParameter<float>("Sky Blend Cloud Alpha[0]", 0x608, ParameterType.FLOAT),
-            newParameter<float>("Sky Blend Sun Cloud Highlight Color[1]", 0x630, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Sun Cloud Shadow Color[1]", 0x670, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Middle Highlight Color[1]", 0x6B0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Middle Shadow Color[1]", 0x6F0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Background Highlight Color[1]", 0x730, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Background Shadow Color[1]", 0x770, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Cloud Speed[1]", 0x5F0, ParameterType.VECTOR2),
-            newParameter<float>("Sky Blend Cloud Alpha[1]", 0x60C, ParameterType.FLOAT),
-            newParameter<float>("Sky Blend Sun Cloud Highlight Color[2]", 0x640, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Sun Cloud Shadow Color[2]", 0x680, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Middle Highlight Color[2]", 0x6C0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Middle Shadow Color[2]", 0x700, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Background Highlight Color[2]", 0x740, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Background Shadow Color[2]", 0x780, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Cloud Speed[2]", 0x5F8, ParameterType.VECTOR2),
-            newParameter<float>("Sky Blend Cloud Alpha[2]", 0x610, ParameterType.FLOAT),
-            newParameter<float>("Sky Blend Sun Cloud Highlight Color[3]", 0x650, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Sun Cloud Shadow Color[3]", 0x690, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Middle Highlight Color[3]", 0x6D0, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Middle Shadow Color[3]", 0x710, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Background Highlight Color[3]", 0x750, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Background Shadow Color[3]", 0x790, ParameterType.COLOR_FACTOR),
-            newParameter<float>("Sky Blend Cloud Speed[3]", 0x600, ParameterType.VECTOR2),
-            newParameter<float>("Sky Blend Cloud Alpha[3]", 0x614, ParameterType.FLOAT),
-            newParameter<float>("Sky Starry Sky Map Factor", 0x290, ParameterType.COLOR_FACTOR, pStep(0.001f)),
+            P<float>("Sky Global Intensity", 0x270, ParameterType.COLOR_FACTOR, pStep(0.001f)),
+            P<float>("Sky Global Cloud Speed", 0x3A8, ParameterType.FLOAT),
+            P<float>("Sky Top Cloud UV Scale[0]", 0x3D0, ParameterType.FLOAT),
+            P<float>("Sky Top Cloud UV Scale[1]", 0x3D8, ParameterType.FLOAT),
+            P<float>("Sky Blend", 0x3B0, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.0025f)),
+            P<float>("Sky Water Reflection Factor", 0x7A0, ParameterType.COLOR_FACTOR, pStep(0.001f)),
+            P<bool>("Sky Fog", 0x3B4, ParameterType.BOOL),
+            P<float>("Sky Fog Blend", 0x3B8, ParameterType.FLOAT),
+            P<bool>("Sky DeGamma", 0x3BC, ParameterType.BOOL),
+            P<float>("Sky DeGamma Value", 0x3C0, ParameterType.FLOAT),
+            P<float>("Sky Cloud Highlight Intensity", 0x3C4, ParameterType.FLOAT),
+            P<float>("Sky Cloud Shadow Intensity", 0x3C8, ParameterType.FLOAT),
+            P<float>("Sky Cloud Contrast", 0x3CC, ParameterType.FLOAT),
+            P<float>("Sky Sun Map Factor", 0x280, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Sun Size", 0x2A8, ParameterType.FLOAT),
+            P<float>("Sky Sun Rotation Y", 0x3A4, ParameterType.FLOAT),
+            P<float>("Sky Sun Height", 0x39C, ParameterType.FLOAT, pStep(0.0001f)),
+            P<float>("Sky Sun Light Mask Height Adjustment", 0x3A0, ParameterType.FLOAT),
+            P<float>("Sky Sun Light Mask Transparency", 0x2CC, ParameterType.FLOAT),
+            P<float>("Sky Sun Light Mask UV Scale", 0x2D0, ParameterType.FLOAT),
+            P<float>("Sky Sun Bloom Intensity", 0x2AC, ParameterType.FLOAT),
+            P<float>("Sky Sun Bloom Transparency Coefficient", 0x2B0, ParameterType.FLOAT),
+            P<float>("Sky Sun Bloom Threshold", 0x2B4, ParameterType.FLOAT),
+            P<float>("Sky Sun Bloom Dispersion", 0x2B8, ParameterType.FLOAT),
+            P<float>("Sky Sun Bloom Downsample Count", 0x2C0, ParameterType.FLOAT),
+            P<float>("Sky Sun Bloom Reduction Resolution", 0x2C4, ParameterType.FLOAT),
+            P<float>("Sky Sun Light Sky Color", 0x2E0, ParameterType.COLOR_FACTOR, pStep(0.001f)),
+            P<float>("Sky Sun Light Sky Mask UV Scale", 0x2F0, ParameterType.FLOAT),
+            P<float>("Sky Base Fov", 0x2BC, ParameterType.FLOAT),
+            P<float>("Sky Base Map Factor", 0x3E0, ParameterType.COLOR_FACTOR, pStep(0.001f)),
+            P<float>("Sky Base Side Cloud UV Offset", 0x3F0, ParameterType.FLOAT),
+            P<float>("Sky Base Top Cloud0 UV Offset", 0x3F8, ParameterType.FLOAT),
+            P<float>("Sky Base Top Cloud1 UV Offset", 0x400, ParameterType.FLOAT),
+            P<float>("Sky Base Sun Cloud Highlight Color[0]", 0x440, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Sun Cloud Shadow Color[0]", 0x480, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Middle Highlight Color[0]", 0x4C0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Middle Shadow Color[0]", 0x500, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Background Highlight Color[0]", 0x540, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Background Shadow Color[0]", 0x580, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Cloud Speed[0]", 0x408, ParameterType.VECTOR2),
+            P<float>("Sky Base Cloud Alpha[0]", 0x428, ParameterType.FLOAT),
+            P<float>("Sky Base Sun Cloud Highlight Color[1]", 0x450, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Sun Cloud Shadow Color[1]", 0x490, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Middle Highlight Color[1]", 0x4D0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Middle Shadow Color[1]", 0x510, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Background Highlight Color[1]", 0x550, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Background Shadow Color[1]", 0x590, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Cloud Speed[1]", 0x410, ParameterType.VECTOR2),
+            P<float>("Sky Base Cloud Alpha[1]", 0x42C, ParameterType.FLOAT),
+            P<float>("Sky Base Sun Cloud Highlight Color[2]", 0x460, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Sun Cloud Shadow Color[2]", 0x4A0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Middle Highlight Color[2]", 0x4E0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Middle Shadow Color[2]", 0x520, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Background Highlight Color[2]", 0x560, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Background Shadow Color[2]", 0x5A0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Cloud Speed[2]", 0x418, ParameterType.VECTOR2),
+            P<float>("Sky Base Cloud Alpha[2]", 0x430, ParameterType.FLOAT),
+            P<float>("Sky Base Sun Cloud Highlight Color[3]", 0x470, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Sun Cloud Shadow Color[3]", 0x4B0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Middle Highlight Color[3]", 0x4F0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Middle Shadow Color[3]", 0x530, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Background Highlight Color[3]", 0x570, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Background Shadow Color[3]", 0x5B0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Base Cloud Speed[3]", 0x420, ParameterType.VECTOR2),
+            P<float>("Sky Base Cloud Alpha[3]", 0x434, ParameterType.FLOAT),
+            P<float>("Sky Blend Base Map Factor", 0x5C0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Side Cloud UV Offset", 0x5D0, ParameterType.FLOAT),
+            P<float>("Sky Blend Top Cloud0 UV Offset", 0x5D8, ParameterType.FLOAT),
+            P<float>("Sky Blend Top Cloud1 UV Offset", 0x5E0, ParameterType.FLOAT),
+            P<float>("Sky Blend Sun Cloud Highlight Color[0]", 0x620, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Sun Cloud Shadow Color[0]", 0x660, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Middle Highlight Color[0]", 0x6A0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Middle Shadow Color[0]", 0x6E0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Background Highlight Color[0]", 0x720, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Background Shadow Color[0]", 0x760, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Cloud Speed[0]", 0x5E8, ParameterType.VECTOR2),
+            P<float>("Sky Blend Cloud Alpha[0]", 0x608, ParameterType.FLOAT),
+            P<float>("Sky Blend Sun Cloud Highlight Color[1]", 0x630, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Sun Cloud Shadow Color[1]", 0x670, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Middle Highlight Color[1]", 0x6B0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Middle Shadow Color[1]", 0x6F0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Background Highlight Color[1]", 0x730, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Background Shadow Color[1]", 0x770, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Cloud Speed[1]", 0x5F0, ParameterType.VECTOR2),
+            P<float>("Sky Blend Cloud Alpha[1]", 0x60C, ParameterType.FLOAT),
+            P<float>("Sky Blend Sun Cloud Highlight Color[2]", 0x640, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Sun Cloud Shadow Color[2]", 0x680, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Middle Highlight Color[2]", 0x6C0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Middle Shadow Color[2]", 0x700, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Background Highlight Color[2]", 0x740, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Background Shadow Color[2]", 0x780, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Cloud Speed[2]", 0x5F8, ParameterType.VECTOR2),
+            P<float>("Sky Blend Cloud Alpha[2]", 0x610, ParameterType.FLOAT),
+            P<float>("Sky Blend Sun Cloud Highlight Color[3]", 0x650, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Sun Cloud Shadow Color[3]", 0x690, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Middle Highlight Color[3]", 0x6D0, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Middle Shadow Color[3]", 0x710, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Background Highlight Color[3]", 0x750, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Background Shadow Color[3]", 0x790, ParameterType.COLOR_FACTOR),
+            P<float>("Sky Blend Cloud Speed[3]", 0x600, ParameterType.VECTOR2),
+            P<float>("Sky Blend Cloud Alpha[3]", 0x614, ParameterType.FLOAT),
+            P<float>("Sky Starry Sky Map Factor", 0x290, ParameterType.COLOR_FACTOR, pStep(0.001f)),
         };
 
         private delegate nint CreateFogObject();
@@ -1958,8 +1989,8 @@ namespace WorldTuningTool
         private Hook<UpdateFogParams>? updateFogParams;
         private nint fogObject = 0x0;
         private static Parameter[] fogParameters = {
-            newParameter<float>("Fog Mip Fog Intensity", 0x2C0, ParameterType.FLOAT, pStep(0.001f)),
-            newParameter<float>("Fog Mip Fog Color", 0x330, ParameterType.COLOR_FACTOR, pStep(0.001f))
+            P<float>("Fog Mip Fog Intensity", 0x2C0, ParameterType.FLOAT, pStep(0.0025f)),
+            P<float>("Fog Mip Fog Color", 0x330, ParameterType.COLOR_FACTOR, pStep(0.001f))
         };
 
         private delegate nint CreateWaterWaveObject(nint unknownPtr);
@@ -1968,9 +1999,9 @@ namespace WorldTuningTool
         private Hook<DestroyWaterWaveObject>? destroyWaterWaveObject;
         private nint waterWaveObject = 0x0;
         private static Parameter[] waterWaveParameters = {
-            newParameter<float>("Water Murkiness", 0x40C, ParameterType.FLOAT),
-            newParameter<int>("Water Color", 0x404, ParameterType.COLOR),
-            newParameter<float>("Water Scattering Intensity", 0x408, ParameterType.FLOAT, pStep(0.001f))
+            P<float>("Water Murkiness", 0x40C, ParameterType.FLOAT),
+            P<int>("Water Color", 0x404, ParameterType.COLOR),
+            P<float>("Water Scattering Intensity", 0x408, ParameterType.FLOAT, pStep(0.001f))
         };
 
         private delegate nint CreateFXAAObject();
@@ -1981,9 +2012,9 @@ namespace WorldTuningTool
         private Hook<DestroyFXAAObject>? destroyFXAAObject;
         private nint fxaaObject = 0x0;
         private static Parameter[] fxaaParameters = {
-            newParameter<float>("FXAA Subpix", 0x178, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.005f)),
-            newParameter<float>("FXAA Edge Threshold", 0x17C, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.001f)),
-            newParameter<float>("FXAA Edge Threshold Min", 0x180, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.001f))
+            P<float>("FXAA Subpix", 0x178, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.005f)),
+            P<float>("FXAA Edge Threshold", 0x17C, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.001f)),
+            P<float>("FXAA Edge Threshold Min", 0x180, ParameterType.FLOAT, pMinMaxStep(0.0f, 1.0f, 0.001f))
         };
 
         private delegate nint CreateTAAObject();
@@ -1994,13 +2025,13 @@ namespace WorldTuningTool
         private Hook<DestroyTAAObject>? destroyTAAObject;
         private nint taaObject = 0x0;
         private static Parameter[] taaParameters = {
-            newParameter<bool>("TAA Reprojection", 0x19D, ParameterType.BOOL),
-            newParameter<bool>("TAA Jitter Enable", 0x184, ParameterType.BOOL),
-            newParameter<float>("TAA Blend Rate", 0x180, ParameterType.FLOAT),
-            newParameter<float>("TAA Variance Gamma", 0x194, ParameterType.FLOAT),
-            newParameter<bool>("TAA Sharpen", 0x187, ParameterType.BOOL),
-            newParameter<float>("TAA Sharpen Amount", 0x198, ParameterType.FLOAT),
-            newParameter<bool>("TAA Sharpend Ignore Edges", 0x19C, ParameterType.BOOL)
+            P<bool>("TAA Reprojection", 0x19D, ParameterType.BOOL),
+            P<bool>("TAA Jitter Enable", 0x184, ParameterType.BOOL),
+            P<float>("TAA Blend Rate", 0x180, ParameterType.FLOAT),
+            P<float>("TAA Variance Gamma", 0x194, ParameterType.FLOAT),
+            P<bool>("TAA Sharpen", 0x187, ParameterType.BOOL),
+            P<float>("TAA Sharpen Amount", 0x198, ParameterType.FLOAT),
+            P<bool>("TAA Sharpend Ignore Edges", 0x19C, ParameterType.BOOL)
         };
 
         private static Parameter[] allParameters = new Parameter[]{ hqMode }
@@ -2010,6 +2041,7 @@ namespace WorldTuningTool
             .Concat(shadowParameters2)
             .Concat(shadowCascadeParameters)
             .Concat(broadAreaShadowParameters)
+            .Concat(sLightProbesParameters)
             .Concat(contactShadowParameters)
             .Concat(capsuleLightParameters)
             .Concat(ssaoParameters)
@@ -2017,7 +2049,6 @@ namespace WorldTuningTool
             .Concat(passthroughParameters)
             .Concat(lightingParameters)
             .Concat(brightnessParameters)
-            .Concat(sLightProbesParameters)
             .Concat(bloomParameters)
             .Concat(dofParameters)
             .Concat(motionBlurParameters)
@@ -2338,7 +2369,7 @@ namespace WorldTuningTool
 
             onAreaChange = Hook.Create<OnAreaChange>(0x141AC27D0, OnAreaChangeHook); // nint
 
-            // Needed for at least "Broad Area Shadow Dir". Otherwise it will flicker on center change.
+            // Needed for at least "Broad Area Shadow Direction". Otherwise it will flicker on center change.
             evalSceneParams = Hook.Create<EvalSceneParams>(0x1423C3790, EvalSceneParamsHook); // nint, nint, int, nint
 
             // Light Dir XZY is updated seperately at 0x1420397F0, we assume this function always happens later, though.
@@ -2347,11 +2378,12 @@ namespace WorldTuningTool
             // These run in a loop during cutscenes.
             updateSSAOParams = Hook.Create<UpdateSSAOParams>(0x1416D8B10, UpdateSSAOParamsHook); // nint
             updateSSLRParams = Hook.Create<UpdateSSLRParams>(0x1416DA3F0, UpdateSSLRParamsHook); // nint
-            updateLightingParams = Hook.Create<UpdateLightingParameters>(0x1416DAAB0, UpdateLightingParametersHook); // nint, nint
+            updateLightingParams = Hook.Create<UpdateLightingParams>(0x1416DAAB0, UpdateLightingParamsHook); // nint, nint
 
             createLightingObject = Hook.Create<CreateLightingObject>(0x1424CDE20, CreateLightingObjectHook);
             destroyLightingObject = Hook.Create<DestroyLightingObject>(0x1424CE380, DestroyLightingObjectHook); // nint, int
-            updateLutBlend = Hook.Create<UpdateLightingParameters>(0x1416D8DF0, UpdateLutBlendHook); // nint, nint
+            updateLutBlend = Hook.Create<UpdateLightingParams>(0x1416D8DF0, UpdateLutBlendHook); // nint, nint
+            updateLightProbesParams = Hook.Create<UpdateLightProbesParams>(0x141AB92C0, UpdateLightProbesParamsHook); // nint, int
 
             createBloomObject = Hook.Create<CreateBloomObject>(0x1424CB3C0, CreateBloomObjectHook);
             createBloomObject2 = Hook.Create<CreateBloomObject2>(0x1424CB5E0, CreateBloomObject2Hook); // nint
@@ -2656,6 +2688,10 @@ namespace WorldTuningTool
             sMhRender = SingletonManager.GetSingleton("sMhRender")!;
             sMhScene = SingletonManager.GetSingleton("sMhScene")!;
             sLightProbes = SingletonManager.GetSingleton("sLightProbes")!;
+            foreach (Parameter param in sLightProbesParameters)
+            {
+                param.Update(sLightProbes!.Instance);
+            }
             Config config = getConfig();
             if (config.SelectedGlobal == "")
             {
@@ -2737,22 +2773,22 @@ namespace WorldTuningTool
                 param.Update(sMhScene!.Instance);
             }
 
-            foreach (Parameter param in passthroughParameters)
+            foreach (Parameter param in snowParameters)
             {
                 param.Update(sMhScene!.Instance);
             }
 
-            foreach (Parameter param in shadowCascadeParameters)
+            foreach (Parameter param in passthroughParameters)
             {
                 param.Update(sMhScene!.Instance);
             }
 
-            foreach (Parameter param in contactShadowParameters)
+            foreach (Parameter param in shadowCascadeParameters)
             {
                 param.Update(sMhScene!.Instance);
             }
 
-            foreach (Parameter param in snowParameters)
+            foreach (Parameter param in contactShadowParameters)
             {
                 param.Update(sMhScene!.Instance);
             }
@@ -2775,11 +2811,6 @@ namespace WorldTuningTool
                 }
             }
 
-            foreach (Parameter param in sLightProbesParameters)
-            {
-                param.Update(sLightProbes!.Instance);
-            }
-
             foreach (Parameter param in brightnessParameters)
             {
                 param.Update(sMhRender!.Instance);
@@ -2797,10 +2828,7 @@ namespace WorldTuningTool
             {
                 foreach (Parameter param in dofParameters)
                 {
-                    if (!param.PerFrame)
-                    {
-                        param.Update(dofObject);
-                    }
+                    param.Update(dofObject);
                 }
             }
 
@@ -2808,10 +2836,15 @@ namespace WorldTuningTool
             {
                 foreach (Parameter param in motionBlurParameters)
                 {
-                    if (!param.PerFrame)
-                    {
-                        param.Update(motionBlurObject);
-                    }
+                    param.Update(motionBlurObject);
+                }
+            }
+
+            if (waterWaveObject != 0x0)
+            {
+                foreach (Parameter param in waterWaveParameters)
+                {
+                    param.Update(waterWaveObject);
                 }
             }
 
@@ -2830,14 +2863,6 @@ namespace WorldTuningTool
                     param.Update(taaObject);
                 }
             }
-
-            if (waterWaveObject != 0x0)
-            {
-                foreach (Parameter param in waterWaveParameters)
-                {
-                    param.Update(waterWaveObject);
-                }
-            }
         }
 
         private void EvalSceneParamsHook(nint unknownPtr, nint unknownPtr2, int unknownInt, nint unknownPtr3)
@@ -2876,7 +2901,7 @@ namespace WorldTuningTool
             }
         }
 
-        private void UpdateLightingParametersHook(nint stackOffset, nint lightingObjectInternal)
+        private void UpdateLightingParamsHook(nint stackOffset, nint lightingObjectInternal)
         {
             updateLightingParams!.Original(stackOffset, lightingObjectInternal);
             if (lightingObject == lightingObjectInternal)
@@ -2919,14 +2944,20 @@ namespace WorldTuningTool
             {
                 foreach (Parameter param in lightingParameters)
                 {
-                    if (param.PerFrame)
-                    {
-                        param.Update(lightingObject, true);
-                    }
+                    param.Update(lightingObject, true);
                 }
             }
         }
 
+        private void UpdateLightProbesParamsHook(nint unknownPtr, int unknownInt)
+        {
+            updateLightProbesParams!.Original(unknownPtr, unknownInt);
+            foreach (Parameter param in sLightProbesParameters)
+            {
+                param.Update(sLightProbes!.Instance);
+            }
+        }
+
         private nint CreateBloomObjectHook()
         {
             bloomObject = createBloomObject!.Original();
@@ -3000,10 +3031,7 @@ namespace WorldTuningTool
             updateDofParams!.Original(unknownPtr);
             foreach (Parameter param in dofParameters)
             {
-                if (param.PerFrame)
-                {
-                    param.Update(dofObject, true);
-                }
+                param.Update(dofObject, true);
             }
         }
 
@@ -3045,10 +3073,7 @@ namespace WorldTuningTool
         {
             foreach (Parameter param in motionBlurParameters)
             {
-                if (param.PerFrame)
-                {
-                    param.Update(motionBlurObject, true);
-                }
+                param.Update(motionBlurObject, true);
             }
             updateMotionBlurParams!.Original(unknownPtr, unknownPtr2);
         }
@@ -3228,10 +3253,7 @@ namespace WorldTuningTool
             {
                 foreach (Parameter param in shadowParameters2)
                 {
-                    if (param.PerFrame)
-                    {
-                        param.Update(stackOffset, true);
-                    }
+                    param.Update(stackOffset, true);
                 }
             }
             updateShadowParams!.Original(shadowParams, stackOffset);
@@ -3244,20 +3266,7 @@ namespace WorldTuningTool
                 // Necessary to apply Broad Area Depth Bias overrides on first update.
                 foreach (Parameter param in shadowParameters2)
                 {
-                    if (param.PerFrame)
-                    {
-                        param.Update(shadowParamsStatic, true);
-                    }
-                }
-            }
-            else
-            {
-                foreach (Parameter param in shadowParameters2)
-                {
-                    if (!param.PerFrame)
-                    {
-                        param.Update(shadowObjectInternal, true);
-                    }
+                    param.Update(shadowParamsStatic, true);
                 }
             }
             staticShadowParams!.Original(shadowParamsStatic, shadowObjectInternal);
@@ -3908,7 +3917,7 @@ namespace WorldTuningTool
                 {
                     shadowResParameter.Draw(width);
                     ImGui.Separator();
-                    ImGui.Text($"shadowObject: 0x{shadowAddr:X}, shadowAddr: 0x{shadowObject:X}");
+                    ImGui.Text($"shadowAddr: 0x{shadowAddr:X}, shadowObject: 0x{shadowObject:X}");
                     /*
                     if (ImGui.CollapsingHeader("Pass 1"))
                     {
@@ -3951,6 +3960,17 @@ namespace WorldTuningTool
                 }
                 ImGui.PopID();
 
+                ImGui.PushID("LightProbes");
+                if (ImGui.CollapsingHeader("Light Probes"))
+                {
+                    ImGui.Text($"Address: 0x{sLightProbes!.Instance:X}");
+                    foreach (Parameter param in sLightProbesParameters)
+                    {
+                        param.Draw(width);
+                    }
+                }
+                ImGui.PopID();
+
                 ImGui.PushID("ContactLight");
                 if (ImGui.CollapsingHeader("Contact Light"))
                 {
@@ -4031,12 +4051,6 @@ namespace WorldTuningTool
                     {
                         param.Draw(width);
                     }
-                    ImGui.Separator();
-                    ImGui.Text($"Address: 0x{sLightProbes!.Instance:X}");
-                    foreach (Parameter param in sLightProbesParameters)
-                    {
-                        param.Draw(width);
-                    }
                 }
                 ImGui.PopID();
 
@@ -4110,8 +4124,8 @@ namespace WorldTuningTool
                 }
                 ImGui.PopID();
 
-                ImGui.PushID("Water");
-                if (ImGui.CollapsingHeader("Water"))
+                ImGui.PushID("WaterWave");
+                if (ImGui.CollapsingHeader("Water Waves"))
                 {
                     ImGui.Text($"Address: 0x{waterWaveObject:X}");
                     if (waterWaveObject != 0x0)
@@ -4195,6 +4209,8 @@ namespace WorldTuningTool
                         ImGui.EndTooltip();
                     }
 
+                    lights.DrawDebug(width);
+
                     ImGui.Separator();
                 }
 
@@ -4304,7 +4320,8 @@ namespace WorldTuningTool
             /*
             else if (hash == "18a797dc-9458d333-59e6dff0-9790fcea")
             {
-                if (replaceShaderFromFile(info, $"{shaderPath}/sssss.shdr")) {
+                if (replaceShaderFromFile(info, $"{shaderPath}/sssss.shdr"))
+                {
                     info->Replacement.Type = ShaderSourceType.Binary;
                     Log.Info("SSSSS shader replaced.");
                 }
@@ -4313,7 +4330,8 @@ namespace WorldTuningTool
             /*
             else if (hash == "ca33bab6-2119df84-41786a69-404471cd")
             {
-                if (replaceShaderFromFile(info, $"{shaderPath}/color_grading.shdr")) {
+                if (replaceShaderFromFile(info, $"{shaderPath}/color_grading.shdr"))
+                {
                     info->Replacement.Type = ShaderSourceType.Binary;
                     Log.Info("Color grading shader replaced.");
                 }