Remove ObjectLights from general light handling

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

1 files changed, 124 insertions, 32 deletions

diff --git a/Lights.cs b/Lights.cs
index b964367..4927fd3 100644
--- a/Lights.cs
+++ b/Lights.cs
@@ -1,3 +1,5 @@
+//#define HOOK_OBJECT_LIGHTS
+
 using System.Numerics;
 
 using ImGuiNET;
@@ -13,14 +15,19 @@ namespace WorldTuningTool
     {
         public Lights() { }
 
-        private class uLight
+        private class BaseLight
         {
             public nint Object = 0x0;
             public virtual int Type => -1;
-            public virtual string Name => $"uLight";
+            public virtual string Name => $"Light";
             public virtual string Info => $"0x{Object:X}";
             public List<Parameter> Parameters = new List<Parameter>();
 
+            public BaseLight(nint lightObject)
+            {
+                Object = lightObject;
+            }
+
             public void UpdateParams()
             {
                 Assert(Object != 0x0);
@@ -29,10 +36,14 @@ namespace WorldTuningTool
                     param.Update(Object);
                 }
             }
+        }
 
-            public uLight(nint lightObject)
+        private class uLight : BaseLight
+        {
+            public override string Name => $"uLight";
+
+            public uLight(nint lightObject) : base(lightObject)
             {
-                Object = lightObject;
                 Parameters.AddRange(new Parameter[]{
                     M<int>("Group", 0x13C, ParameterType.INT, 0x7, pMinMaxStep(0, 7, 1)), // 1 = World, (1 << 1) = Player/Palico, (1 << 2) = NPCs
                     M<int>("Priority", 0x138, ParameterType.INT, (0xFF << 6), pMinMaxStep(0, 255, 1)),
@@ -451,25 +462,53 @@ namespace WorldTuningTool
             }
         }
 
-        private class uMhObjectLight : uLight
+#if HOOK_OBJECT_LIGHTS
+        private class uMhObjectLight : BaseLight
         {
             public override int Type => 5;
             public override string Name => $"uMhObjectLight";
 
             public uMhObjectLight(nint lightObject) : base(lightObject)
             {
+                Parameters.AddRange(new Parameter[]{
+                    P<float>("Position", 0x160, ParameterType.VECTOR3),
+                    P<int>("Shape", 0x590, ParameterType.INT, pStep(1)),
+                    P<int>("Color", 0x5A0, ParameterType.COLOR),
+                    P<float>("Intensity", 0x5A4, ParameterType.FLOAT),
+                });
+                UpdateParams();
             }
         }
 
-        private class uLlkObjectLight : uLight
+        private class uLlkObjectLight : BaseLight
         {
+            public override int Type => 5;
             public override string Name => $"uLlkObjectLight";
 
             public uLlkObjectLight(nint lightObject) : base(lightObject)
             {
+                Parameters.AddRange(new Parameter[]{
+                    P<float>("Position", 0x160, ParameterType.VECTOR3)
+                });
+                UpdateParams();
             }
         }
 
+        private delegate nint CreateMhObjectLight();
+        private delegate nint CreateMhObjectLight2(nint unknownPtr);
+        private delegate nint DestroyMhObjectLight(nint mhObjectLightInternal, int unknownInt);
+        private Hook<CreateMhObjectLight>? createMhObjectLight;
+        private Hook<CreateMhObjectLight2>? createMhObjectLight2;
+        private Hook<DestroyMhObjectLight>? destroyMhObjectLight;
+
+        private delegate nint CreateLlkObjectLight();
+        private delegate nint CreateLlkObjectLight2(nint unknownPtr);
+        private delegate nint DestroyLlkObjectLight(nint llkObjectLightInternal, int unknownInt);
+        private Hook<CreateLlkObjectLight>? createLlkObjectLight;
+        private Hook<CreateLlkObjectLight2>? createLlkObjectLight2;
+        private Hook<DestroyLlkObjectLight>? destroyLlkObjectLight;
+#endif
+
         private delegate nint CreateLightObject(nint lightObject);
         private delegate nint DestroyLightObject(nint lightObjectInternal, int unknownInt);
         private Hook<CreateLightObject>? createLightObject;
@@ -497,10 +536,8 @@ namespace WorldTuningTool
             { lton(0x143493D10), (x) => new uLlkFollowCameraSpotLight(x) },
             { lton(0x1435145E8), (x) => new uHemiSphereLight(x) },
             { lton(0x143499378), (x) => new uMhHemiSphereLight(x) },
-            { lton(0x143493F98), (x) => new uLlkHemiSphereLight(x) },
-            { lton(0x14349A498), (x) => new uMhObjectLight(x) },
-            { lton(0x1434942A0), (x) => new uLlkObjectLight(x) },
-            { lton(0x143493918), (x) => new uLight(x) }, // @TODO: uLlkBaseModel is not implemented.
+            { lton(0x143493F98), (x) => new uLlkHemiSphereLight(x) }
+
         };
         private static nint[] lightObjectDestructors = {
             lton(0x142311FF0), // # uLight
@@ -525,10 +562,7 @@ namespace WorldTuningTool
             lton(0x141F83BE0), // # uLlkFollowCameraSpotLight
             lton(0x142311EC0), // # uHemiSphereLight
             lton(0x141FB8C20), // # uMhHemiSphereLight
-            lton(0x141F84A40), // # uLlkHemiSphereLight
-            lton(0x141FBF6B0), // # uMhObjectLight
-            lton(0x141F86270), // # uLlkObjectLight
-            lton(0x141F83460), // # uLlkBaseModel
+            lton(0x141F84A40)  // # uLlkHemiSphereLight
         };
         private Hook<DestroyLightObject>[] lightObjectDestructorHooks = new Hook<DestroyLightObject>[lightObjectDestructors.Length];
 
@@ -541,6 +575,10 @@ namespace WorldTuningTool
         private NativeAction<nint> removeFromScene;
         private List<uLight> ourLights = new List<uLight>();
 
+#if HOOK_OBJECT_LIGHTS
+        private List<BaseLight> objectLights = new List<BaseLight>();
+#endif
+
         public void Initialize()
         {
             createLightObject = Hook.Create<CreateLightObject>(0x142311420, CreateLightObjectHook);
@@ -567,16 +605,23 @@ namespace WorldTuningTool
                 DestroyLightObjectHook19,
                 DestroyLightObjectHook20,
                 DestroyLightObjectHook21,
-                DestroyLightObjectHook22,
-                DestroyLightObjectHook23,
-                DestroyLightObjectHook24,
-                DestroyLightObjectHook25
+                DestroyLightObjectHook22
             };
             for (int i = 0; i < lightObjectDestructors.Length; i++)
             {
                 lightObjectDestructorHooks[i] = Hook.Create<DestroyLightObject>(lightObjectDestructors[i], destructorHookFuncs[i]);
             }
 
+#if HOOK_OBJECT_LIGHTS
+            createMhObjectLight = Hook.Create<CreateMhObjectLight>(0x141FBF290, CreateMhObjectLightHook);
+            createMhObjectLight2 = Hook.Create<CreateMhObjectLight2>(0x141FBF500, CreateMhObjectLight2Hook);
+            destroyMhObjectLight = Hook.Create<DestroyMhObjectLight>(0x141FBF6B0, DestroyMhObjectLightHook);
+
+            createLlkObjectLight = Hook.Create<CreateLlkObjectLight>(0x141F85DF0, CreateLlkObjectLightHook);
+            createLlkObjectLight2 = Hook.Create<CreateLlkObjectLight2>(0x141F86090, CreateLlkObjectLight2Hook);
+            destroyLlkObjectLight = Hook.Create<DestroyLlkObjectLight>(0x141F86270, DestroyLlkObjectLightHook);
+#endif
+
             addToScene = new NativeAction<nint, int, nint, int>(0x142219070);
             removeFromScene = new NativeAction<nint>(0x142228F10);
         }
