Massively improve update hooks, work on lights

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

1 files changed, 183 insertions, 125 deletions

diff --git a/Plugin.cs b/Plugin.cs
index 9cb230e..111eb09 100644
--- a/Plugin.cs
+++ b/Plugin.cs
@@ -199,7 +199,7 @@ namespace WorldTuningTool
             configState = 0;
         }
 
-        private const float defaultParamWidth = 0.215f;
+        private const float defaultParamWidth = 0.21f;
 
         private static bool ignoreMinMax = false;
 
@@ -881,13 +881,19 @@ namespace WorldTuningTool
                         Vector3 v3 = new Vector3(v4.X, v4.Y, v4.Z);
                         if (Type == ParameterType.COLOR_FACTOR)
                         {
-                            Vector3 v3Scale = Vector3.Abs(v3);
-                            float max = MathF.Max(v3.X, MathF.Max(v3.Y, v3.Z));
-                            if (max != 0.0f)
+                            Vector3 v3Color = v3;
+                            // Only scale the color vector if max is unbound. Otherwise, assume that intensity and color are combined.
+                            if (maxf == Single.MaxValue)
                             {
-                                v3Scale = (v3Scale / max) * v3Scale;
+                                float v3Max = MathF.Max(Math.Abs(v3.X), MathF.Max(Math.Abs(v3.Y), Math.Abs(v3.Z)));
+                                if (v3Max != 0.0f)
+                                {
+                                    // I believe a compromise is needed here. These are the options I can think of.
+                                    //v3Color /= v3Max; // Preview will be full "brightness" at low intensities.
+                                    v3Color = v3Color * (v3Color / v3Max); // Preview will converge towards white at high intensities.
+                                }
                             }
-                            ImGui.ColorEdit3(label, ref v3Scale, ImGuiColorEditFlags.NoPicker | ImGuiColorEditFlags.NoLabel | ImGuiColorEditFlags.NoInputs);
+                            ImGui.ColorEdit3(label, ref v3Color, ImGuiColorEditFlags.NoPicker | ImGuiColorEditFlags.NoLabel | ImGuiColorEditFlags.NoInputs);
                             ImGui.SameLine();
                         }
                         ImGui.SetNextItemWidth(width * defaultParamWidth * 3.0f);
@@ -1541,6 +1547,24 @@ namespace WorldTuningTool
         private delegate void OnAreaChange(nint unknownPtr);
         private Hook<OnAreaChange>? onAreaChange;
 
+        private delegate void UpdateUnits(nint sMhUnit);
+        private Hook<UpdateUnits>? updateUnits;
+
+        private delegate void UpdateLightLinker(nint sLightLinker);
+        private Hook<UpdateLightLinker>? updateLightLinker;
+
+        private delegate void EvaluateSceneParams(nint unknownPtr, nint unknownPtr2, int unknownInt, nint unknownPtr3);
+        private Hook<EvaluateSceneParams>? evaluateSceneParams;
+
+        private delegate void UpdateSSAOParams(nint stackOffset);
+        private Hook<UpdateSSAOParams>? updateSSAOParams;
+
+        private delegate void UpdateSSLRParams(nint stackOffset);
+        private Hook<UpdateSSLRParams>? updateSSLRParams;
+
+        private delegate void UpdateLightingParams(nint stackOffset, nint lightingObjectInternal);
+        private Hook<UpdateLightingParams>? updateLightingParams;
+
         private static bool InTransition = false;
         private static List<Parameter> DirtyParams = new List<Parameter>();
         private static void BeginTransition()
@@ -1562,11 +1586,23 @@ namespace WorldTuningTool
         private static MtObject? sMhScene = null;
         private static MtObject? sMhMain = null;
         private static MtObject? sMhRender = null;
+        private static MtObject? sTime = null;
+        private static MtObject? sQuest = null;
+        private static MtObject? sLightLinker = null;
 