@@ -777,23 +822,68 @@ namespace WorldTuningTool
             Assert(unknownInt == 1); cleanupCommon(lightObject);
             return lightObjectDestructorHooks[22]!.Original(lightObject, unknownInt);
         }
-        private nint DestroyLightObjectHook23(nint lightObject, int unknownInt)
+
+#if HOOK_OBJECT_LIGHTS
+        private nint CreateMhObjectLightHook()
         {
-            Assert(unknownInt == 1); cleanupCommon(lightObject);
-            return lightObjectDestructorHooks[23]!.Original(lightObject, unknownInt);
+            nint objectLight = createMhObjectLight!.Original();
+            objectLights.Add(new uMhObjectLight(objectLight));
+            return objectLight;
         }
-        private nint DestroyLightObjectHook24(nint lightObject, int unknownInt)
+
+        private nint CreateMhObjectLight2Hook(nint unknownPtr)
         {
-            Assert(unknownInt == 1); cleanupCommon(lightObject);
-            return lightObjectDestructorHooks[24]!.Original(lightObject, unknownInt);
+            nint objectLight = createMhObjectLight2!.Original(unknownPtr);
+            objectLights.Add(new uMhObjectLight(objectLight));
+            return objectLight;
         }
-        private nint DestroyLightObjectHook25(nint lightObject, int unknownInt)
+
+        private nint DestroyMhObjectLightHook(nint mhObjectLightInternal, int unknownInt)
         {
-            Assert(unknownInt == 1); cleanupCommon(lightObject);
-            return lightObjectDestructorHooks[25]!.Original(lightObject, unknownInt);
+            Assert(unknownInt == 1);
+            for (int i = 0; i < objectLights.Count; i++)
+            {
+                BaseLight light = objectLights[i];
+                if (mhObjectLightInternal == light.Object)
+                {
+                    objectLights.RemoveAt(i);
+                    break;
+                }
+            }
+            return destroyMhObjectLight!.Original(mhObjectLightInternal, unknownInt);
+        }
+
+        private nint CreateLlkObjectLightHook()
+        {
+            nint objectLight = createLlkObjectLight!.Original();
+            objectLights.Add(new uLlkObjectLight(objectLight));
+            return objectLight;
+        }
+
+        private nint CreateLlkObjectLight2Hook(nint unknownPtr)
+        {
+            nint objectLight = createLlkObjectLight2!.Original(unknownPtr);
+            objectLights.Add(new uLlkObjectLight(objectLight));
+            return objectLight;
+        }
+
+        private nint DestroyLlkObjectLightHook(nint llkObjectLightInternal, int unknownInt)
+        {
+            Assert(unknownInt == 1);
+            for (int i = 0; i < objectLights.Count; i++)
+            {
+                BaseLight light = objectLights[i];
+                if (llkObjectLightInternal == light.Object)
+                {
+                    objectLights.RemoveAt(i);
+                    break;
+                }
+            }
+            return destroyLlkObjectLight!.Original(llkObjectLightInternal, unknownInt);
         }
+#endif
 
-        private void DrawLights(IEnumerable<uLight> lights, float width)
+        private void DrawLights(IEnumerable<BaseLight> lights, float width)
         {
             bool disableAll = ImGui.Button("Disable All");
             if (ImGui.BeginItemTooltip())
@@ -803,7 +893,7 @@ namespace WorldTuningTool
             }
             ImGui.SameLine();
             bool enableAll = ImGui.Button("Enable All");
-            foreach (uLight light in lights)
+            foreach (BaseLight light in lights)
             {
                 ImGui.PushID(light.Object);
                 if (disableAll)
@@ -1044,12 +1134,14 @@ namespace WorldTuningTool
                     ImGui.Separator();
                 }
                 ImGui.PopID();
-                ImGui.PushID("Other");
-                if (ImGui.CollapsingHeader("Other"))
+#if HOOK_OBJECT_LIGHTS
+                ImGui.PushID("ObjectLights");
+                if (ImGui.CollapsingHeader("Object Lights"))
                 {
-                    DrawLights(sceneLights.Where(x => (x.Type == -1 || x.Type == 5)), width);
+                    DrawLights(objectLights, width);
                 }
                 ImGui.PopID();
+#endif
                 ImGui.TreePop();
             }
             ImGui.PopID();