+        private static bool disableLightsFeature = false;
         private static Lights lights = new Lights();
 
         private static Parameter hqMode = P<bool>("HQ Mode", 0xE9A3, ParameterType.BOOL);
 
+        private static bool setWeatherMode = false;
+        private static int requestWeatherMode = 1;
+        private static Parameter[] sTimeParameters = {
+            P<float>("Time", 0x38, ParameterType.FLOAT, pMinMaxStep(0.0f, 24.0f, 0.005f)),
+            P<bool>("Time Moving", 0x70, ParameterType.BOOL),
+            V<int>("Weather", 0x8C, ParameterType.INT)
+        };
+
         private static Parameter[] lodParameters = {
             P<float>("LOD Bias 1", 0x21C, ParameterType.FLOAT, pMin(0.0f)),
             P<float>("LOD Bias 2", 0x220, ParameterType.FLOAT, pMin(0.0f)),
@@ -1604,8 +1640,6 @@ namespace WorldTuningTool
             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 = {
             P<bool>("Broad Area Shadow Enable", 0x5534, ParameterType.BOOL),
             P<float>("Broad Area Shadow Center", 0x5540 + 0x40, ParameterType.VECTOR3),
@@ -1628,8 +1662,6 @@ namespace WorldTuningTool
             P<float>("Contact Shadow Accept Minimum Length", 0xB4FC, ParameterType.FLOAT)
         };
 
-        private delegate void UpdateCapsuleAOParams(nint sceneObjectInternal);
-        private Hook<UpdateCapsuleAOParams>? updateCapsuleAoParams;
         private static Parameter[] capsuleLightParameters = {
             P<bool>("Force Disable Capsule AO", 0xB503, ParameterType.BOOL),
             P<bool>("Capsule AO Enabled", 0xB502, ParameterType.BOOL),
@@ -1641,8 +1673,6 @@ namespace WorldTuningTool
             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 = {
             P<float>("SSAO Depth Bias", 0xB4B0, ParameterType.FLOAT, pStep(0.00001f)),
             P<float>("SSAO Sloped Depth Bias", 0xB4B4, ParameterType.FLOAT, pStep(0.00001f)),
@@ -1661,8 +1691,6 @@ namespace WorldTuningTool
             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 = {
             P<int>("SSLR Loop Count", 0xE628, ParameterType.INT, pStep(1)),
             P<float>("SSLR Loop Count Factor for CBR", 0xE62C, ParameterType.FLOAT),
@@ -1689,13 +1717,13 @@ namespace WorldTuningTool
         private Hook<StaticShadowParams>? staticShadowParams;
         private static Parameter[] shadowParameters1 = {
         };
-        // This is actually an InfiniteLight object.
+        // These are parameters for an Infinite Light object (uSdlInfinite @ 0x143343038).
         // "Min Roughness" is +0xFC in params but is never read.
         private static Parameter[] shadowParameters2 = {
             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<float>("Sunlight Intensity", 0xF4, ParameterType.FLOAT, pStep(0.005f)),
             P<bool>("Sunlight Is Primary", 0x1D, ParameterType.BOOL),
             P<bool>("Do Volumetric", 0x1F, ParameterType.BOOL),
             P<bool>("Shadow Cast", 0x23, ParameterType.BOOL),
@@ -1739,7 +1767,6 @@ namespace WorldTuningTool
 
         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),
@@ -1764,9 +1791,6 @@ namespace WorldTuningTool
         private Hook<CreateLightingObject>? createLightingObject;
         private Hook<DestroyLightingObject>? destroyLightingObject;
         private nint lightingObject = 0x0;
-        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 = {
             P<int>("Light Tone Map Type", 0x16C, ParameterType.INT, pMinMaxStep(1, 6, 1)),
@@ -1825,8 +1849,6 @@ namespace WorldTuningTool
         private Hook<CreateDofObject>? createDofObject;
         private Hook<CreateDofObject2>? createDofObject2;
         private Hook<DestroyDofObject>? destroyDofObject;
-        private delegate void UpdateDofParams(nint unknownPtr);
-        private Hook<UpdateDofParams>? updateDofParams;
         private nint dofObject = 0x0;
         private static Parameter[] dofParameters = {
             P<bool>("Dof Enabled", 0x1DD, ParameterType.BOOL),
@@ -1856,8 +1878,6 @@ namespace WorldTuningTool
         private Hook<CreateMotionBlurObject>? createMotionBlurObject;
         private Hook<CreateMotionBlurObject2>? createMotionBlurObject2;
         private Hook<DestroyMotionBlurObject>? destroyMotionBlurObject;
-        private delegate void UpdateMotionBlurParams(nint unknownPtr, nint unknownPtr2);
-        private Hook<UpdateMotionBlurParams>? updateMotionBlurParams;
         private nint motionBlurObject = 0x0;
         private static Parameter[] motionBlurParameters = {
             P<int>("Motion Blur Type", 0x168, ParameterType.INT, pStep(1)),
@@ -1872,7 +1892,6 @@ namespace WorldTuningTool
         private delegate void RenderSimpleSky(nint simpleSkyObjectInternal, nint unknownPtr);
         private Hook<CreateSimpleSkyObject>? createSimpleSkyObject;
         private Hook<DestroySimpleSkyObject>? destroySimpleSkyObject;
-        private Hook<RenderSimpleSky>? renderSimpleSky;
         private nint simpleSkyObject = 0x0;
         private static Parameter[] simpleSkyParameters = {
             P<float>("Sky Global Intensity", 0x270, ParameterType.COLOR_FACTOR, pStep(0.001f)),
@@ -1985,8 +2004,6 @@ namespace WorldTuningTool
         private Hook<CreateFogObject>? createFogObject;
         private Hook<CreateFogObject2>? createFogObject2;
         private Hook<DestroyFogObject>? destroyFogObject;
-        private delegate void UpdateFogParams(nint unknownPtr, int unknownInt);
-        private Hook<UpdateFogParams>? updateFogParams;
         private nint fogObject = 0x0;
         private static Parameter[] fogParameters = {
             P<float>("Fog Mip Fog Intensity", 0x2C0, ParameterType.FLOAT, pStep(0.0025f)),
@@ -2035,6 +2052,7 @@ namespace WorldTuningTool
         };
 
         private static Parameter[] allParameters = new Parameter[]{ hqMode }
+            .Concat(sTimeParameters)
             .Concat(lodParameters)
             .Concat(snowParameters)
             .Append(shadowResParameter)
@@ -2302,6 +2320,9 @@ namespace WorldTuningTool
         private bool disableReducedRateAnimations = false;
         private Patch zeroFrameSkip;
 
+        private bool nukeEffects = false;
+        private Patch jmpOverEffects;
+
         public int AddOverride(string name, Vector4 v4, int i1)
         {
             foreach (Parameter param in allParameters)
@@ -2369,11 +2390,12 @@ namespace WorldTuningTool
 
             onAreaChange = Hook.Create<OnAreaChange>(0x141AC27D0, OnAreaChangeHook); // nint
 
-            // 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.
-            updateCapsuleAoParams = Hook.Create<UpdateCapsuleAOParams>(0x141B19E10, UpdateCapsuleAOParamsHook); // nint
+            updateUnits = Hook.Create<UpdateUnits>(0x14221B360, UpdateUnitsHook); // nint
+            updateLightLinker = Hook.Create<UpdateLightLinker>(0x141AB8310, UpdateLightLinkerHook);
+            // Used for:
+            //  "Capsule AO Intensity".
+            //  "Broad Area Shadow Direction". Otherwise it will flicker on center change.
+            evaluateSceneParams = Hook.Create<EvaluateSceneParams>(0x1423C3790, EvaluateSceneParamsHook); // nint, nint, int, nint
 
             // These run in a loop during cutscenes.
             updateSSAOParams = Hook.Create<UpdateSSAOParams>(0x1416D8B10, UpdateSSAOParamsHook); // nint
@@ -2382,8 +2404,6 @@ namespace WorldTuningTool
 
             createLightingObject = Hook.Create<CreateLightingObject>(0x1424CDE20, CreateLightingObjectHook);
             destroyLightingObject = Hook.Create<DestroyLightingObject>(0x1424CE380, DestroyLightingObjectHook); // nint, int
-            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
@@ -2392,21 +2412,17 @@ namespace WorldTuningTool
             createDofObject = Hook.Create<CreateDofObject>(0x142421E80, CreateDofObjectHook);
             createDofObject2 = Hook.Create<CreateDofObject2>(0x1424220A0, CreateDofObject2Hook); // nint
             destroyDofObject = Hook.Create<DestroyDofObject>(0x142422290, DestroyDofObjectHook); // nint, int
-            updateDofParams = Hook.Create<UpdateDofParams>(0x1412BA6A0, UpdateDofParamsHook); // nint
 
             createMotionBlurObject = Hook.Create<CreateMotionBlurObject>(0x1424C95E0, CreateMotionBlurObjectHook);
             createMotionBlurObject2 = Hook.Create<CreateMotionBlurObject2>(0x1424C9740, CreateMotionBlurObject2Hook); // nint
             destroyMotionBlurObject = Hook.Create<DestroyMotionBlurObject>(0x1424C97E0, DestroyMotionBlurObjectHook); // nint, int
-            updateMotionBlurParams = Hook.Create<UpdateMotionBlurParams>(0x1424CADF0, UpdateMotionBlurParamsHook); // nint, nint
 
             createSimpleSkyObject = Hook.Create<CreateSimpleSkyObject>(0x141FCCC20, CreateSimpleSkyObjectHook); // nint
             destroySimpleSkyObject = Hook.Create<DestroySimpleSkyObject>(0x141FCD840, DestroySimpleSkyObjectHook); // nint, int
-            renderSimpleSky = Hook.Create<RenderSimpleSky>(0x141FD58E0, RenderSimpleSkyHook); // nint, nint
 
             createFogObject = Hook.Create<CreateFogObject>(0x141FADB50, CreateFogObjectHook);
             createFogObject2 = Hook.Create<CreateFogObject2>(0x141FADC80, CreateFogObject2Hook); // nint
             destroyFogObject = Hook.Create<DestroyFogObject>(0x141FADD50, DestroyFogObjectHook); // nint, int
-            updateFogParams = Hook.Create<UpdateFogParams>(0x1416D8F00, UpdateFogParamsHook); // nint, int
 
             createWaterWaveObject = Hook.Create<CreateWaterWaveObject>(0x1423F0850, CreateWaterWaveObjectHook); // nint
             destroyWaterWaveObject = Hook.Create<DestroyWaterWaveObject>(0x1423F0EE0, DestroyWaterWaveObjectHook); // nint, int
@@ -2419,7 +2435,10 @@ namespace WorldTuningTool
             createTAAObject2 = Hook.Create<CreateTAAObject2>(0x142391320, CreateTAAObject2Hook); // nint
             destroyTAAObject = Hook.Create<DestroyTAAObject>(0x1423916E0, DestroyTAAObjectHook); // nint, int
 
-            lights.Initialize();
+            if (!disableLightsFeature)
+            {
+                lights.Initialize();
+            }
 
             nint addr = PatternScanner.FindFirst(Pattern.FromString("48 89 5C 24 10 48 89 74 24 18 48 89 7C 24 20 55 41 56 41 57 48 8B EC 48 83 EC 30 48 8B FA 48 8B D9 E8 AA B6 C1 FF 48 8B 47 10 48 8D 57 50"));
             Assert(addr == 0x141AB2260); // nint, nint
@@ -2528,6 +2547,9 @@ namespace WorldTuningTool
             // Found using mFrameSkipNum annotation from MHW-DTI-Dumps.
             zeroFrameSkip = new Patch(lton(0x142246948), [0x31, 0xC0, 0x90, 0x90, 0x90, 0x90]);
 
+            // vTable of Interest: 0x1433B8730.
+            jmpOverEffects = new Patch(lton(0x14263483B), [0xEB]);
+
             // The game will crash when trying to switch to the FULL_RES path for SSR. It's likley because
             // it tries to access shaders that are not available in the game files.
             // Ex: MonsterHunterWorld.exe+259329B - lea rcx,[rdi+00000120] # Zero.
@@ -2615,6 +2637,7 @@ namespace WorldTuningTool
         public void OnPreMain()
         {
             Config config = getConfig();
+            disableLightsFeature = config.DisableLightsFeature;
             PatchConfig patches = config.Patches;
 #if SHADER_FEATURES
             fullResSSLR = patches.FullResolutionSSLR;
@@ -2687,6 +2710,9 @@ namespace WorldTuningTool
             sMhMain = SingletonManager.GetSingleton("sMhMain")!;
             sMhRender = SingletonManager.GetSingleton("sMhRender")!;
             sMhScene = SingletonManager.GetSingleton("sMhScene")!;
+            sTime = SingletonManager.GetSingleton("sTime")!;
+            sQuest = SingletonManager.GetSingleton("sQuest")!;
+            sLightLinker = SingletonManager.GetSingleton("sLightLinker")!;
             sLightProbes = SingletonManager.GetSingleton("sLightProbes")!;
             foreach (Parameter param in sLightProbesParameters)
             {
@@ -2766,8 +2792,28 @@ namespace WorldTuningTool
                 HandleAreaChange(stage);
             }
 
+            if (!disableLightsFeature)
+            {
+                lights.OnUpdate();
+            }
+        }
+
+        private void UpdateUnitsHook(nint sMhUnit)
+        {
+            updateUnits!.Original(sMhUnit);
+
             hqMode.Update(sMhScene!.Instance);
 
+            if (setWeatherMode)
+            {
+                MemoryUtil.GetRef<int>(sQuest!.Instance + 0x293B4) = requestWeatherMode;
+            }
+
+            foreach (Parameter param in sTimeParameters)
+            {
+                param.Update(sTime!.Instance);
+            }
+
             foreach (Parameter param in lodParameters)
             {
                 param.Update(sMhScene!.Instance);
@@ -2778,12 +2824,12 @@ namespace WorldTuningTool
                 param.Update(sMhScene!.Instance);
             }
 
-            foreach (Parameter param in passthroughParameters)
+            foreach (Parameter param in shadowCascadeParameters)
             {
                 param.Update(sMhScene!.Instance);
             }
 
-            foreach (Parameter param in shadowCascadeParameters)
+            foreach (Parameter param in passthroughParameters)
             {
                 param.Update(sMhScene!.Instance);
             }
@@ -2803,14 +2849,6 @@ namespace WorldTuningTool
                 param.Update(sMhScene!.Instance);
             }
 
-            if (lightingObject != 0x0)
-            {
-                foreach (Parameter param in lightingParameters)
-                {
-                    param.Update(lightingObject);
-                }
-            }
-
             foreach (Parameter param in brightnessParameters)
             {
                 param.Update(sMhRender!.Instance);
@@ -2832,14 +2870,6 @@ namespace WorldTuningTool
                 }
             }
 
-            if (motionBlurObject != 0x0)
-            {
-                foreach (Parameter param in motionBlurParameters)
-                {
-                    param.Update(motionBlurObject);
-                }
-            }
-
             if (waterWaveObject != 0x0)
             {
                 foreach (Parameter param in waterWaveParameters)
@@ -2863,24 +2893,68 @@ namespace WorldTuningTool
                     param.Update(taaObject);
                 }
             }
+
+            if (!disableLightsFeature)
+            {
+                lights.PostUpdateUnits();
+            }
         }
 
-        private void EvalSceneParamsHook(nint unknownPtr, nint unknownPtr2, int unknownInt, nint unknownPtr3)
+        private void UpdateLightLinkerHook(nint sLightLinker)
         {
-            foreach (Parameter param in broadAreaShadowParameters)
+            updateLightLinker!.Original(sLightLinker);
+
+            foreach (Parameter param in sLightProbesParameters)
             {
-                param.Update(sMhScene!.Instance, true);
+                param.Update(sLightProbes!.Instance);
+            }
+
+            if (lightingObject != 0x0)
+            {
+                foreach (Parameter param in lightingParameters)
+                {
+                    param.Update(lightingObject);
+                }
+            }
+
+            if (motionBlurObject != 0x0)
+            {
+                foreach (Parameter param in motionBlurParameters)
+                {
+                    param.Update(motionBlurObject);
+                }
+            }
+
+            if (simpleSkyObject != 0x0)
+            {
+                foreach (Parameter param in simpleSkyParameters)
+                {
+                    param.Update(simpleSkyObject);
+                }
+            }
+
+            if (fogObject != 0x0)
+            {
+                foreach (Parameter param in fogParameters)
+                {
+                    param.Update(fogObject);
+                }
             }
-            evalSceneParams!.Original(unknownPtr, unknownPtr2, unknownInt, unknownPtr3);
         }
 
-        private void UpdateCapsuleAOParamsHook(nint sceneObjectInternal)
+        private void EvaluateSceneParamsHook(nint unknownPtr, nint unknownPtr2, int unknownInt, nint unknownPtr3)
         {
-            updateCapsuleAoParams!.Original(sceneObjectInternal);
+            foreach (Parameter param in broadAreaShadowParameters)
+            {
+                param.Update(sMhScene!.Instance);
+            }
+
             foreach (Parameter param in capsuleLightParameters)
             {
-                param.Update(sMhScene!.Instance, true);
+                param.Update(sMhScene!.Instance);
             }
+
+            evaluateSceneParams!.Original(unknownPtr, unknownPtr2, unknownInt, unknownPtr3);
         }
 
         private void UpdateSSAOParamsHook(nint stackOffset)
@@ -2937,27 +3011,6 @@ namespace WorldTuningTool
             return destroyLightingObject!.Original(lightingObjectInternal, unknownInt);
         }
 
-        private void UpdateLutBlendHook(nint stackOffset, nint lightingObjectInternal)
-        {
-            updateLutBlend!.Original(stackOffset, lightingObjectInternal);
-            if (lightingObject == lightingObjectInternal)
-            {
-                foreach (Parameter param in lightingParameters)
-                {
-                    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();
@@ -3026,15 +3079,6 @@ namespace WorldTuningTool
             return destroyDofObject!.Original(dofObjectInternal, unknownInt);
         }
 
-        private void UpdateDofParamsHook(nint unknownPtr)
-        {
-            updateDofParams!.Original(unknownPtr);
-            foreach (Parameter param in dofParameters)
-            {
-                param.Update(dofObject, true);
-            }
-        }
-
         private nint CreateMotionBlurObjectHook()
         {
             motionBlurObject = createMotionBlurObject!.Original();
@@ -3069,15 +3113,6 @@ namespace WorldTuningTool
             return destroyMotionBlurObject!.Original(motionBlurObjectInternal, unknownInt);
         }
 
-        private void UpdateMotionBlurParamsHook(nint unknownPtr, nint unknownPtr2)
-        {
-            foreach (Parameter param in motionBlurParameters)
-            {
-                param.Update(motionBlurObject, true);
-            }
-            updateMotionBlurParams!.Original(unknownPtr, unknownPtr2);
-        }
-
         private nint CreateSimpleSkyObjectHook(nint unknownPtr)
         {
             simpleSkyObject = createSimpleSkyObject!.Original(unknownPtr);
@@ -3102,15 +3137,6 @@ namespace WorldTuningTool
             return destroySimpleSkyObject!.Original(simpleSkyObjectInternal, unknownInt);
         }
 
-        private void RenderSimpleSkyHook(nint simpleSkyObjectInternal, nint unknownPtr)
-        {
-            foreach (Parameter param in simpleSkyParameters)
-            {
-                param.Update(simpleSkyObject, true);
-            }
-            renderSimpleSky!.Original(simpleSkyObjectInternal, unknownPtr);
-        }
-
         private nint CreateFogObjectHook()
         {
             fogObject = createFogObject!.Original();
@@ -3145,15 +3171,6 @@ namespace WorldTuningTool
             return destroyFogObject!.Original(fogObjectInternal, unknownInt);
         }
 
-        private void UpdateFogParamsHook(nint unknownPtr, int unknownInt)
-        {
-            updateFogParams!.Original(unknownPtr, unknownInt);
-            foreach (Parameter param in fogParameters)
-            {
-                param.Update(fogObject, true);
-            }
-        }
-
         private nint CreateWaterWaveObjectHook(nint unknownPtr)
         {
             waterWaveObject = createWaterWaveObject!.Original(unknownPtr);
@@ -3878,9 +3895,12 @@ namespace WorldTuningTool
                 }
             }
 
-            if (ImGui.CollapsingHeader("Lights"))
+            if (!disableLightsFeature)
             {
-                lights.DrawUI(width);
+                if (ImGui.CollapsingHeader("Lights"))
+                {
+                    lights.DrawUI(width);
+                }
             }
 
             bool expanded = ImGui.CollapsingHeader("Parameters");
@@ -3893,6 +3913,27 @@ namespace WorldTuningTool
             {
                 hqMode.Draw(width);
 
+                ImGui.PushID("Time");
+                if (ImGui.CollapsingHeader("Time and Weather"))
+                {
+                    ImGui.Text($"Address: 0x{sTime!.Instance:X}");
+                    foreach (Parameter param in sTimeParameters)
+                    {
+                        param.Draw(width);
+                    }
+                    ImGui.Text($"Address: 0x{sQuest!.Instance:X}");
+                    ImGui.Checkbox("##Set Weather Mode", ref setWeatherMode);
+                    ImGui.SameLine();
+                    ImGui.SetNextItemWidth(width * defaultParamWidth);
+                    ImGui.InputInt("Weather Mode", ref requestWeatherMode, 1);
+                    if (ImGui.BeginItemTooltip())
+                    {
+                        ImGui.Text("Applies on stage load. 2 = Harsh weather.");
+                        ImGui.EndTooltip();
+                    }
+                }
+                ImGui.PopID();
+
                 ImGui.PushID("LOD");
                 if (ImGui.CollapsingHeader("Level of Detail"))
                 {
@@ -4180,6 +4221,23 @@ namespace WorldTuningTool
 
                 if (ImGui.CollapsingHeader("Tests"))
                 {
+                    if (ImGui.Checkbox("Nuke Effects in Scene", ref nukeEffects))
+                    {
+                        if (nukeEffects)
+                        {
+                            jmpOverEffects.Enable();
+                        }
+                        else
+                        {
+                            jmpOverEffects.Disable();
+                        }
+                    }
+                    if (ImGui.BeginItemTooltip())
+                    {
+                        ImGui.Text("Includes Torches, Lanterns, Scoutflies, Bubbles, Waterfalls, etc.");
+                        ImGui.EndTooltip();
+                    }
+
                     if (ImGui.Checkbox("Skip Mip Mapping for SSLR", ref skipSSLRMipMapping))
                     {
                         if (skipSSLRMipMapping)
@@ -4209,8 +4267,6 @@ namespace WorldTuningTool
                         ImGui.EndTooltip();
                     }
 
-                    lights.DrawDebug(width);
-
                     ImGui.Separator();
                 }
 
@@ -4226,6 +4282,8 @@ namespace WorldTuningTool
                 }
                 ImGui.InputFloat("Max FPS", ref MemoryUtil.GetRef<float>(sMhMain!.Instance + 0x5C));
                 ImGui.PopItemWidth();
+
+                ImGui.Text($"sLightLinker: 0x{sLightLinker!.Instance:X}");
             }
         }