8.15.2020 update

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/-.h

@@ -19,6 +19,7 @@
 #include "includes/collisiondelegate.h"
 #include "includes/collisionimpulsedelegate.h"
 #include "includes/collisionresistancemultiplier.h"
+#include "includes/commands.h"
 #include "includes/createsessionfromtypedelegate.h"
 #include "includes/cubemapdepth.h"
 #include "includes/cubemaprendermethod.h"
@@ -28,6 +29,7 @@
 #include "includes/custominstancetype.h"
 #include "includes/datatype.h"
 #include "includes/delaydeadc__iterator0.h"
+#include "includes/delayedinitialize.h"
 #include "includes/delayfreezec__iterator0.h"
 #include "includes/disabledtoactivec__iterator0.h"
 #include "includes/downscale.h"

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/activetodisabledc__iterator2.h

@@ -24,28 +24,28 @@ class activetodisabledciterator2 {
 
     template <typename T = bool> T movenext() {
         return ((T(*)(activetodisabledciterator2 *))(il2cpp::il2cpp_base() +
-                                                     0x39A56FC))(this);
+                                                     0x422026C))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_generic_ienumeratorobject_get_current() {
         return ((T(*)(activetodisabledciterator2 *))(il2cpp::il2cpp_base() +
-                                                     0x39A58E8))(this);
+                                                     0x4220458))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_ienumerator_get_current() {
         return ((T(*)(activetodisabledciterator2 *))(il2cpp::il2cpp_base() +
-                                                     0x39A58F0))(this);
+                                                     0x4220460))(this);
     }
 
     template <typename T = void> T dispose() {
         return ((T(*)(activetodisabledciterator2 *))(il2cpp::il2cpp_base() +
-                                                     0x39A58F8))(this);
+                                                     0x4220468))(this);
     }
 
     template <typename T = void> T reset() {
         return ((T(*)(activetodisabledciterator2 *))(il2cpp::il2cpp_base() +
-                                                     0x39A590C))(this);
+                                                     0x422047C))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/activetokinematicc__iterator3.h

@@ -30,28 +30,28 @@ class activetokinematicciterator3 {
 
     template <typename T = bool> T movenext() {
         return ((T(*)(activetokinematicciterator3 *))(il2cpp::il2cpp_base() +
-                                                      0x39A59A0))(this);
+                                                      0x4220510))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_generic_ienumeratorobject_get_current() {
         return ((T(*)(activetokinematicciterator3 *))(il2cpp::il2cpp_base() +
-                                                      0x39A5CE8))(this);
+                                                      0x4220858))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_ienumerator_get_current() {
         return ((T(*)(activetokinematicciterator3 *))(il2cpp::il2cpp_base() +
-                                                      0x39A5CF0))(this);
+                                                      0x4220860))(this);
     }
 
     template <typename T = void> T dispose() {
         return ((T(*)(activetokinematicciterator3 *))(il2cpp::il2cpp_base() +
-                                                      0x39A5CF8))(this);
+                                                      0x4220868))(this);
     }
 
     template <typename T = void> T reset() {
         return ((T(*)(activetokinematicciterator3 *))(il2cpp::il2cpp_base() +
-                                                      0x39A5D0C))(this);
+                                                      0x422087C))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/alivetodeadc__iterator4.h

@@ -57,28 +57,28 @@ class alivetodeadciterator4 {
 
     template <typename T = bool> T movenext() {
         return ((T(*)(alivetodeadciterator4 *))(il2cpp::il2cpp_base() +
-                                                0x39A5DA0))(this);
+                                                0x4220910))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_generic_ienumeratorobject_get_current() {
         return ((T(*)(alivetodeadciterator4 *))(il2cpp::il2cpp_base() +
-                                                0x39A6348))(this);
+                                                0x4220EE8))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_ienumerator_get_current() {
         return ((T(*)(alivetodeadciterator4 *))(il2cpp::il2cpp_base() +
-                                                0x39A6350))(this);
+                                                0x4220EF0))(this);
     }
 
     template <typename T = void> T dispose() {
         return ((T(*)(alivetodeadciterator4 *))(il2cpp::il2cpp_base() +
-                                                0x39A6358))(this);
+                                                0x4220EF8))(this);
     }
 
     template <typename T = void> T reset() {
         return ((T(*)(alivetodeadciterator4 *))(il2cpp::il2cpp_base() +
-                                                0x39A636C))(this);
+                                                0x4220F0C))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/animatorevent.h

@@ -19,16 +19,16 @@ class animatorevent {
     template <typename T = void>
     T activate(std::uintptr_t _animator, std::uintptr_t _animation) {
         return ((T(*)(animatorevent *, std::uintptr_t, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x397EF68))(this, _animator, _animation);
+            il2cpp::il2cpp_base() + 0x41F97A4))(this, _animator, _animation);
     }
 
     template <typename T = void> T activate_1(std::uintptr_t _animator) {
         return ((T(*)(animatorevent *, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x397F088))(this, _animator);
+            il2cpp::il2cpp_base() + 0x41F98C4))(this, _animator);
     }
 
     template <typename T = void> T activate_2(std::uintptr_t _animation) {
         return ((T(*)(animatorevent *, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x397F220))(this, _animation);
+            il2cpp::il2cpp_base() + 0x41F9A5C))(this, _animation);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/autodetectparams.h

@@ -11,6 +11,6 @@ class autodetectparams {
     }
 
     template <typename T = std::uintptr_t> static T get_default() {
-        return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x3979A14))(0);
+        return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x41F49E4))(0);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/behaviourdelegate.h

@@ -4,18 +4,18 @@
 class behaviourdelegate {
   public:
     template <typename T = void> T invoke() {
-        return ((T(*)(behaviourdelegate *))(il2cpp::il2cpp_base() + 0x397C700))(
+        return ((T(*)(behaviourdelegate *))(il2cpp::il2cpp_base() + 0x41F6E80))(
             this);
     }
 
     template <typename T = std::uintptr_t>
     T begininvoke(std::uintptr_t _callback, std::uintptr_t _object) {
         return ((T(*)(behaviourdelegate *, std::uintptr_t, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x397F39C))(this, _callback, _object);
+            il2cpp::il2cpp_base() + 0x41F9BD8))(this, _callback, _object);
     }
 
     template <typename T = void> T endinvoke(std::uintptr_t _result) {
         return ((T(*)(behaviourdelegate *, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x397F3C8))(this, _result);
+            il2cpp::il2cpp_base() + 0x41F9C04))(this, _result);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/collisiondelegate.h

@@ -5,19 +5,19 @@ class collisiondelegate {
   public:
     template <typename T = void> T invoke(std::uintptr_t _collision) {
         return ((T(*)(collisiondelegate *, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x397CC24))(this, _collision);
+            il2cpp::il2cpp_base() + 0x41F7424))(this, _collision);
     }
 
     template <typename T = std::uintptr_t>
     T begininvoke(std::uintptr_t _collision, std::uintptr_t _callback,
                   std::uintptr_t _object) {
         return ((T(*)(collisiondelegate *, std::uintptr_t, std::uintptr_t,
-                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x397F3E8))(
+                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x41F9C24))(
             this, _collision, _callback, _object);
     }
 
     template <typename T = void> T endinvoke(std::uintptr_t _result) {
         return ((T(*)(collisiondelegate *, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x397F4A8))(this, _result);
+            il2cpp::il2cpp_base() + 0x41F9CE4))(this, _result);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/collisionimpulsedelegate.h

@@ -5,7 +5,7 @@ class collisionimpulsedelegate {
   public:
     template <typename T = void> T invoke(std::uintptr_t _m, float _impulse) {
         return ((T(*)(collisionimpulsedelegate *, std::uintptr_t, float))(
-            il2cpp::il2cpp_base() + 0x3985948))(this, _m, _impulse);
+            il2cpp::il2cpp_base() + 0x42001F8))(this, _m, _impulse);
     }
 
     template <typename T = std::uintptr_t>
@@ -13,12 +13,12 @@ class collisionimpulsedelegate {
                   std::uintptr_t _object) {
         return ((T(*)(collisionimpulsedelegate *, std::uintptr_t, float,
                       std::uintptr_t, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x398634C))(this, _m, _impulse, _callback,
+            il2cpp::il2cpp_base() + 0x4200BFC))(this, _m, _impulse, _callback,
                                                 _object);
     }
 
     template <typename T = void> T endinvoke(std::uintptr_t _result) {
         return ((T(*)(collisionimpulsedelegate *, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x3986434))(this, _result);
+            il2cpp::il2cpp_base() + 0x4200CE4))(this, _result);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/commands.h

@@ -0,0 +1,9 @@
+#pragma once
+#include <il2cpp/il2cpp.h>
+
+class commands {
+  public:
+    template <typename T = std::int32_t> T &value__() {
+        return *(T *)((std::uintptr_t)this + 0x0);
+    }
+};

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/createsessionfromtypedelegate.h

@@ -5,7 +5,7 @@ class createsessionfromtypedelegate {
   public:
     template <typename T = std::uintptr_t> T invoke(std::uintptr_t _type) {
         return ((T(*)(createsessionfromtypedelegate *, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x2C7D198))(this, _type);
+            il2cpp::il2cpp_base() + 0x2F50EA8))(this, _type);
     }
 
     template <typename T = std::uintptr_t>
@@ -13,12 +13,12 @@ class createsessionfromtypedelegate {
                   std::uintptr_t _object) {
         return ((T(*)(createsessionfromtypedelegate *, std::uintptr_t,
                       std::uintptr_t, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x2C7D230))(this, _type, _callback,
+            il2cpp::il2cpp_base() + 0x2F50F40))(this, _type, _callback,
                                                 _object);
     }
 
     template <typename T = std::uintptr_t> T endinvoke(std::uintptr_t _result) {
         return ((T(*)(createsessionfromtypedelegate *, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x2C7D25C))(this, _result);
+            il2cpp::il2cpp_base() + 0x2F50F6C))(this, _result);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/delaydeadc__iterator0.h

@@ -18,28 +18,28 @@ class delaydeadciterator0 {
 
     template <typename T = bool> T movenext() {
         return ((T(*)(delaydeadciterator0 *))(il2cpp::il2cpp_base() +
-                                              0x397A338))(this);
+                                              0x41F5308))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_generic_ienumeratorobject_get_current() {
         return ((T(*)(delaydeadciterator0 *))(il2cpp::il2cpp_base() +
-                                              0x397A4C8))(this);
+                                              0x41F5498))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_ienumerator_get_current() {
         return ((T(*)(delaydeadciterator0 *))(il2cpp::il2cpp_base() +
-                                              0x397A4D0))(this);
+                                              0x41F54A0))(this);
     }
 
     template <typename T = void> T dispose() {
         return ((T(*)(delaydeadciterator0 *))(il2cpp::il2cpp_base() +
-                                              0x397A4D8))(this);
+                                              0x41F54A8))(this);
     }
 
     template <typename T = void> T reset() {
         return ((T(*)(delaydeadciterator0 *))(il2cpp::il2cpp_base() +
-                                              0x397A4EC))(this);
+                                              0x41F54BC))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/delayedinitialize.h

@@ -0,0 +1,15 @@
+#pragma once
+#include <il2cpp/il2cpp.h>
+
+class delayedinitialize {
+  public:
+    template <typename T = void> T start() {
+        return ((T(*)(delayedinitialize *))(il2cpp::il2cpp_base() + 0x5A67194))(
+            this);
+    }
+
+    template <typename T = void> T executecallback() {
+        return ((T(*)(delayedinitialize *))(il2cpp::il2cpp_base() + 0x5A67220))(
+            this);
+    }
+};

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/delayfreezec__iterator0.h

@@ -18,28 +18,28 @@ class delayfreezeciterator0 {
 
     template <typename T = bool> T movenext() {
         return ((T(*)(delayfreezeciterator0 *))(il2cpp::il2cpp_base() +
-                                                0x397FAEC))(this);
+                                                0x41FA328))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_generic_ienumeratorobject_get_current() {
         return ((T(*)(delayfreezeciterator0 *))(il2cpp::il2cpp_base() +
-                                                0x397FC64))(this);
+                                                0x41FA4A0))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_ienumerator_get_current() {
         return ((T(*)(delayfreezeciterator0 *))(il2cpp::il2cpp_base() +
-                                                0x397FC6C))(this);
+                                                0x41FA4A8))(this);
     }
 
     template <typename T = void> T dispose() {
         return ((T(*)(delayfreezeciterator0 *))(il2cpp::il2cpp_base() +
-                                                0x397FC74))(this);
+                                                0x41FA4B0))(this);
     }
 
     template <typename T = void> T reset() {
         return ((T(*)(delayfreezeciterator0 *))(il2cpp::il2cpp_base() +
-                                                0x397FC88))(this);
+                                                0x41FA4C4))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/disabledtoactivec__iterator0.h

@@ -36,28 +36,28 @@ class disabledtoactiveciterator0 {
 
     template <typename T = bool> T movenext() {
         return ((T(*)(disabledtoactiveciterator0 *))(il2cpp::il2cpp_base() +
-                                                     0x39A6400))(this);
+                                                     0x4220FA0))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_generic_ienumeratorobject_get_current() {
         return ((T(*)(disabledtoactiveciterator0 *))(il2cpp::il2cpp_base() +
-                                                     0x39A67B8))(this);
+                                                     0x4221358))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_ienumerator_get_current() {
         return ((T(*)(disabledtoactiveciterator0 *))(il2cpp::il2cpp_base() +
-                                                     0x39A67C0))(this);
+                                                     0x4221360))(this);
     }
 
     template <typename T = void> T dispose() {
         return ((T(*)(disabledtoactiveciterator0 *))(il2cpp::il2cpp_base() +
-                                                     0x39A67C8))(this);
+                                                     0x4221368))(this);
     }
 
     template <typename T = void> T reset() {
         return ((T(*)(disabledtoactiveciterator0 *))(il2cpp::il2cpp_base() +
-                                                     0x39A67DC))(this);
+                                                     0x422137C))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/fadeoutmuscleweightc__iterator2.h

@@ -18,28 +18,28 @@ class fadeoutmuscleweightciterator2 {
 
     template <typename T = bool> T movenext() {
         return ((T(*)(fadeoutmuscleweightciterator2 *))(il2cpp::il2cpp_base() +
-                                                        0x397A580))(this);
+                                                        0x41F5550))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_generic_ienumeratorobject_get_current() {
         return ((T(*)(fadeoutmuscleweightciterator2 *))(il2cpp::il2cpp_base() +
-                                                        0x397A6DC))(this);
+                                                        0x41F56AC))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_ienumerator_get_current() {
         return ((T(*)(fadeoutmuscleweightciterator2 *))(il2cpp::il2cpp_base() +
-                                                        0x397A6E4))(this);
+                                                        0x41F56B4))(this);
     }
 
     template <typename T = void> T dispose() {
         return ((T(*)(fadeoutmuscleweightciterator2 *))(il2cpp::il2cpp_base() +
-                                                        0x397A6EC))(this);
+                                                        0x41F56BC))(this);
     }
 
     template <typename T = void> T reset() {
         return ((T(*)(fadeoutmuscleweightciterator2 *))(il2cpp::il2cpp_base() +
-                                                        0x397A700))(this);
+                                                        0x41F56D0))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/fadeoutpinweightc__iterator1.h

@@ -18,28 +18,28 @@ class fadeoutpinweightciterator1 {
 
     template <typename T = bool> T movenext() {
         return ((T(*)(fadeoutpinweightciterator1 *))(il2cpp::il2cpp_base() +
-                                                     0x397A794))(this);
+                                                     0x41F5764))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_generic_ienumeratorobject_get_current() {
         return ((T(*)(fadeoutpinweightciterator1 *))(il2cpp::il2cpp_base() +
-                                                     0x397A8EC))(this);
+                                                     0x41F58BC))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_ienumerator_get_current() {
         return ((T(*)(fadeoutpinweightciterator1 *))(il2cpp::il2cpp_base() +
-                                                     0x397A8F4))(this);
+                                                     0x41F58C4))(this);
     }
 
     template <typename T = void> T dispose() {
         return ((T(*)(fadeoutpinweightciterator1 *))(il2cpp::il2cpp_base() +
-                                                     0x397A8FC))(this);
+                                                     0x41F58CC))(this);
     }
 
     template <typename T = void> T reset() {
         return ((T(*)(fadeoutpinweightciterator1 *))(il2cpp::il2cpp_base() +
-                                                     0x397A910))(this);
+                                                     0x41F58E0))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/finalrendercapturec__iterator0.h

@@ -21,28 +21,28 @@ class finalrendercaptureciterator0 {
 
     template <typename T = bool> T movenext() {
         return ((T(*)(finalrendercaptureciterator0 *))(il2cpp::il2cpp_base() +
-                                                       0x396102C))(this);
+                                                       0x41DBA98))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_generic_ienumeratorobject_get_current() {
         return ((T(*)(finalrendercaptureciterator0 *))(il2cpp::il2cpp_base() +
-                                                       0x39611E0))(this);
+                                                       0x41DBC4C))(this);
     }
 
     template <typename T = std::uintptr_t>
     T system_collections_ienumerator_get_current() {
         return ((T(*)(finalrendercaptureciterator0 *))(il2cpp::il2cpp_base() +
-                                                       0x39611E8))(this);
+                                                       0x41DBC54))(this);
     }
 
     template <typename T = void> T dispose() {
         return ((T(*)(finalrendercaptureciterator0 *))(il2cpp::il2cpp_base() +
-                                                       0x39611F0))(this);
+                                                       0x41DBC5C))(this);
     }
 
     template <typename T = void> T reset() {
         return ((T(*)(finalrendercaptureciterator0 *))(il2cpp::il2cpp_base() +
-                                                       0x3961204))(this);
+                                                       0x41DBC70))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/graphicsdebuggerclient.h

@@ -3,7 +3,98 @@
 
 class graphicsdebuggerclient {
   public:
+    template <typename T = void *> T &allreloadshaders() {
+        return *(T *)((std::uintptr_t)this + 0xC);
+    }
+    template <typename T =
+                  il2cpp_dict<std::uintptr_t, il2cpp_array<std::uintptr_t> *> *>
+    T &bakerenderermat() {
+        return *(T *)((std::uintptr_t)this + 0x10);
+    }
+
     template <typename T = void> static T initializeonloadentrypoint() {
-        return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C72BA4))(0);
+        return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A633FC))(0);
+    }
+
+    template <typename T = void> static T initializeonload() {
+        return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A63400))(0);
+    }
+
+    template <typename T = void> T onenable() {
+        return ((T(*)(graphicsdebuggerclient *))(il2cpp::il2cpp_base() +
+                                                 0x5A63520))(this);
+    }
+
+    template <typename T = void> T initialize() {
+        return ((T(*)(graphicsdebuggerclient *))(il2cpp::il2cpp_base() +
+                                                 0x5A63524))(this);
+    }
+
+    template <typename T = void> T onreceivecommand(std::uintptr_t _args) {
+        return ((T(*)(graphicsdebuggerclient *, std::uintptr_t))(
+            il2cpp::il2cpp_base() + 0x5A63BCC))(this, _args);
+    }
+
+    template <typename T = void> T onreceiveping(std::uintptr_t _args) {
+        return ((T(*)(graphicsdebuggerclient *, std::uintptr_t))(
+            il2cpp::il2cpp_base() + 0x5A63E90))(this, _args);
+    }
+
+    template <typename T = void>
+    T onreceivefetchruntimeinfo(std::uintptr_t _args) {
+        return ((T(*)(graphicsdebuggerclient *, std::uintptr_t))(
+            il2cpp::il2cpp_base() + 0x5A64390))(this, _args);
+    }
+
+    template <typename T = void>
+    T onreceiveapplyglobalkeywords(std::uintptr_t _args) {
+        return ((T(*)(graphicsdebuggerclient *, std::uintptr_t))(
+            il2cpp::il2cpp_base() + 0x5A64B60))(this, _args);
+    }
+
+    template <typename T = void>
+    T onreceiveapplyshaderlod(std::uintptr_t _args) {
+        return ((T(*)(graphicsdebuggerclient *, std::uintptr_t))(
+            il2cpp::il2cpp_base() + 0x5A65054))(this, _args);
+    }
+
+    template <typename T = void>
+    T onreceivedestroyshader(std::uintptr_t _args) {
+        return ((T(*)(graphicsdebuggerclient *, std::uintptr_t))(
+            il2cpp::il2cpp_base() + 0x5A65164))(this, _args);
+    }
+
+    template <typename T = void> T onreceiveshaderreload(std::uintptr_t _args) {
+        return ((T(*)(graphicsdebuggerclient *, std::uintptr_t))(
+            il2cpp::il2cpp_base() + 0x5A656A4))(this, _args);
+    }
+
+    template <typename T = void> T onconnected(std::int32_t __) {
+        return ((T(*)(graphicsdebuggerclient *, std::int32_t))(
+            il2cpp::il2cpp_base() + 0x5A665D0))(this, __);
+    }
+
+    template <typename T = void> T ondisconnected(std::int32_t __) {
+        return ((T(*)(graphicsdebuggerclient *, std::int32_t))(
+            il2cpp::il2cpp_base() + 0x5A66690))(this, __);
+    }
+
+    template <typename T = void> T sendplatform() {
+        return ((T(*)(graphicsdebuggerclient *))(il2cpp::il2cpp_base() +
+                                                 0x5A6402C))(this);
+    }
+
+    template <typename T = void>
+    T reloadshaders(il2cpp_array<std::uintptr_t> *_shaders) {
+        return (
+            (T(*)(graphicsdebuggerclient *, il2cpp_array<std::uintptr_t> *))(
+                il2cpp::il2cpp_base() + 0x5A66938))(this, _shaders);
+    }
+
+    template <typename T = void>
+    T reloadshadersex(il2cpp_array<std::uintptr_t> *_shaders) {
+        return (
+            (T(*)(graphicsdebuggerclient *, il2cpp_array<std::uintptr_t> *))(
+                il2cpp::il2cpp_base() + 0x5A659F4))(this, _shaders);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/headdata.h

@@ -11,6 +11,6 @@ class headdata {
     }
 
     template <typename T = void> T clear() {
-        return ((T(*)(headdata *))(il2cpp::il2cpp_base() + 0x4FCA2B8))(this);
+        return ((T(*)(headdata *))(il2cpp::il2cpp_base() + 0x5B6085C))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_asseteventreceivertest.h

@@ -8,7 +8,7 @@ class heuasseteventreceivertest {
                      il2cpp_list<std::uintptr_t> *_outputlist) {
         return ((T(*)(heuasseteventreceivertest *, std::uintptr_t, bool,
                       il2cpp_list<std::uintptr_t> *))(
-            il2cpp::il2cpp_base() + 0x4C72DF0))(this, _asset, _success,
+            il2cpp::il2cpp_base() + 0x5A6734C))(this, _asset, _success,
                                                 _outputlist);
     }
 
@@ -17,7 +17,7 @@ class heuasseteventreceivertest {
                      il2cpp_list<std::uintptr_t> *_outputlist) {
         return ((T(*)(heuasseteventreceivertest *, std::uintptr_t, bool,
                       il2cpp_list<std::uintptr_t> *))(
-            il2cpp::il2cpp_base() + 0x4C7305C))(this, _asset, _success,
+            il2cpp::il2cpp_base() + 0x5A675B8))(this, _asset, _success,
                                                 _outputlist);
     }
 
@@ -26,7 +26,7 @@ class heuasseteventreceivertest {
                     il2cpp_list<std::uintptr_t> *_outputlist) {
         return ((T(*)(heuasseteventreceivertest *, std::uintptr_t, bool,
                       il2cpp_list<std::uintptr_t> *))(
-            il2cpp::il2cpp_base() + 0x4C732C8))(this, _asset, _success,
+            il2cpp::il2cpp_base() + 0x5A67824))(this, _asset, _success,
                                                 _outputlist);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_scriptcallbackexample.h

@@ -9,11 +9,11 @@ class heuscriptcallbackexample {
 
     template <typename T = void> T assetcallbackwithmsg(il2cpp_string *_msg) {
         return ((T(*)(heuscriptcallbackexample *, il2cpp_string *))(
-            il2cpp::il2cpp_base() + 0x4C73544))(this, _msg);
+            il2cpp::il2cpp_base() + 0x5A67AA0))(this, _msg);
     }
 
     template <typename T = void> T assetcallbacknomsg() {
         return ((T(*)(heuscriptcallbackexample *))(il2cpp::il2cpp_base() +
-                                                   0x4C73650))(this);
+                                                   0x5A67BAC))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_scriptparameterexample.h

@@ -18,11 +18,11 @@ class heuscriptparameterexample {
 
     template <typename T = void> T start() {
         return ((T(*)(heuscriptparameterexample *))(il2cpp::il2cpp_base() +
-                                                    0x4C7372C))(this);
+                                                    0x5A67C88))(this);
     }
 
     template <typename T = void> T updategravity() {
         return ((T(*)(heuscriptparameterexample *))(il2cpp::il2cpp_base() +
-                                                    0x4C73890))(this);
+                                                    0x5A67DEC))(this);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/hitdelegate.h

@@ -5,19 +5,19 @@ class hitdelegate {
   public:
     template <typename T = void> T invoke(std::uintptr_t _hit) {
         return ((T(*)(hitdelegate *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                      0x397CA70))(this, _hit);
+                                                      0x41F725C))(this, _hit);
     }
 
     template <typename T = std::uintptr_t>
     T begininvoke(std::uintptr_t _hit, std::uintptr_t _callback,
                   std::uintptr_t _object) {
         return ((T(*)(hitdelegate *, std::uintptr_t, std::uintptr_t,
-                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x397F518))(
+                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x41F9D54))(
             this, _hit, _callback, _object);
     }
 
     template <typename T = void> T endinvoke(std::uintptr_t _result) {
         return ((T(*)(hitdelegate *, std::uintptr_t))(
-            il2cpp::il2cpp_base() + 0x397F5F8))(this, _result);
+            il2cpp::il2cpp_base() + 0x41F9E34))(this, _result);
     }
 };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_geoinfo.h

@@ -41,7 +41,7 @@ namespace houdiniengineunity {
         template <typename T = std::int32_t>
         T getgroupcountbytype(std::uintptr_t _type) {
             return ((T(*)(hapigeoinfo *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C73F2C))(this, _type);
+                il2cpp::il2cpp_base() + 0x5A68488))(this, _type);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_parminfo.h

@@ -123,32 +123,32 @@ namespace houdiniengineunity {
         }
 
         template <typename T = bool> T isint() {
-            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73F64))(
+            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x5A684C0))(
                 this);
         }
 
         template <typename T = bool> T isfloat() {
-            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73F78))(
+            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x5A684D4))(
                 this);
         }
 
         template <typename T = bool> T isstring() {
-            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73F90))(
+            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x5A684EC))(
                 this);
         }
 
         template <typename T = bool> T ispath() {
-            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73FA8))(
+            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x5A68504))(
                 this);
         }
 
         template <typename T = bool> T isnode() {
-            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73FC0))(
+            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x5A6851C))(
                 this);
         }
 
         template <typename T = bool> T isnonvalue() {
-            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73FD4))(
+            return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x5A68530))(
                 this);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_partinfo.h

@@ -39,62 +39,62 @@ namespace houdiniengineunity {
         template <typename T = std::int32_t>
         T getelementcountbyattributeowner(std::uintptr_t _owner) {
             return ((T(*)(hapipartinfo *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7422C))(this, _owner);
+                il2cpp::il2cpp_base() + 0x5A68788))(this, _owner);
         }
 
         template <typename T = std::int32_t>
         T getelementcountbygrouptype(std::uintptr_t _type) {
             return ((T(*)(hapipartinfo *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C742A4))(this, _type);
+                il2cpp::il2cpp_base() + 0x5A68800))(this, _type);
         }
 
         template <typename T = void> T init() {
-            return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x4C74368))(
+            return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x5A688C4))(
                 this);
         }
 
         template <typename T = std::int32_t> T get_pointattributecount() {
-            return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x4C743B4))(
+            return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x5A68910))(
                 this);
         }
 
         template <typename T = void>
         T set_pointattributecount(std::int32_t _value) {
             return ((T(*)(hapipartinfo *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C74404))(this, _value);
+                il2cpp::il2cpp_base() + 0x5A68960))(this, _value);
         }
 
         template <typename T = std::int32_t> T get_primitiveattributecount() {
-            return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x4C74450))(
+            return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x5A689AC))(
                 this);
         }
 
         template <typename T = void>
         T set_primitiveattributecount(std::int32_t _value) {
             return ((T(*)(hapipartinfo *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C744A0))(this, _value);
+                il2cpp::il2cpp_base() + 0x5A689FC))(this, _value);
         }
 
         template <typename T = std::int32_t> T get_vertexattributecount() {
-            return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x4C744EC))(
+            return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x5A68A48))(
                 this);
         }
 
         template <typename T = void>
         T set_vertexattributecount(std::int32_t _value) {
             return ((T(*)(hapipartinfo *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C7453C))(this, _value);
+                il2cpp::il2cpp_base() + 0x5A68A98))(this, _value);
         }
 
         template <typename T = std::int32_t> T get_detailattributecount() {
-            return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x4C74588))(
+            return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x5A68AE4))(
                 this);
         }
 
         template <typename T = void>
         T set_detailattributecount(std::int32_t _value) {
             return ((T(*)(hapipartinfo *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C745D8))(this, _value);
+                il2cpp::il2cpp_base() + 0x5A68B34))(this, _value);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_transform.h

@@ -22,7 +22,7 @@ namespace houdiniengineunity {
         }
 
         template <typename T = void> T init() {
-            return ((T(*)(hapitransform *))(il2cpp::il2cpp_base() + 0x4C74D6C))(
+            return ((T(*)(hapitransform *))(il2cpp::il2cpp_base() + 0x5A692C8))(
                 this);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_assetdatabase.h

@@ -5,120 +5,120 @@ namespace houdiniengineunity {
     class heuassetdatabase {
       public:
         template <typename T = il2cpp_string *> static T getassetcachepath() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C7534C))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A698A8))(0);
         }
 
         template <typename T = il2cpp_string *>
         static T getassetrelativepath(il2cpp_string *_infullpath) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C75450))(0, _infullpath);
+                                                    0x5A699AC))(0, _infullpath);
         }
 
         template <typename T = il2cpp_string *>
         static T getassetpath(std::uintptr_t _asset) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C755DC))(0, _asset);
+                                                   0x5A69B38))(0, _asset);
         }
 
         template <typename T = il2cpp_string *>
         static T getassetrelativepathstart() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C7569C))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A69BF8))(0);
         }
 
         template <typename T = il2cpp_string *>
         static T getassetfullpath(il2cpp_string *_inassetrelativepath) {
             return ((T(*)(void *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C757A4))(0, _inassetrelativepath);
+                il2cpp::il2cpp_base() + 0x5A69D00))(0, _inassetrelativepath);
         }
 
         template <typename T = bool>
         static T ispathrelativetoassets(il2cpp_string *_inpath) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C75A14))(0, _inpath);
+                                                    0x5A69F70))(0, _inpath);
         }
 
         template <typename T = il2cpp_string *>
         static T getassetrootpath(std::uintptr_t _asset) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C75A4C))(0, _asset);
+                                                   0x5A69FA8))(0, _asset);
         }
 
         template <typename T = il2cpp_string *>
         static T getuniqueassetpath(il2cpp_string *_path) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C75B0C))(0, _path);
+                                                    0x5A6A068))(0, _path);
         }
 
         template <typename T = il2cpp_string *>
         static T getassetorscenepath(std::uintptr_t _inputobject) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C75BCC))(0, _inputobject);
+                                                   0x5A6A128))(0, _inputobject);
         }
 
         template <typename T = bool>
         static T ispathinassetcache(il2cpp_string *_path) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C75C8C))(0, _path);
+                                                    0x5A6A1E8))(0, _path);
         }
 
         template <typename T = bool>
         static T ispathinassetcachebakedfolder(il2cpp_string *_path) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C75CF4))(0, _path);
+                                                    0x5A6A250))(0, _path);
         }
 
         template <typename T = bool>
         static T ispathinassetcacheworkingfolder(il2cpp_string *_path) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C75DB4))(0, _path);
+                                                    0x5A6A310))(0, _path);
         }
 
         template <typename T = bool>
         static T isassetinassetcachebakedfolder(std::uintptr_t _asset) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C75E74))(0, _asset);
+                                                   0x5A6A3D0))(0, _asset);
         }
 
         template <typename T = bool>
         static T isassetinassetcacheworkingfolder(std::uintptr_t _asset) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C75F34))(0, _asset);
+                                                   0x5A6A490))(0, _asset);
         }
 
         template <typename T = il2cpp_string *>
         static T createassetcachefolder(il2cpp_string *_suggestedassetpath) {
             return ((T(*)(void *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C75FF4))(0, _suggestedassetpath);
+                il2cpp::il2cpp_base() + 0x5A6A550))(0, _suggestedassetpath);
         }
 
         template <typename T = void>
         static T deleteassetcachefolder(il2cpp_string *_assetcachefolderpath) {
             return ((T(*)(void *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C760B4))(0, _assetcachefolderpath);
+                il2cpp::il2cpp_base() + 0x5A6A610))(0, _assetcachefolderpath);
         }
 
         template <typename T = void>
         static T deleteasset(std::uintptr_t _asset) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C76170))(0, _asset);
+                                                   0x5A6A6CC))(0, _asset);
         }
 
         template <typename T = void>
         static T deleteassetifinbakedfolder(std::uintptr_t _asset) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C7622C))(0, _asset);
+                                                   0x5A6A788))(0, _asset);
         }
 
         template <typename T = bool>
         static T containsasset(std::uintptr_t _assetobject) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C762E8))(0, _assetobject);
+                                                   0x5A6A844))(0, _assetobject);
         }
 
         template <typename T = bool>
         static T copyasset(il2cpp_string *_path, il2cpp_string *_newpath) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C763A8))(0, _path, _newpath);
+                il2cpp::il2cpp_base() + 0x5A6A904))(0, _path, _newpath);
         }
 
         template <typename T = std::uintptr_t>
@@ -126,7 +126,7 @@ namespace houdiniengineunity {
                                il2cpp_string *_newassetfolderpath,
                                std::uintptr_t _type) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C76468))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A6A9C4))(
                 0, _srcasset, _newassetfolderpath, _type);
         }
 
@@ -138,7 +138,7 @@ namespace houdiniengineunity {
                                        std::uintptr_t _type) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           il2cpp_string *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C76528))(0, _objecttocreate,
+                il2cpp::il2cpp_base() + 0x5A6AA84))(0, _objecttocreate,
                                                     _assetcachefolderpath,
                                                     _assetfilename, _type);
         }
@@ -150,7 +150,7 @@ namespace houdiniengineunity {
             std::uintptr_t _assetdbobject) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_string *,
                           std::uintptr_t, std::uintptr_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C765E4))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A6AB40))(
                 0, _assetname, _assetobjectfilename, _objecttoadd,
                 _bakedassetpath, _assetdbobject);
         }
@@ -159,120 +159,120 @@ namespace houdiniengineunity {
         static T addobjecttoasset(std::uintptr_t _objecttoadd,
                                   std::uintptr_t _assetobject) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C766A0))(0, _objecttoadd,
+                il2cpp::il2cpp_base() + 0x5A6ABFC))(0, _objecttoadd,
                                                     _assetobject);
         }
 
         template <typename T = void> static T saveandrefreshdatabase() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C7675C))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A6ACB8))(0);
         }
 
         template <typename T = void> static T refreshassetdatabase() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C76760))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A6ACBC))(0);
         }
 
         template <typename T = std::uintptr_t>
         static T loadassetatpath(il2cpp_string *_assetpath,
                                  std::uintptr_t _type) {
             return ((T(*)(void *, il2cpp_string *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C76764))(0, _assetpath, _type);
+                il2cpp::il2cpp_base() + 0x5A6ACC0))(0, _assetpath, _type);
         }
 
         template <typename T = il2cpp_array<std::uintptr_t> *>
         static T loadallassetsatpath(il2cpp_string *_assetpath) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C76824))(0, _assetpath);
+                                                    0x5A6AD80))(0, _assetpath);
         }
 
         template <typename T = void>
         static T importasset(il2cpp_string *_assetpath,
                              std::uintptr_t _heuoptions) {
             return ((T(*)(void *, il2cpp_string *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C768E4))(0, _assetpath, _heuoptions);
+                il2cpp::il2cpp_base() + 0x5A6AE40))(0, _assetpath, _heuoptions);
         }
 
         template <typename T = il2cpp_string *> static T getassetworkingpath() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C769A0))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A6AEFC))(0);
         }
 
         template <typename T = il2cpp_string *> static T getassetbakedpath() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C76A60))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A6AFBC))(0);
         }
 
         template <typename T = il2cpp_string *>
         static T getassetbakedpathwithassetname(il2cpp_string *_assetname) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C76B20))(0, _assetname);
+                                                    0x5A6B07C))(0, _assetname);
         }
 
         template <typename T = il2cpp_string *>
         static T createuniquebakepath(il2cpp_string *_assetname) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C76BE0))(0, _assetname);
+                                                    0x5A6B13C))(0, _assetname);
         }
 
         template <typename T = void>
         static T createpathwithfolders(il2cpp_string *_inpath) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C76CA0))(0, _inpath);
+                                                    0x5A6B1FC))(0, _inpath);
         }
 
         template <typename T = il2cpp_string *>
         static T
         appendmeshespathtoassetfolder(il2cpp_string *_inassetcachefolder) {
             return ((T(*)(void *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C76D5C))(0, _inassetcachefolder);
+                il2cpp::il2cpp_base() + 0x5A6B2B8))(0, _inassetcachefolder);
         }
 
         template <typename T = il2cpp_string *>
         static T
         appendtexturespathtoassetfolder(il2cpp_string *_inassetcachefolder) {
             return ((T(*)(void *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C76E58))(0, _inassetcachefolder);
+                il2cpp::il2cpp_base() + 0x5A6B3B4))(0, _inassetcachefolder);
         }
 
         template <typename T = il2cpp_string *>
         static T
         appendmaterialspathtoassetfolder(il2cpp_string *_inassetcachefolder) {
             return ((T(*)(void *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C76F54))(0, _inassetcachefolder);
+                il2cpp::il2cpp_base() + 0x5A6B4B0))(0, _inassetcachefolder);
         }
 
         template <typename T = il2cpp_array<std::uintptr_t> *>
         static T getassetsubfolders() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C77050))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A6B5AC))(0);
         }
 
         template <typename T = il2cpp_string *>
         static T appendprefabpath(il2cpp_string *_inassetcachefolder,
                                   il2cpp_string *_assetname) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C7723C))(0, _inassetcachefolder,
+                il2cpp::il2cpp_base() + 0x5A6B798))(0, _inassetcachefolder,
                                                     _assetname);
         }
 
         template <typename T = il2cpp_string *>
         static T appendmeshesassetfilename(il2cpp_string *_assetname) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C77388))(0, _assetname);
+                                                    0x5A6B8E4))(0, _assetname);
         }
 
         template <typename T = bool>
         static T isassetsavedinscene(std::uintptr_t _go) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C7744C))(0, _go);
+                                                   0x5A6B9A8))(0, _go);
         }
 
         template <typename T = void>
         static T printdependencies(std::uintptr_t _targetgo) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C7750C))(0, _targetgo);
+                                                   0x5A6BA68))(0, _targetgo);
         }
 
         template <typename T = il2cpp_string *>
         static T getuniqueassetpathforunityasset(std::uintptr_t _obj) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C77510))(0, _obj);
+                                                   0x5A6BA6C))(0, _obj);
         }
 
         template <typename T = std::uintptr_t>

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_assetpresetutility.h

@@ -8,14 +8,14 @@ namespace houdiniengineunity {
         static T saveassetpresettofile(std::uintptr_t _asset,
                                        il2cpp_string *_filepath) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C777D8))(0, _asset, _filepath);
+                il2cpp::il2cpp_base() + 0x5A6BD34))(0, _asset, _filepath);
         }
 
         template <typename T = void>
         static T loadpresetfileintoassetandcook(std::uintptr_t _asset,
                                                 il2cpp_string *_filepath) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C77CC0))(0, _asset, _filepath);
+                il2cpp::il2cpp_base() + 0x5A6C260))(0, _asset, _filepath);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_assettask.h

@@ -24,23 +24,23 @@ namespace houdiniengineunity {
         }
 
         template <typename T = std::uintptr_t> T gettasksession() {
-            return ((T(*)(heuassettask *))(il2cpp::il2cpp_base() + 0x4C78490))(
+            return ((T(*)(heuassettask *))(il2cpp::il2cpp_base() + 0x5A6CA50))(
                 this);
         }
 
         template <typename T = void> T dotask() {
-            return ((T(*)(heuassettask *))(il2cpp::il2cpp_base() + 0x4C78604))(
+            return ((T(*)(heuassettask *))(il2cpp::il2cpp_base() + 0x5A6CBC4))(
                 this);
         }
 
         template <typename T = void> T killtask() {
-            return ((T(*)(heuassettask *))(il2cpp::il2cpp_base() + 0x4C78B68))(
+            return ((T(*)(heuassettask *))(il2cpp::il2cpp_base() + 0x5A6D128))(
                 this);
         }
 
         template <typename T = void> T completetask(std::uintptr_t _result) {
             return ((T(*)(heuassettask *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C78D4C))(this, _result);
+                il2cpp::il2cpp_base() + 0x5A6D30C))(this, _result);
         }
 
         template <typename T = void>
@@ -48,7 +48,7 @@ namespace houdiniengineunity {
                                 il2cpp_list<std::uintptr_t> *_outputs) {
             return ((T(*)(heuassettask *, std::uintptr_t, bool,
                           il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C78F30))(this, _asset, _bsuccess,
+                il2cpp::il2cpp_base() + 0x5A6D4F0))(this, _asset, _bsuccess,
                                                     _outputs);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_assetupdater.h

@@ -5,19 +5,19 @@ namespace houdiniengineunity {
     class heuassetupdater {
       public:
         template <typename T = void> static T update() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C79004))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A6D5C4))(0);
         }
 
         template <typename T = void>
         static T addassetforupdate(std::uintptr_t _asset) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C79008))(0, _asset);
+                                                   0x5A6D5C8))(0, _asset);
         }
 
         template <typename T = void>
         static T removeasset(std::uintptr_t _asset) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C7900C))(0, _asset);
+                                                   0x5A6D5CC))(0, _asset);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_attributedata.h

@@ -30,13 +30,13 @@ namespace houdiniengineunity {
 
         template <typename T = bool> T iscolorattribute() {
             return ((T(*)(heuattributedata *))(il2cpp::il2cpp_base() +
-                                               0x4C79018))(this);
+                                               0x5A6D5D8))(this);
         }
 
         template <typename T = void>
         T copyvaluesto(std::uintptr_t _destattrdata) {
             return ((T(*)(heuattributedata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C790D8))(this, _destattrdata);
+                il2cpp::il2cpp_base() + 0x5A6D698))(this, _destattrdata);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_attributesstore.h

@@ -65,37 +65,37 @@ namespace houdiniengineunity {
 
         template <typename T = std::int32_t> T get_geoid() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7938C))(this);
+                                                 0x5A6D94C))(this);
         }
 
         template <typename T = std::int32_t> T get_partid() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C79394))(this);
+                                                 0x5A6D954))(this);
         }
 
         template <typename T = il2cpp_string *> T get_geoname() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7939C))(this);
+                                                 0x5A6D95C))(this);
         }
 
         template <typename T = bool> T hascolorattribute() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C793A4))(this);
+                                                 0x5A6D964))(this);
         }
 
         template <typename T = std::uintptr_t> T get_outputtransform() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C793AC))(this);
+                                                 0x5A6D96C))(this);
         }
 
         template <typename T = std::uintptr_t> T get_outputmesh() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C793B4))(this);
+                                                 0x5A6D974))(this);
         }
 
         template <typename T = void> T destroyalldata(std::uintptr_t _asset) {
             return ((T(*)(heuattributesstore *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C793BC))(this, _asset);
+                il2cpp::il2cpp_base() + 0x5A6D97C))(this, _asset);
         }
 
         template <typename T = void>
@@ -104,7 +104,7 @@ namespace houdiniengineunity {
                                 std::uintptr_t _outputgameobject) {
             return ((T(*)(heuattributesstore *, std::uintptr_t, std::uintptr_t,
                           std::int32_t, std::uintptr_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C794E0))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A6DAA0))(
                 this, _session, _asset, _geoid, _partinfo, _outputgameobject);
         }
 
@@ -112,19 +112,19 @@ namespace houdiniengineunity {
         T setupmeshandmaterials(std::uintptr_t _asset, std::uintptr_t _parttype,
                                 std::uintptr_t _outputgameobject) {
             return ((T(*)(heuattributesstore *, std::uintptr_t, std::uintptr_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C7AA38))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A6F0CC))(
                 this, _asset, _parttype, _outputgameobject);
         }
 
         template <typename T = bool> T hasdirtyattributes() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7ACDC))(this);
+                                                 0x5A6F370))(this);
         }
 
         template <typename T = void>
         T syncdirtyattributestohoudini(std::uintptr_t _session) {
             return ((T(*)(heuattributesstore *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7AF00))(this, _session);
+                il2cpp::il2cpp_base() + 0x5A6F594))(this, _session);
         }
 
         template <typename T = void>
@@ -134,7 +134,7 @@ namespace houdiniengineunity {
                                 std::uintptr_t _attributeinfo) {
             return ((T(*)(heuattributesstore *, std::uintptr_t, std::int32_t,
                           std::int32_t, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7A130))(this, _session, _geoid,
+                il2cpp::il2cpp_base() + 0x5A6E780))(this, _session, _geoid,
                                                     _partid, _attributedata,
                                                     _attributeinfo);
         }
@@ -148,7 +148,7 @@ namespace houdiniengineunity {
             return ((T(*)(heuattributesstore *, std::uintptr_t, std::int32_t,
                           std::int32_t, il2cpp_list<std::uintptr_t> *,
                           std::uintptr_t,
-                          std::int32_t))(il2cpp::il2cpp_base() + 0x4C7B714))(
+                          std::int32_t))(il2cpp::il2cpp_base() + 0x5A6FE54))(
                 this, _session, _geoid, _partid, _attributeslist, _ownertype,
                 _attributecount);
         }
@@ -158,7 +158,7 @@ namespace houdiniengineunity {
                           std::int32_t _partid, std::uintptr_t _attributedata) {
             return ((T(*)(heuattributesstore *, std::uintptr_t, std::int32_t,
                           std::int32_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7B9D4))(this, _session, _geoid,
+                il2cpp::il2cpp_base() + 0x5A7014C))(this, _session, _geoid,
                                                     _partid, _attributedata);
         }
 
@@ -168,14 +168,14 @@ namespace houdiniengineunity {
                               il2cpp_list<std::uintptr_t> *_attributedatalist) {
             return ((T(*)(heuattributesstore *, std::uintptr_t, std::int32_t,
                           std::int32_t, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C7C06C))(
+                il2cpp::il2cpp_base() + 0x5A7084C))(
                 this, _session, _geoid, _partid, _attributedatalist);
         }
 
         template <typename T = void>
         T refreshupstreaminputs(std::uintptr_t _session) {
             return ((T(*)(heuattributesstore *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7C1F8))(this, _session);
+                il2cpp::il2cpp_base() + 0x5A709D8))(this, _session);
         }
 
         template <typename T = bool>
@@ -183,76 +183,76 @@ namespace houdiniengineunity {
                                       std::int32_t _geoid,
                                       std::int32_t _partid) {
             return ((T(*)(heuattributesstore *, std::uintptr_t, std::int32_t,
-                          std::int32_t))(il2cpp::il2cpp_base() + 0x4C7AFEC))(
+                          std::int32_t))(il2cpp::il2cpp_base() + 0x5A6F680))(
                 this, _session, _geoid, _partid);
         }
 
         template <typename T = void>
         static T setattributedatasyncd(std::uintptr_t _attributedata) {
             return ((T(*)(void *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7B6F0))(0, _attributedata);
+                il2cpp::il2cpp_base() + 0x5A6FE30))(0, _attributedata);
         }
 
         template <typename T = void>
         static T setattributedatadirty(std::uintptr_t _attributedata) {
             return ((T(*)(void *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7C304))(0, _attributedata);
+                il2cpp::il2cpp_base() + 0x5A70AFC))(0, _attributedata);
         }
 
         template <typename T = std::uintptr_t>
         T createattribute(il2cpp_string *_attributename,
                           std::uintptr_t _attributeinfo) {
             return ((T(*)(heuattributesstore *, il2cpp_string *,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C7A038))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A6E688))(
                 this, _attributename, _attributeinfo);
         }
 
         template <typename T = std::uintptr_t>
         T getattributedata(il2cpp_string *_name) {
             return ((T(*)(heuattributesstore *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C79E44))(this, _name);
+                il2cpp::il2cpp_base() + 0x5A6E494))(this, _name);
         }
 
         template <typename T = std::uintptr_t>
         T getattributedata_1(std::int32_t _index) {
             return ((T(*)(heuattributesstore *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C7C328))(this, _index);
+                il2cpp::il2cpp_base() + 0x5A70B20))(this, _index);
         }
 
         template <typename T = il2cpp_list<il2cpp_string *> *>
         T getattributenames() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7C410))(this);
+                                                 0x5A70C08))(this);
         }
 
         template <typename T = void> T enablepaintcollider() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7C614))(this);
+                                                 0x5A70E0C))(this);
         }
 
         template <typename T = void> T disablepaintcollider() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7C864))(this);
+                                                 0x5A7105C))(this);
         }
 
         template <typename T = void> T showpaintmesh() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7CA30))(this);
+                                                 0x5A71228))(this);
         }
 
         template <typename T = void> T hidepaintmesh() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7CC08))(this);
+                                                 0x5A71400))(this);
         }
 
         template <typename T = bool> T hasmeshforpainting() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7CD74))(this);
+                                                 0x5A7156C))(this);
         }
 
         template <typename T = std::uintptr_t> T getpaintmeshcollider() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7CE24))(this);
+                                                 0x5A7161C))(this);
         }
 
         template <typename T = void>
@@ -262,7 +262,7 @@ namespace houdiniengineunity {
                          std::uintptr_t _setattrfunc) {
             return ((T(*)(heuattributesstore *, std::uintptr_t, std::uintptr_t,
                           std::int32_t, float,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C7CEE4))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A716DC))(
                 this, _attributedata, _sourcetools, _attributeindex,
                 _paintfactor, _setattrfunc);
         }
@@ -274,7 +274,7 @@ namespace houdiniengineunity {
                                  il2cpp_array<std::uintptr_t> *_values) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C7D064))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A7185C))(0, _attributedata,
                                                     _startindex, _values);
         }
 
@@ -285,7 +285,7 @@ namespace houdiniengineunity {
                                    il2cpp_array<std::uintptr_t> *_values) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C7D11C))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A71914))(0, _attributedata,
                                                     _startindex, _values);
         }
 
@@ -296,7 +296,7 @@ namespace houdiniengineunity {
                                     il2cpp_array<std::uintptr_t> *_values) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C7D1E4))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A719DC))(0, _attributedata,
                                                     _startindex, _values);
         }
 
@@ -308,7 +308,7 @@ namespace houdiniengineunity {
                                           float _factor) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
                           std::int32_t, float))(
-                il2cpp::il2cpp_base() + 0x4C7D2C4))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A71ABC))(0, _attributedata,
                                                     _targetindex, _sourcetools,
                                                     _sourceindex, _factor);
         }
@@ -321,7 +321,7 @@ namespace houdiniengineunity {
                                       float _factor) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
                           std::int32_t, float))(
-                il2cpp::il2cpp_base() + 0x4C7D4B4))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A71CAC))(0, _attributedata,
                                                     _targetindex, _sourcetools,
                                                     _sourceindex, _factor);
         }
@@ -334,7 +334,7 @@ namespace houdiniengineunity {
                                            float _factor) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
                           std::int32_t, float))(
-                il2cpp::il2cpp_base() + 0x4C7D66C))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A71E64))(0, _attributedata,
                                                     _targetindex, _sourcetools,
                                                     _sourceindex, _factor);
         }
@@ -347,7 +347,7 @@ namespace houdiniengineunity {
                                            float _factor) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
                           std::int32_t, float))(
-                il2cpp::il2cpp_base() + 0x4C7D824))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A7201C))(0, _attributedata,
                                                     _targetindex, _sourcetools,
                                                     _sourceindex, _factor);
         }
@@ -360,7 +360,7 @@ namespace houdiniengineunity {
                                             float _factor) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
                           std::int32_t, float))(
-                il2cpp::il2cpp_base() + 0x4C7DA64))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A7225C))(0, _attributedata,
                                                     _targetindex, _sourcetools,
                                                     _sourceindex, _factor);
         }
@@ -373,7 +373,7 @@ namespace houdiniengineunity {
                                         float _factor) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
                           std::int32_t, float))(
-                il2cpp::il2cpp_base() + 0x4C7DB98))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A72390))(0, _attributedata,
                                                     _targetindex, _sourcetools,
                                                     _sourceindex, _factor);
         }
@@ -386,7 +386,7 @@ namespace houdiniengineunity {
                                              float _factor) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
                           std::int32_t, float))(
-                il2cpp::il2cpp_base() + 0x4C7DCA4))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A7249C))(0, _attributedata,
                                                     _targetindex, _sourcetools,
                                                     _sourceindex, _factor);
         }
@@ -399,7 +399,7 @@ namespace houdiniengineunity {
                                              float _factor) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
                           std::int32_t, float))(
-                il2cpp::il2cpp_base() + 0x4C7DDB0))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A725A8))(0, _attributedata,
                                                     _targetindex, _sourcetools,
                                                     _sourceindex, _factor);
         }
@@ -412,7 +412,7 @@ namespace houdiniengineunity {
                                          float _factor) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
                           std::int32_t, float))(
-                il2cpp::il2cpp_base() + 0x4C7DFC4))(0, _attributedata,
+                il2cpp::il2cpp_base() + 0x5A727BC))(0, _attributedata,
                                                     _targetindex, _sourcetools,
                                                     _sourceindex, _factor);
         }
@@ -421,13 +421,13 @@ namespace houdiniengineunity {
         T fillattribute(std::uintptr_t _attributedata,
                         std::uintptr_t _sourcetools) {
             return ((T(*)(heuattributesstore *, std::uintptr_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C7E0CC))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A728C4))(
                 this, _attributedata, _sourcetools);
         }
 
         template <typename T = bool> T areattributesdirty() {
             return ((T(*)(heuattributesstore *))(il2cpp::il2cpp_base() +
-                                                 0x4C7E728))(this);
+                                                 0x5A72F20))(this);
         }
 
         template <typename T = void>
@@ -435,28 +435,28 @@ namespace houdiniengineunity {
             il2cpp_array<std::uintptr_t> **_positionarray) {
             return (
                 (T(*)(heuattributesstore *, il2cpp_array<std::uintptr_t> **))(
-                    il2cpp::il2cpp_base() + 0x4C7E8F8))(this, _positionarray);
+                    il2cpp::il2cpp_base() + 0x5A730F0))(this, _positionarray);
         }
 
         template <typename T = void>
         T getvertexindices(il2cpp_array<std::uintptr_t> **_indices) {
             return (
                 (T(*)(heuattributesstore *, il2cpp_array<std::uintptr_t> **))(
-                    il2cpp::il2cpp_base() + 0x4C7E904))(this, _indices);
+                    il2cpp::il2cpp_base() + 0x5A730FC))(this, _indices);
         }
 
         template <typename T = std::uintptr_t>
         static T getattributesetvaluefunction(std::uintptr_t _attrtype,
                                               std::uintptr_t _paintmergemode) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7E188))(0, _attrtype,
+                il2cpp::il2cpp_base() + 0x5A72980))(0, _attrtype,
                                                     _paintmergemode);
         }
 
         template <typename T = void>
         T copyattributevaluesto(std::uintptr_t _destattrstore) {
             return ((T(*)(heuattributesstore *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7E924))(this, _destattrstore);
+                il2cpp::il2cpp_base() + 0x5A7311C))(this, _destattrstore);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_curve.h

@@ -36,37 +36,37 @@ namespace houdiniengineunity {
         }
 
         template <typename T = std::int32_t> T get_geoid() {
-            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x4C7ED28))(
+            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x5A73520))(
                 this);
         }
 
         template <typename T = bool> T iseditable() {
-            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x4C7ED30))(
+            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x5A73528))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_parameters() {
-            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x4C7ED38))(
+            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x5A73530))(
                 this);
         }
 
         template <typename T = void> T setuploadparameterpreset(bool _bvalue) {
             return ((T(*)(heucurve *, bool))(il2cpp::il2cpp_base() +
-                                             0x4C7ED40))(this, _bvalue);
+                                             0x5A73538))(this, _bvalue);
         }
 
         template <typename T = il2cpp_string *> T get_curvename() {
-            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x4C7ED48))(
+            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x5A73540))(
                 this);
         }
 
         template <typename T = bool> T isgeocurve() {
-            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x4C7ED50))(
+            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x5A73548))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_editstate() {
-            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x4C7ED58))(
+            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x5A73550))(
                 this);
         }
 
@@ -76,25 +76,25 @@ namespace houdiniengineunity {
                                   std::int32_t _geoid, bool _bgeocurve) {
             return (
                 (T(*)(void *, std::uintptr_t, bool, il2cpp_string *,
-                      std::int32_t, bool))(il2cpp::il2cpp_base() + 0x4C7ED60))(
+                      std::int32_t, bool))(il2cpp::il2cpp_base() + 0x5A73558))(
                 0, _parentasset, _iseditable, _curvename, _geoid, _bgeocurve);
         }
 
         template <typename T = void> T destroyalldata() {
-            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x4C7EE44))(
+            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x5A7363C))(
                 this);
         }
 
         template <typename T = void> T setcurvename(il2cpp_string *_name) {
             return ((T(*)(heucurve *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C7EF9C))(this, _name);
+                il2cpp::il2cpp_base() + 0x5A73794))(this, _name);
         }
 
         template <typename T = void>
         T uploadparameterpreset(std::uintptr_t _session, std::int32_t _geoid,
                                 std::uintptr_t _parentasset) {
             return ((T(*)(heucurve *, std::uintptr_t, std::int32_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C7F080))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A73878))(
                 this, _session, _geoid, _parentasset);
         }
 
@@ -102,7 +102,7 @@ namespace houdiniengineunity {
         T resetcurveparameters(std::uintptr_t _session,
                                std::uintptr_t _parentasset) {
             return ((T(*)(heucurve *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7F1D4))(this, _session,
+                il2cpp::il2cpp_base() + 0x5A739CC))(this, _session,
                                                     _parentasset);
         }
 
@@ -112,27 +112,27 @@ namespace houdiniengineunity {
             il2cpp_array<std::uintptr_t> *_parameterpreset) {
             return ((T(*)(heucurve *, std::uintptr_t, std::uintptr_t,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C7F2FC))(
+                il2cpp::il2cpp_base() + 0x5A73AF4))(
                 this, _session, _parentasset, _parameterpreset);
         }
 
         template <typename T = void>
         T updatecurve(std::uintptr_t _session, std::int32_t _partid) {
             return ((T(*)(heucurve *, std::uintptr_t, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C7F428))(this, _session, _partid);
+                il2cpp::il2cpp_base() + 0x5A73C20))(this, _session, _partid);
         }
 
         template <typename T = void>
         T generatemesh(std::uintptr_t _ingameobject) {
             return ((T(*)(heucurve *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7F784))(this, _ingameobject);
+                il2cpp::il2cpp_base() + 0x5A73F90))(this, _ingameobject);
         }
 
         template <typename T = void>
         T syncfromparameters(std::uintptr_t _session,
                              std::uintptr_t _parentasset) {
             return ((T(*)(heucurve *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7FC88))(this, _session,
+                il2cpp::il2cpp_base() + 0x5A74494))(this, _session,
                                                     _parentasset);
         }
 
@@ -140,89 +140,89 @@ namespace houdiniengineunity {
         T projecttocolliders(std::uintptr_t _parentasset,
                              il2cpp_vec3 _raydirection, float _raydistance) {
             return ((T(*)(heucurve *, std::uintptr_t, il2cpp_vec3, float))(
-                il2cpp::il2cpp_base() + 0x4C80454))(
+                il2cpp::il2cpp_base() + 0x5A74C78))(
                 this, _parentasset, _raydirection, _raydistance);
         }
 
         template <typename T = il2cpp_string *>
         static T getpointsstring(il2cpp_list<il2cpp_vec3> *_points) {
             return ((T(*)(void *, il2cpp_list<il2cpp_vec3> *))(
-                il2cpp::il2cpp_base() + 0x4C80B54))(0, _points);
+                il2cpp::il2cpp_base() + 0x5A75378))(0, _points);
         }
 
         template <typename T = void> T seteditstate(std::uintptr_t _editstate) {
             return ((T(*)(heucurve *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C7EE3C))(this, _editstate);
+                il2cpp::il2cpp_base() + 0x5A73634))(this, _editstate);
         }
 
         template <typename T = void>
         T setcurvepoint(std::int32_t _pointindex, il2cpp_vec3 _newposition) {
             return ((T(*)(heucurve *, std::int32_t, il2cpp_vec3))(
-                il2cpp::il2cpp_base() + 0x4C80E6C))(this, _pointindex,
+                il2cpp::il2cpp_base() + 0x5A756A4))(this, _pointindex,
                                                     _newposition);
         }
 
         template <typename T = il2cpp_vec3>
         T getcurvepoint(std::int32_t _pointindex) {
             return ((T(*)(heucurve *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C80F68))(this, _pointindex);
+                il2cpp::il2cpp_base() + 0x5A757A0))(this, _pointindex);
         }
 
         template <typename T = il2cpp_list<il2cpp_vec3> *> T getallpoints() {
-            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x4C81060))(
+            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x5A75898))(
                 this);
         }
 
         template <typename T = std::int32_t> T getnumpoints() {
-            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x4C81068))(
+            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x5A758A0))(
                 this);
         }
 
         template <typename T = il2cpp_vec3>
         T gettransformedpoint(std::int32_t _pointindex) {
             return ((T(*)(heucurve *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C81100))(this, _pointindex);
+                il2cpp::il2cpp_base() + 0x5A75938))(this, _pointindex);
         }
 
         template <typename T = il2cpp_vec3>
         T gettransformedposition(il2cpp_vec3 _inposition) {
             return ((T(*)(heucurve *, il2cpp_vec3))(
-                il2cpp::il2cpp_base() + 0x4C81220))(this, _inposition);
+                il2cpp::il2cpp_base() + 0x5A75A58))(this, _inposition);
         }
 
         template <typename T = il2cpp_vec3>
         T getinvertedtransformedposition(il2cpp_vec3 _inposition) {
             return ((T(*)(heucurve *, il2cpp_vec3))(
-                il2cpp::il2cpp_base() + 0x4C81288))(this, _inposition);
+                il2cpp::il2cpp_base() + 0x5A75AC0))(this, _inposition);
         }
 
         template <typename T = il2cpp_array<std::uintptr_t> *> T getvertices() {
-            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x4C812F0))(
+            return ((T(*)(heucurve *))(il2cpp::il2cpp_base() + 0x5A75B28))(
                 this);
         }
 
         template <typename T = void>
         T setcurvegeometryvisibility(bool _bvisible) {
             return ((T(*)(heucurve *, bool))(il2cpp::il2cpp_base() +
-                                             0x4C812F8))(this, _bvisible);
+                                             0x5A75B30))(this, _bvisible);
         }
 
         template <typename T = void>
         T downloadpresetdata(std::uintptr_t _session) {
             return ((T(*)(heucurve *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C80374))(this, _session);
+                il2cpp::il2cpp_base() + 0x5A74B98))(this, _session);
         }
 
         template <typename T = void>
         T uploadpresetdata(std::uintptr_t _session) {
             return ((T(*)(heucurve *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C8144C))(this, _session);
+                il2cpp::il2cpp_base() + 0x5A75C84))(this, _session);
         }
 
         template <typename T = void>
         T downloadasdefaultpresetdata(std::uintptr_t _session) {
             return ((T(*)(heucurve *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C8152C))(this, _session);
+                il2cpp::il2cpp_base() + 0x5A75D64))(this, _session);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_editorutility.h

@@ -5,74 +5,74 @@ namespace houdiniengineunity {
     class heueditorutility {
       public:
         template <typename T = void> static T markscenedirty() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C81838))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A760A0))(0);
         }
 
         template <typename T = void>
         static T selectobject(std::uintptr_t _gameobject) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C8183C))(0, _gameobject);
+                                                   0x5A760A4))(0, _gameobject);
         }
 
         template <typename T = void>
         static T selectobjects(il2cpp_array<std::uintptr_t> *_gameobjects) {
             return ((T(*)(void *, il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C81840))(0, _gameobjects);
+                il2cpp::il2cpp_base() + 0x5A760A8))(0, _gameobjects);
         }
 
         template <typename T = std::uintptr_t>
         static T createprefab(il2cpp_string *_path, std::uintptr_t _go) {
             return ((T(*)(void *, il2cpp_string *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C81844))(0, _path, _go);
+                il2cpp::il2cpp_base() + 0x5A760AC))(0, _path, _go);
         }
 
         template <typename T = bool> static T iseditorplaying() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C8036C))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A74B90))(0);
         }
 
         template <typename T = std::uintptr_t>
         static T replaceprefab(std::uintptr_t _go, std::uintptr_t _targetprefab,
                                std::uintptr_t _heuoptions) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C81904))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A7616C))(
                 0, _go, _targetprefab, _heuoptions);
         }
 
         template <typename T = bool>
         static T isprefabinstance(std::uintptr_t _go) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C819C4))(0, _go);
+                                                   0x5A7622C))(0, _go);
         }
 
         template <typename T = bool>
         static T isprefaboriginal(std::uintptr_t _go) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C81A84))(0, _go);
+                                                   0x5A762EC))(0, _go);
         }
 
         template <typename T = bool>
         static T isdisconnectedprefabinstance(std::uintptr_t _go) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C81B44))(0, _go);
+                                                   0x5A763AC))(0, _go);
         }
 
         template <typename T = std::uintptr_t>
         static T getprefabparent(std::uintptr_t _go) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C81C04))(0, _go);
+                                                   0x5A7646C))(0, _go);
         }
 
         template <typename T = std::uintptr_t>
         static T connectgameobjecttoprefab(std::uintptr_t _go,
                                            std::uintptr_t _sourceprefab) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C81CC4))(0, _go, _sourceprefab);
+                il2cpp::il2cpp_base() + 0x5A7652C))(0, _go, _sourceprefab);
         }
 
         template <typename T = std::uintptr_t>
         static T instantiateprefab(std::uintptr_t _prefaboriginal) {
             return ((T(*)(void *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C81D84))(0, _prefaboriginal);
+                il2cpp::il2cpp_base() + 0x5A765EC))(0, _prefaboriginal);
         }
 
         template <typename T = std::uintptr_t>
@@ -81,7 +81,7 @@ namespace houdiniengineunity {
                                        bool _instantiateinworldspace,
                                        bool _bregisterundo) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t, bool, bool))(
-                il2cpp::il2cpp_base() + 0x4C81E44))(
+                il2cpp::il2cpp_base() + 0x5A766AC))(
                 0, _sourcegameobject, _parenttransform,
                 _instantiateinworldspace, _bregisterundo);
         }
@@ -96,47 +96,47 @@ namespace houdiniengineunity {
         static T undorecordobject(std::uintptr_t _objecttoundo,
                                   il2cpp_string *_name) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C81F20))(0, _objecttoundo, _name);
+                il2cpp::il2cpp_base() + 0x5A76788))(0, _objecttoundo, _name);
         }
 
         template <typename T = void> static T undocollapsecurrentgroup() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C81F24))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A7678C))(0);
         }
 
         template <typename T = il2cpp_array<std::uintptr_t> *>
         static T collectdependencies(std::uintptr_t _obj) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C81F28))(0, _obj);
+                                                   0x5A76790))(0, _obj);
         }
 
         template <typename T = bool>
         static T ispersistant(std::uintptr_t _obj) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C81FE8))(0, _obj);
+                                                   0x5A76850))(0, _obj);
         }
 
         template <typename T = il2cpp_string *>
         static T getuniquenameforsibling(std::uintptr_t _parenttransform,
                                          il2cpp_string *_name) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C820A8))(0, _parenttransform, _name);
+                il2cpp::il2cpp_base() + 0x5A76910))(0, _parenttransform, _name);
         }
 
         template <typename T = void>
         static T displayprogressbar(il2cpp_string *_title, il2cpp_string *_info,
                                     float _progress) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_string *, float))(
-                il2cpp::il2cpp_base() + 0x4C82168))(0, _title, _info,
+                il2cpp::il2cpp_base() + 0x5A769D0))(0, _title, _info,
                                                     _progress);
         }
 
         template <typename T = void> static T clearprogressbar() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C82224))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A76A8C))(0);
         }
 
         template <typename T = bool>
         static T iseditornotinplaymodeandnotgoingtoplaymode() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C822E0))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A76B48))(0);
         }
 
         template <typename T = bool>
@@ -144,7 +144,7 @@ namespace houdiniengineunity {
                                il2cpp_string *_ok, il2cpp_string *_cancel) {
             return (
                 (T(*)(void *, il2cpp_string *, il2cpp_string *, il2cpp_string *,
-                      il2cpp_string *))(il2cpp::il2cpp_base() + 0x4C82318))(
+                      il2cpp_string *))(il2cpp::il2cpp_base() + 0x5A76B80))(
                 0, _title, _message, _ok, _cancel);
         }
 
@@ -154,73 +154,73 @@ namespace houdiniengineunity {
                                     il2cpp_string *_cancel) {
             return (
                 (T(*)(void *, il2cpp_string *, il2cpp_string *, il2cpp_string *,
-                      il2cpp_string *))(il2cpp::il2cpp_base() + 0x4C82434))(
+                      il2cpp_string *))(il2cpp::il2cpp_base() + 0x5A76C9C))(
                 0, _title, _message, _ok, _cancel);
         }
 
         template <typename T = void>
         static T setobjectdirtyforeditorupdate(std::uintptr_t _obj) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C82560))(0, _obj);
+                                                   0x5A76DC8))(0, _obj);
         }
 
         template <typename T = void>
         static T setstatic(std::uintptr_t _go, bool _bstatic) {
             return ((T(*)(void *, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x4C82564))(0, _go, _bstatic);
+                il2cpp::il2cpp_base() + 0x5A76DCC))(0, _go, _bstatic);
         }
 
         template <typename T = il2cpp_array<std::uintptr_t> *>
         static T getselectedassetroots() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C82568))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A76DD0))(0);
         }
 
         template <typename T = il2cpp_array<std::uintptr_t> *>
         static T getallassetroots() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C82638))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A76EA0))(0);
         }
 
         template <typename T = void> static T cookselected() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C826F0))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A76F58))(0);
         }
 
         template <typename T = void> static T cookall() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C8284C))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A770B4))(0);
         }
 
         template <typename T = void>
         static T cookassets(il2cpp_array<std::uintptr_t> *_rootassets) {
             return ((T(*)(void *, il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C82708))(0, _rootassets);
+                il2cpp::il2cpp_base() + 0x5A76F70))(0, _rootassets);
         }
 
         template <typename T = void> static T rebuildselected() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C82864))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A770CC))(0);
         }
 
         template <typename T = void> static T rebuildall() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C829A4))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A7720C))(0);
         }
 
         template <typename T = void>
         static T rebuildassets(il2cpp_array<std::uintptr_t> *_rootassets) {
             return ((T(*)(void *, il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C8287C))(0, _rootassets);
+                il2cpp::il2cpp_base() + 0x5A770E4))(0, _rootassets);
         }
 
         template <typename T = void> static T bakeandreplaceselectedinscene() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C829BC))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A77224))(0);
         }
 
         template <typename T = void> static T bakeandreplaceallinscene() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C82AF8))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x5A77360))(0);
         }
 
         template <typename T = void>
         static T
         bakeandreplaceassets(il2cpp_array<std::uintptr_t> *_rootassets) {
             return ((T(*)(void *, il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C829D4))(0, _rootassets);
+                il2cpp::il2cpp_base() + 0x5A7723C))(0, _rootassets);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_generalutility.h

@@ -125,7 +125,7 @@ namespace houdiniengineunity {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
                           il2cpp_string *, std::uintptr_t,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C82B18))(
+                il2cpp::il2cpp_base() + 0x5A77380))(
                 0, _session, _geoid, _partid, _name, _info, _data);
         }
 
@@ -160,7 +160,7 @@ namespace houdiniengineunity {
                                       std::uintptr_t _attribowner) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
                           il2cpp_string *,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C82DBC))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A77658))(
                 0, _session, _geoid, _partid, _attribname, _attribowner);
         }
 
@@ -171,7 +171,7 @@ namespace houdiniengineunity {
                                   std::uintptr_t _attribinfo) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
                           il2cpp_string *,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C82EE4))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A7779C))(
                 0, _session, _geoid, _partid, _attribname, _attribinfo);
         }
 
@@ -179,20 +179,20 @@ namespace houdiniengineunity {
         static T copyworldtransformvalues(std::uintptr_t _src,
                                           std::uintptr_t _dest) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C82F84))(0, _src, _dest);
+                il2cpp::il2cpp_base() + 0x5A7784C))(0, _src, _dest);
         }
 
         template <typename T = void>
         static T copylocaltransformvalues(std::uintptr_t _src,
                                           std::uintptr_t _dest) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C83030))(0, _src, _dest);
+                il2cpp::il2cpp_base() + 0x5A778F8))(0, _src, _dest);
         }
 
         template <typename T = il2cpp_list<std::uintptr_t> *>
         static T getchildgameobjects(std::uintptr_t _parentgo) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C830DC))(0, _parentgo);
+                                                   0x5A779A4))(0, _parentgo);
         }
 
         template <typename T = il2cpp_list<std::uintptr_t> *>
@@ -200,20 +200,20 @@ namespace houdiniengineunity {
                                                     il2cpp_string *_pattern,
                                                     bool _bexclude) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *, bool))(
-                il2cpp::il2cpp_base() + 0x4C83438))(0, _parentgo, _pattern,
+                il2cpp::il2cpp_base() + 0x5A77D48))(0, _parentgo, _pattern,
                                                     _bexclude);
         }
 
         template <typename T = il2cpp_list<std::uintptr_t> *>
         static T getinstancechildobjects(std::uintptr_t _parentgo) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C83818))(0, _parentgo);
+                                                   0x5A78178))(0, _parentgo);
         }
 
         template <typename T = il2cpp_list<std::uintptr_t> *>
         static T getnoninstancechildobjects(std::uintptr_t _parentgo) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C838A8))(0, _parentgo);
+                                                   0x5A78208))(0, _parentgo);
         }
 
         template <typename T = std::uintptr_t>
@@ -221,7 +221,7 @@ namespace houdiniengineunity {
                                      il2cpp_string *_name) {
             return (
                 (T(*)(void *, il2cpp_list<std::uintptr_t> *, il2cpp_string *))(
-                    il2cpp::il2cpp_base() + 0x4C83938))(0, _golist, _name);
+                    il2cpp::il2cpp_base() + 0x5A78298))(0, _golist, _name);
         }
 
         template <typename T = std::uintptr_t>
@@ -233,7 +233,7 @@ namespace houdiniengineunity {
         template <typename T = void>
         static T destroygeneratedcomponents(std::uintptr_t _gameobject) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C83B34))(0, _gameobject);
+                                                   0x5A78494))(0, _gameobject);
         }
 
         template <typename T = void>
@@ -247,7 +247,7 @@ namespace houdiniengineunity {
                                   bool _ballowdestroyingassets,
                                   bool _bregisterundo) {
             return ((T(*)(void *, std::uintptr_t, bool, bool))(
-                il2cpp::il2cpp_base() + 0x4C83C48))(
+                il2cpp::il2cpp_base() + 0x5A785A8))(
                 0, _obj, _ballowdestroyingassets, _bregisterundo);
         }
 
@@ -255,7 +255,7 @@ namespace houdiniengineunity {
         static T destroybakedgameobjects(
             il2cpp_list<std::uintptr_t> *_gameobjectstodestroy) {
             return ((T(*)(void *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C83D04))(0, _gameobjectstodestroy);
+                il2cpp::il2cpp_base() + 0x5A78664))(0, _gameobjectstodestroy);
         }
 
         template <typename T = void>
@@ -263,7 +263,7 @@ namespace houdiniengineunity {
             il2cpp_list<std::uintptr_t> *_gameobjectstodestroy,
             il2cpp_string *_endname) {
             return ((T(*)(void *, il2cpp_list<std::uintptr_t> *,
-                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x4C83D0C))(
+                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x5A7866C))(
                 0, _gameobjectstodestroy, _endname);
         }
 
@@ -271,7 +271,7 @@ namespace houdiniengineunity {
         static T destroylodgroup(std::uintptr_t _targetgo,
                                  bool _bdontdeletepersistantresources) {
             return ((T(*)(void *, std::uintptr_t, bool))(il2cpp::il2cpp_base() +
-                                                         0x4C84194))(
+                                                         0x5A78AF4))(
                 0, _targetgo, _bdontdeletepersistantresources);
         }
 
@@ -279,21 +279,21 @@ namespace houdiniengineunity {
         static T destroygeneratedmeshmaterialslodgroups(
             std::uintptr_t _targetgo, bool _bdontdeletepersistantresources) {
             return ((T(*)(void *, std::uintptr_t, bool))(il2cpp::il2cpp_base() +
-                                                         0x4C83EB8))(
+                                                         0x5A78818))(
                 0, _targetgo, _bdontdeletepersistantresources);
         }
 
         template <typename T = void>
         static T destroygeneratedmaterial(std::uintptr_t _material) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C8458C))(0, _material);
+                                                   0x5A78EEC))(0, _material);
         }
 
         template <typename T = void>
         static T destroymeshcollider(std::uintptr_t _gameobject,
                                      bool _bdontdeletepersistantresources) {
             return ((T(*)(void *, std::uintptr_t, bool))(il2cpp::il2cpp_base() +
-                                                         0x4C843B4))(
+                                                         0x5A78D14))(
                 0, _gameobject, _bdontdeletepersistantresources);
         }
 
@@ -301,39 +301,39 @@ namespace houdiniengineunity {
         static T setgameobjectrendervisiblity(std::uintptr_t _gameobject,
                                               bool _bvisible) {
             return ((T(*)(void *, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x4C84730))(0, _gameobject, _bvisible);
+                il2cpp::il2cpp_base() + 0x5A79090))(0, _gameobject, _bvisible);
         }
 
         template <typename T = void>
         static T setgameobjectcolliderstate(std::uintptr_t _gameobject,
                                             bool _benabled) {
             return ((T(*)(void *, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x4C84830))(0, _gameobject, _benabled);
+                il2cpp::il2cpp_base() + 0x5A79190))(0, _gameobject, _benabled);
         }
 
         template <typename T = il2cpp_string *>
         static T colortostring(std::uintptr_t _c) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C84930))(0, _c);
+                                                   0x5A79290))(0, _c);
         }
 
         template <typename T = std::uintptr_t>
         static T stringtocolor(il2cpp_string *_colorstring) {
             return ((T(*)(void *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x4C84C1C))(0, _colorstring);
+                il2cpp::il2cpp_base() + 0x5A7957C))(0, _colorstring);
         }
 
         template <typename T = bool>
         static T doesunitytagexist(il2cpp_string *_tagname) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C84DE4))(0, _tagname);
+                                                    0x5A79744))(0, _tagname);
         }
 
         template <typename T = void>
         static T setlayer(std::uintptr_t _rootgo, std::int32_t _layer,
                           bool _bincludechildren) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, bool))(
-                il2cpp::il2cpp_base() + 0x4C84DEC))(0, _rootgo, _layer,
+                il2cpp::il2cpp_base() + 0x5A7974C))(0, _rootgo, _layer,
                                                     _bincludechildren);
         }
 
@@ -341,7 +341,7 @@ namespace houdiniengineunity {
         static T ismousewithinsceneview(std::uintptr_t _camera,
                                         il2cpp_vec2 _mouseposition) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_vec2))(
-                il2cpp::il2cpp_base() + 0x4C84F18))(0, _camera, _mouseposition);
+                il2cpp::il2cpp_base() + 0x5A79878))(0, _camera, _mouseposition);
         }
 
         template <typename T = bool>
@@ -349,14 +349,14 @@ namespace houdiniengineunity {
                                  il2cpp_vec2 _mouseposition,
                                  std::uintptr_t _rect) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_vec2, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C84FB8))(0, _camera, _mouseposition,
+                il2cpp::il2cpp_base() + 0x5A79918))(0, _camera, _mouseposition,
                                                     _rect);
         }
 
         template <typename T = std::uintptr_t>
         static T getsystemtypebyname(il2cpp_string *_typename) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x4C85014))(0, _typename);
+                                                    0x5A79974))(0, _typename);
         }
 
         template <typename T = void>
@@ -364,7 +364,7 @@ namespace houdiniengineunity {
                                 std::int32_t _partid,
                                 std::uintptr_t _gameobject) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C850D4))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A79A34))(
                 0, _session, _geoid, _partid, _gameobject);
         }
 
@@ -374,7 +374,7 @@ namespace houdiniengineunity {
                                           std::int32_t _partid,
                                           std::uintptr_t _gameobject) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C85504))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A79E84))(
                 0, _session, _geoid, _partid, _gameobject);
         }
 
@@ -383,7 +383,7 @@ namespace houdiniengineunity {
                                               std::int32_t _geoid,
                                               std::int32_t _partid) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C856D4))(0, _session, _geoid,
+                il2cpp::il2cpp_base() + 0x5A7A060))(0, _session, _geoid,
                                                     _partid);
         }
 
@@ -391,13 +391,13 @@ namespace houdiniengineunity {
         static T attachscriptwithinvokefunction(il2cpp_string *_scriptset,
                                                 std::uintptr_t _gameobject) {
             return ((T(*)(void *, il2cpp_string *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C85A18))(0, _scriptset, _gameobject);
+                il2cpp::il2cpp_base() + 0x5A7A3A8))(0, _scriptset, _gameobject);
         }
 
         template <typename T = bool>
         static T isincameraview(std::uintptr_t _camera, il2cpp_vec3 _point) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_vec3))(
-                il2cpp::il2cpp_base() + 0x4C85CDC))(0, _camera, _point);
+                il2cpp::il2cpp_base() + 0x5A7A66C))(0, _camera, _point);
         }
 
         template <typename T = il2cpp_list<std::uintptr_t> *>
@@ -410,7 +410,7 @@ namespace houdiniengineunity {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t, std::int32_t,
                           il2cpp_string *, std::uintptr_t,
                           il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C85D84))(
+                il2cpp::il2cpp_base() + 0x5A7A714))(
                 0, _session, _assetinfo, _assetid, _assetname, _parameters,
                 _currenthandles);
         }
@@ -418,14 +418,14 @@ namespace houdiniengineunity {
         template <typename T = void>
         static T copycomponents(std::uintptr_t _srcgo, std::uintptr_t _destgo) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C8631C))(0, _srcgo, _destgo);
+                il2cpp::il2cpp_base() + 0x5A7ACBC))(0, _srcgo, _destgo);
         }
 
         template <typename T = std::int32_t>
         static T getparentnodeid(std::uintptr_t _session,
                                  std::int32_t _nodeid) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C86320))(0, _session, _nodeid);
+                il2cpp::il2cpp_base() + 0x5A7ACC0))(0, _session, _nodeid);
         }
 
         template <typename T = std::int32_t>
@@ -435,7 +435,7 @@ namespace houdiniengineunity {
                                               std::uintptr_t _foundparminfo) {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, il2cpp_string *,
-                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x4C86448))(
+                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x5A7ADFC))(
                 0, _session, _nodeid, _parmname, _foundparminfo);
         }
 
@@ -444,7 +444,7 @@ namespace houdiniengineunity {
                                                 std::uintptr_t _nodeid,
                                                 il2cpp_string *_paramname) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t,
-                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x4C86600))(
+                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x5A7AFE0))(
                 0, _session, _nodeid, _paramname);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_generatedoutput.h

@@ -15,13 +15,13 @@ namespace houdiniengineunity {
         template <typename T = void>
         static T resetmaterialoverrides(std::uintptr_t _output) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C8678C))(0, _output);
+                                                   0x5A7B198))(0, _output);
         }
 
         template <typename T = void>
         static T resetmaterialoverrides_1(std::uintptr_t _outputdata) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C869D4))(0, _outputdata);
+                                                   0x5A7B3E0))(0, _outputdata);
         }
 
         template <typename T = il2cpp_array<std::uintptr_t> *>
@@ -29,27 +29,27 @@ namespace houdiniengineunity {
         getgeneratedmaterialsforgameobject(std::uintptr_t _output,
                                            std::uintptr_t _ingameobject) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C86AE0))(0, _output, _ingameobject);
+                il2cpp::il2cpp_base() + 0x5A7B4EC))(0, _output, _ingameobject);
         }
 
         template <typename T = bool>
         static T haslodgroup(std::uintptr_t _output) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x4C86928))(0, _output);
+                                                   0x5A7B334))(0, _output);
         }
 
         template <typename T = bool>
         static T isoutputusingmaterial(std::uintptr_t _checkmaterial,
                                        std::uintptr_t _output) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C86D78))(0, _checkmaterial, _output);
+                il2cpp::il2cpp_base() + 0x5A7B784))(0, _checkmaterial, _output);
         }
 
         template <typename T = bool>
         static T isoutputdatausingmaterial(std::uintptr_t _checkmaterial,
                                            std::uintptr_t _outputdata) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C86F30))(0, _checkmaterial,
+                il2cpp::il2cpp_base() + 0x5A7B93C))(0, _checkmaterial,
                                                     _outputdata);
         }
 
@@ -57,20 +57,20 @@ namespace houdiniengineunity {
         static T
         cleargeneratedmaterialreferences(std::uintptr_t _generatedoutputdata) {
             return ((T(*)(void *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C871BC))(0, _generatedoutputdata);
+                il2cpp::il2cpp_base() + 0x5A7BBC8))(0, _generatedoutputdata);
         }
 
         template <typename T = void>
         static T destroygeneratedoutput(std::uintptr_t _generatedoutput) {
             return ((T(*)(void *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C871E0))(0, _generatedoutput);
+                il2cpp::il2cpp_base() + 0x5A7BBEC))(0, _generatedoutput);
         }
 
         template <typename T = void>
         static T
         destroygeneratedoutputchildren(std::uintptr_t _generatedoutput) {
             return ((T(*)(void *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C87430))(0, _generatedoutput);
+                il2cpp::il2cpp_base() + 0x5A7BE3C))(0, _generatedoutput);
         }
 
         template <typename T = void>
@@ -78,7 +78,7 @@ namespace houdiniengineunity {
         destroygeneratedoutputdata(std::uintptr_t _generatedoutputdata,
                                    bool _bdontdeletepersistantresources) {
             return ((T(*)(void *, std::uintptr_t, bool))(il2cpp::il2cpp_base() +
-                                                         0x4C8766C))(
+                                                         0x5A7C078))(
                 0, _generatedoutputdata, _bdontdeletepersistantresources);
         }
 
@@ -88,7 +88,7 @@ namespace houdiniengineunity {
             il2cpp_array<std::uintptr_t> *_materialsinuse) {
             return ((T(*)(void *, il2cpp_array<std::uintptr_t> *,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C876B0))(0, _materialstocheck,
+                il2cpp::il2cpp_base() + 0x5A7C0BC))(0, _materialstocheck,
                                                     _materialsinuse);
         }
 
@@ -96,7 +96,7 @@ namespace houdiniengineunity {
         static T copymaterialoverrides(std::uintptr_t _sourceoutputdata,
                                        std::uintptr_t _destoutputdata) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C87834))(0, _sourceoutputdata,
+                il2cpp::il2cpp_base() + 0x5A7C240))(0, _sourceoutputdata,
                                                     _destoutputdata);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_generategeocache.h

@@ -161,12 +161,12 @@ namespace houdiniengineunity {
 
         template <typename T = std::int32_t> T get_geoid() {
             return ((T(*)(heugenerategeocache *))(il2cpp::il2cpp_base() +
-                                                  0x4C87CD8))(this);
+                                                  0x2EF57D4))(this);
         }
 
         template <typename T = std::int32_t> T get_partid() {
             return ((T(*)(heugenerategeocache *))(il2cpp::il2cpp_base() +
-                                                  0x4C87CE0))(this);
+                                                  0x2EF57DC))(this);
         }
 
         template <typename T = std::uintptr_t>
@@ -174,14 +174,14 @@ namespace houdiniengineunity {
                                       std::int32_t _geoid, std::int32_t _partid,
                                       bool _buselodgroups) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
-                          bool))(il2cpp::il2cpp_base() + 0x4C87CE8))(
+                          bool))(il2cpp::il2cpp_base() + 0x2EF57E4))(
                 0, _session, _geoid, _partid, _buselodgroups);
         }
 
         template <typename T = void>
         T populateunitymaterialdata(std::uintptr_t _session) {
             return ((T(*)(heugenerategeocache *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C882B0))(this, _session);
+                il2cpp::il2cpp_base() + 0x2EF6080))(this, _session);
         }
 
         template <typename T = std::int32_t>
@@ -192,7 +192,7 @@ namespace houdiniengineunity {
             return (
                 (T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t *,
                       std::uintptr_t *,
-                      std::uintptr_t *))(il2cpp::il2cpp_base() + 0x4C8A7E4))(
+                      std::uintptr_t *))(il2cpp::il2cpp_base() + 0x2EF8904))(
                 0, _geocache, _attributeindex, _unitymaterialname,
                 _substancename, _substanceindex);
         }
@@ -201,14 +201,14 @@ namespace houdiniengineunity {
         static T creatematerialinfoentryfromattributeindex(
             std::uintptr_t _geocache, std::int32_t _materialattributeindex) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x4C8A674))(0, _geocache,
+                il2cpp::il2cpp_base() + 0x2EF879C))(0, _geocache,
                                                     _materialattributeindex);
         }
 
         template <typename T = bool>
         T populategeometrydata(std::uintptr_t _session, bool _buselodgroups) {
             return ((T(*)(heugenerategeocache *, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x4C88DB4))(this, _session,
+                il2cpp::il2cpp_base() + 0x2EF6BAC))(this, _session,
                                                     _buselodgroups);
         }
 
@@ -218,7 +218,7 @@ namespace houdiniengineunity {
             il2cpp_array<std::uintptr_t> **_lodtransitionvalues) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
                           il2cpp_array<std::uintptr_t> **))(
-                il2cpp::il2cpp_base() + 0x4C8AA44))(
+                il2cpp::il2cpp_base() + 0x2EF948C))(
                 0, _session, _geoid, _partid, _lodtransitionvalues);
         }
 
@@ -226,7 +226,7 @@ namespace houdiniengineunity {
         static T updatecollider(std::uintptr_t _geocache,
                                 std::uintptr_t _outputgameobject) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x4C8AD30))(0, _geocache,
+                il2cpp::il2cpp_base() + 0x2EF978C))(0, _geocache,
                                                     _outputgameobject);
         }
 
@@ -240,7 +240,7 @@ namespace houdiniengineunity {
                 (T(*)(void *, std::uintptr_t, il2cpp_array<std::uintptr_t> *,
                       il2cpp_array<std::uintptr_t> *,
                       il2cpp_array<std::uintptr_t> *))(il2cpp::il2cpp_base() +
-                                                       0x4C8AEF8))(
+                                                       0x2EF995C))(
                 0, _gameobject, _previousmaterials, _newmaterials,
                 _finalmaterials);
         }
@@ -255,7 +255,7 @@ namespace houdiniengineunity {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, std::uintptr_t,
                       std::uintptr_t, std::uintptr_t, std::int32_t, bool, bool,
-                      bool, bool))(il2cpp::il2cpp_base() + 0x4C8B23C))(
+                      bool, bool))(il2cpp::il2cpp_base() + 0x2EF9CA0))(
                 0, _session, _geogroup, _asset, _geocache, _generatedoutput,
                 _defaultmaterialkey, _bgenerateuvs, _bgeneratetangents,
                 _bgeneratenormals, _bpartinstanced);
@@ -272,7 +272,7 @@ namespace houdiniengineunity {
             return ((T(*)(void *, std::uintptr_t, il2cpp_list<std::uintptr_t> *,
                           std::uintptr_t, std::uintptr_t, std::uintptr_t,
                           std::int32_t, bool, bool, bool,
-                          bool))(il2cpp::il2cpp_base() + 0x4C8C7D0))(
+                          bool))(il2cpp::il2cpp_base() + 0x2EFB1A8))(
                 0, _session, _geogroupmeshes, _asset, _geocache,
                 _generatedoutput, _defaultmaterialkey, _bgenerateuvs,
                 _bgeneratetangents, _bgeneratenormals, _bpartinstanced);
@@ -290,7 +290,7 @@ namespace houdiniengineunity {
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, std::uintptr_t,
                       std::uintptr_t, std::int32_t, bool, bool, bool, bool,
                       std::uintptr_t *, il2cpp_array<std::uintptr_t> **))(
-                    il2cpp::il2cpp_base() + 0x4C8B460))(
+                    il2cpp::il2cpp_base() + 0x2EF9ED4))(
                 0, _session, _geogroup, _asset, _geocache, _defaultmaterialkey,
                 _bgenerateuvs, _bgeneratetangents, _bgeneratenormals,
                 _bpartinstanced, _newmesh, _newmaterials);
@@ -304,7 +304,7 @@ namespace houdiniengineunity {
             return ((T(*)(void *, il2cpp_array<std::uintptr_t> *,
                           std::uintptr_t, il2cpp_array<std::uintptr_t> *,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x4C8D5C0))(0, _vertexlist, _attribinfo,
+                il2cpp::il2cpp_base() + 0x2EFD4AC))(0, _vertexlist, _attribinfo,
                                                     _indata, _outdata);
         }
 
@@ -319,7 +319,7 @@ namespace houdiniengineunity {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, std::uintptr_t,
                       bool, bool, bool, bool, bool, std::uintptr_t *,
-                      std::uintptr_t *))(il2cpp::il2cpp_base() + 0x4C8D834))(
+                      std::uintptr_t *))(il2cpp::il2cpp_base() + 0x2EFD720))(
                 0, _session, _asset, _geocache, _bgenerateuvs,
                 _bgeneratetangents, _bgeneratenormals, _buselodgroups,
                 _bpartinstanced, _lodgroupmeshes, _defaultmaterialkey);
@@ -336,7 +336,7 @@ namespace houdiniengineunity {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, std::uintptr_t,
                       bool, bool, bool, bool, bool, std::uintptr_t *,
-                      std::uintptr_t *))(il2cpp::il2cpp_base() + 0x4C902FC))(
+                      std::uintptr_t *))(il2cpp::il2cpp_base() + 0x2F007D0))(
                 0, _session, _asset, _geocache, _bgenerateuvs,
                 _bgeneratetangents, _bgeneratenormals, _buselodgroups,
                 _bpartinstanced, _lodgroupmeshes, _defaultmaterialkey);
@@ -345,7 +345,7 @@ namespace houdiniengineunity {
         template <typename T = std::int32_t>
         static T generatelodmeshesfromgeogroupsm__0(float _a, float _b) {
             return ((T(*)(void *, float, float))(il2cpp::il2cpp_base() +
-                                                 0x4C926C4))(0, _a, _b);
+                                                 0x2F02B94))(0, _a, _b);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_geogroup.h

@@ -19,13 +19,13 @@ namespace houdiniengineunity {
         template <typename T = std::int32_t>
         T compareto(std::uintptr_t _other) {
             return ((T(*)(heugeogroup *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C2E14C))(this, _other);
+                il2cpp::il2cpp_base() + 0x2F02BB8))(this, _other);
         }
 
         template <typename T = void>
         T setupnormalindices(std::int32_t _indicescount) {
             return ((T(*)(heugeogroup *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C2E188))(this, _indicescount);
+                il2cpp::il2cpp_base() + 0x2F00434))(this, _indicescount);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_geometryutility.h

@@ -7,19 +7,19 @@ namespace houdiniengineunity {
         template <typename T = il2cpp_array<std::uintptr_t> *>
         static T generatepertriangle(std::uintptr_t _meshsrc) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C2E2DC))(0, _meshsrc);
+                                                   0x2EFD3EC))(0, _meshsrc);
         }
 
         template <typename T = void>
         static T generatesecondaryuvset(std::uintptr_t _meshsrc) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C2E39C))(0, _meshsrc);
+                                                   0x2F02BF4))(0, _meshsrc);
         }
 
         template <typename T = void>
         static T calculatemeshtangents(std::uintptr_t _mesh) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C2E458))(0, _mesh);
+                                                   0x2EFBFB0))(0, _mesh);
         }
 
         template <typename T = bool>
@@ -32,7 +32,7 @@ namespace houdiniengineunity {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t, std::int32_t,
                           std::int32_t, std::uintptr_t, std::uintptr_t,
                           std::uintptr_t *, std::uintptr_t *))(
-                il2cpp::il2cpp_base() + 0x2C2ED6C))(
+                il2cpp::il2cpp_base() + 0x2F02CB0))(
                 0, _session, _volumeinfo, _geoid, _partid, _houdiniasset,
                 _gameobject, _terraindata, _volumepositionoffset);
         }
@@ -44,7 +44,7 @@ namespace houdiniengineunity {
                                    float _size) {
             return ((T(*)(void *, il2cpp_array<std::uintptr_t> *,
                           il2cpp_array<std::uintptr_t> *, float))(
-                il2cpp::il2cpp_base() + 0x2C3032C))(0, _points, _pointscolor,
+                il2cpp::il2cpp_base() + 0x2F042B8))(0, _points, _pointscolor,
                                                     _size);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_geonode.h

@@ -24,68 +24,68 @@ namespace houdiniengineunity {
         }
 
         template <typename T = std::int32_t> T get_geoid() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C3167C))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F05608))(
                 this);
         }
 
         template <typename T = il2cpp_string *> T get_geoname() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C31684))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F05610))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_geotype() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C3168C))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F05618))(
                 this);
         }
 
         template <typename T = bool> T get_editable() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C31694))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F05620))(
                 this);
         }
 
         template <typename T = bool> T get_displayable() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C3169C))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F05628))(
                 this);
         }
 
         template <typename T = bool> T isvisible() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C316A4))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F05630))(
                 this);
         }
 
         template <typename T = bool> T isintermediateoreditable() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C316D0))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F0565C))(
                 this);
         }
 
         template <typename T = bool> T isgeoinputtype() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C31700))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F0568C))(
                 this);
         }
 
         template <typename T = bool> T isgeocurvetype() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C31728))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F056B4))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_parentasset() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C3173C))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F056C8))(
                 this);
         }
 
         template <typename T = void> T destroyalldata() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C31820))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F057AC))(
                 this);
         }
 
         template <typename T = void>
         T removeanddestroypart(std::uintptr_t _part) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C31EB0))(this, _part);
+                il2cpp::il2cpp_base() + 0x2F05E78))(this, _part);
         }
 
         template <typename T = void> T reset() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C314E8))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F05474))(
                 this);
         }
 
@@ -93,24 +93,24 @@ namespace houdiniengineunity {
         T initialize(std::uintptr_t _session, std::uintptr_t _geoinfo,
                      std::uintptr_t _containerobjectnode) {
             return ((T(*)(heugeonode *, std::uintptr_t, std::uintptr_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C31FA8))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F05F70))(
                 this, _session, _geoinfo, _containerobjectnode);
         }
 
         template <typename T = bool> T doesthisrequirepotentialcook() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C322F0))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F0606C))(
                 this);
         }
 
         template <typename T = void> T updategeo(std::uintptr_t _session) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C32410))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F0618C))(this, _session);
         }
 
         template <typename T = void>
         T processunityscriptattribute(std::uintptr_t _session) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C33C28))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F079C4))(this, _session);
         }
 
         template <typename T = void>
@@ -118,7 +118,7 @@ namespace houdiniengineunity {
                       std::uintptr_t _partinfo, std::uintptr_t _partdata) {
             return ((T(*)(heugeonode *, std::uintptr_t, std::int32_t,
                           std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C32FB0))(this, _session, _partid,
+                il2cpp::il2cpp_base() + 0x2F06D3C))(this, _session, _partid,
                                                     _partinfo, _partdata);
         }
 
@@ -126,7 +126,7 @@ namespace houdiniengineunity {
         T setupgameobjectandtransform(std::uintptr_t _partdata,
                                       std::uintptr_t _parentasset) {
             return ((T(*)(heugeonode *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C3422C))(this, _partdata,
+                il2cpp::il2cpp_base() + 0x2F07FC8))(this, _partdata,
                                                     _parentasset);
         }
 
@@ -135,137 +135,137 @@ namespace houdiniengineunity {
                                il2cpp_list<std::uintptr_t> *_volumeparts) {
             return ((T(*)(heugeonode *, il2cpp_list<std::uintptr_t> *,
                           il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C34EEC))(this, _meshparts,
+                il2cpp::il2cpp_base() + 0x2F08C88))(this, _meshparts,
                                                     _volumeparts);
         }
 
         template <typename T = void>
         T generatepartinstances(std::uintptr_t _session) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C35084))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F08E20))(this, _session);
         }
 
         template <typename T = void>
         T processgeocurve(std::uintptr_t _session) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C32C94))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F06A20))(this, _session);
         }
 
         template <typename T = void>
         T setupgeocurvegameobjectandtransform(std::uintptr_t _curve) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C3678C))(this, _curve);
+                il2cpp::il2cpp_base() + 0x2F0A644))(this, _curve);
         }
 
         template <typename T = void> T clearobjectinstances() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C36A60))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F0A918))(
                 this);
         }
 
         template <typename T = void> T setgeoinfo(std::uintptr_t _geoinfo) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C36B5C))(this, _geoinfo);
+                il2cpp::il2cpp_base() + 0x2F0AA14))(this, _geoinfo);
         }
 
         template <typename T = il2cpp_string *>
         T generatepartfullname(il2cpp_string *_partname) {
             return ((T(*)(heugeonode *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C34774))(this, _partname);
+                il2cpp::il2cpp_base() + 0x2F08510))(this, _partname);
         }
 
         template <typename T = il2cpp_string *> T generategeocurvename() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C36714))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F0A5CC))(
                 this);
         }
 
         template <typename T = bool>
         T hasgeonodechanged(std::uintptr_t _session) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C36B9C))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F0AA54))(this, _session);
         }
 
         template <typename T = void>
         T applyhapitransform(std::uintptr_t _hapitransform) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C36CF4))(this, _hapitransform);
+                il2cpp::il2cpp_base() + 0x2F0ABC4))(this, _hapitransform);
         }
 
         template <typename T = void> T getdebuginfo(std::uintptr_t _sb) {
             return ((T(*)(heugeonode *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                         0x2C36FE8))(this, _sb);
+                                                         0x2F0AEB8))(this, _sb);
         }
 
         template <typename T = bool>
         T isusingmaterial(std::uintptr_t _materialdata) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C377DC))(this, _materialdata);
+                il2cpp::il2cpp_base() + 0x2F0B6AC))(this, _materialdata);
         }
 
         template <typename T = void>
         T getclonableparts(il2cpp_list<std::uintptr_t> *_clonableparts) {
             return ((T(*)(heugeonode *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C379E8))(this, _clonableparts);
+                il2cpp::il2cpp_base() + 0x2F0B8B8))(this, _clonableparts);
         }
 
         template <typename T = void>
         T getoutputgameobjects(il2cpp_list<std::uintptr_t> *_outputobjects) {
             return ((T(*)(heugeonode *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C37C8C))(this, _outputobjects);
+                il2cpp::il2cpp_base() + 0x2F0BB5C))(this, _outputobjects);
         }
 
         template <typename T = void>
         T getoutput(il2cpp_list<std::uintptr_t> *_outputs) {
             return ((T(*)(heugeonode *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C37F38))(this, _outputs);
+                il2cpp::il2cpp_base() + 0x2F0BE08))(this, _outputs);
         }
 
         template <typename T = std::uintptr_t>
         T gethdapartwithgameobject(std::uintptr_t _outputgameobject) {
             return ((T(*)(heugeonode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C38184))(this, _outputgameobject);
+                il2cpp::il2cpp_base() + 0x2F0C054))(this, _outputgameobject);
         }
 
         template <typename T = std::uintptr_t>
         T getpartfrompartid(std::int32_t _partid) {
             return ((T(*)(heugeonode *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C3846C))(this, _partid);
+                il2cpp::il2cpp_base() + 0x2F0C33C))(this, _partid);
         }
 
         template <typename T = void>
         T getcurves(il2cpp_list<std::uintptr_t> *_curves, bool _beditableonly) {
             return ((T(*)(heugeonode *, il2cpp_list<std::uintptr_t> *, bool))(
-                il2cpp::il2cpp_base() + 0x2C385A8))(this, _curves,
+                il2cpp::il2cpp_base() + 0x2F0C478))(this, _curves,
                                                     _beditableonly);
         }
 
         template <typename T = il2cpp_list<std::uintptr_t> *> T getparts() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C38978))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F0C848))(
                 this);
         }
 
         template <typename T = void>
         T calculatevisiblity(bool _bparentvisibility) {
             return ((T(*)(heugeonode *, bool))(
-                il2cpp::il2cpp_base() + 0x2C38980))(this, _bparentvisibility);
+                il2cpp::il2cpp_base() + 0x2F0C850))(this, _bparentvisibility);
         }
 
         template <typename T = void> T hideallgeometry() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C38B64))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F0CA34))(
                 this);
         }
 
         template <typename T = void> T calculatecolliderstate() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C38E9C))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F0CD6C))(
                 this);
         }
 
         template <typename T = void> T disableallcolliders() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C392BC))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F0D18C))(
                 this);
         }
 
         template <typename T = il2cpp_string *> T tostring() {
-            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2C393E8))(
+            return ((T(*)(heugeonode *))(il2cpp::il2cpp_base() + 0x2F0D2B8))(
                 this);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_handle.h

@@ -43,87 +43,87 @@ namespace houdiniengineunity {
         }
 
         template <typename T = il2cpp_string *> T get_handlename() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C39594))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D464))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_handletype() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C3959C))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D46C))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_rstorder() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C395A4))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D474))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_xyzorder() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C395AC))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D47C))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_convertedtransformeuler() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C395B4))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D484))(
                 this);
         }
 
         template <typename T = bool> T hastranslatehandle() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C395CC))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D49C))(
                 this);
         }
 
         template <typename T = bool> T hasrotatehandle() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C395DC))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D4AC))(
                 this);
         }
 
         template <typename T = bool> T hasscalehandle() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C395EC))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D4BC))(
                 this);
         }
 
         template <typename T = bool> T istranslatehandledisabled() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C395FC))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D4CC))(
                 this);
         }
 
         template <typename T = bool> T isrotatehandledisabled() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C3961C))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D4EC))(
                 this);
         }
 
         template <typename T = bool> T isscalehandledisabled() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C3963C))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D50C))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T gettranslatebinding() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C3965C))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D52C))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T getrotatebinding() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C39664))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D534))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T getscalebinding() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C3966C))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D53C))(
                 this);
         }
 
         template <typename T = il2cpp_vec3> T get_handleposition() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C39674))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D544))(
                 this);
         }
 
         template <typename T = il2cpp_quaternion> T get_handlerotation() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C39688))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D558))(
                 this);
         }
 
         template <typename T = il2cpp_vec3> T get_handlescale() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C39698))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0D568))(
                 this);
         }
 
@@ -135,13 +135,13 @@ namespace houdiniengineunity {
             return (
                 (T(*)(heuhandle *, std::uintptr_t, std::int32_t, std::int32_t,
                       il2cpp_string *, std::uintptr_t, std::uintptr_t,
-                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C396AC))(
+                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F0D57C))(
                 this, _session, _assetid, _handleindex, _handlename,
                 _handletype, _handleinfo, _parameters);
         }
 
         template <typename T = void> T cleanup() {
-            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2C3AF68))(
+            return ((T(*)(heuhandle *))(il2cpp::il2cpp_base() + 0x2F0EE24))(
                 this);
         }
 
@@ -149,7 +149,7 @@ namespace houdiniengineunity {
         T generatetransform(std::uintptr_t _session,
                             std::uintptr_t _parameters) {
             return ((T(*)(heuhandle *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C3A5F4))(this, _session,
+                il2cpp::il2cpp_base() + 0x2F0E49C))(this, _session,
                                                     _parameters);
         }
 
@@ -157,20 +157,20 @@ namespace houdiniengineunity {
         T getupdatedposition(std::uintptr_t _asset,
                              std::uintptr_t _inposition) {
             return ((T(*)(heuhandle *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C3AFA0))(this, _asset, _inposition);
+                il2cpp::il2cpp_base() + 0x2F0EE5C))(this, _asset, _inposition);
         }
 
         template <typename T = bool>
         T getupdatedrotation(std::uintptr_t _asset,
                              std::uintptr_t _inrotation) {
             return ((T(*)(heuhandle *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C3B20C))(this, _asset, _inrotation);
+                il2cpp::il2cpp_base() + 0x2F0F0E4))(this, _asset, _inrotation);
         }
 
         template <typename T = bool>
         static T isspecialrstorder(std::uintptr_t _rstorder) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C3AF7C))(0, _rstorder);
+                                                   0x2F0EE38))(0, _rstorder);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_hapiutility.h

@@ -6,47 +6,47 @@ namespace houdiniengineunity {
       public:
         template <typename T = il2cpp_string *>
         static T gethoudiniengineinstallationinfo() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2C3B564))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2F0F458))(0);
         }
 
         template <typename T = il2cpp_string *> static T getenvironmentpath() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2C3B614))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2F0F508))(0);
         }
 
         template <typename T = bool>
         static T ishoudiniassetfile(il2cpp_string *_filepath) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C3B69C))(0, _filepath);
+                                                    0x2F0F590))(0, _filepath);
         }
 
         template <typename T = void> static T log(il2cpp_string *_message) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C3B84C))(0, _message);
+                                                    0x2F0F740))(0, _message);
         }
 
         template <typename T = void>
         static T logwarning(il2cpp_string *_message) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C3B8F4))(0, _message);
+                                                    0x2F0F7E8))(0, _message);
         }
 
         template <typename T = void>
         static T logerror(il2cpp_string *_message) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C3B99C))(0, _message);
+                                                    0x2F0F890))(0, _message);
         }
 
         template <typename T = il2cpp_string *>
         static T locatevalidfilepath(std::uintptr_t _inobject) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C3BA44))(0, _inobject);
+                                                   0x2F0F938))(0, _inobject);
         }
 
         template <typename T = il2cpp_string *>
         static T locatevalidfilepath_1(il2cpp_string *_assetname,
                                        il2cpp_string *_infilepath) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C3BB10))(0, _assetname, _infilepath);
+                il2cpp::il2cpp_base() + 0x2F0FA04))(0, _assetname, _infilepath);
         }
 
         template <typename T = std::uintptr_t>
@@ -54,7 +54,7 @@ namespace houdiniengineunity {
                                 il2cpp_vec3 _initialposition,
                                 std::uintptr_t _session, bool _bbuildasync) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_vec3, std::uintptr_t,
-                          bool))(il2cpp::il2cpp_base() + 0x2C3BB18))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F0FA0C))(
                 0, _filepath, _initialposition, _session, _bbuildasync);
         }
 
@@ -64,7 +64,7 @@ namespace houdiniengineunity {
                              il2cpp_array<std::uintptr_t> **_assetnames) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           std::uintptr_t *, il2cpp_array<std::uintptr_t> **))(
-                il2cpp::il2cpp_base() + 0x2C3C30C))(
+                il2cpp::il2cpp_base() + 0x2F10200))(
                 0, _session, _assetpath, _assetlibraryid, _assetnames);
         }
 
@@ -75,7 +75,7 @@ namespace houdiniengineunity {
                                         std::uintptr_t *_newassetid) {
             return (
                 (T(*)(void *, std::uintptr_t, il2cpp_string *, bool,
-                      std::uintptr_t *))(il2cpp::il2cpp_base() + 0x2C3C5FC))(
+                      std::uintptr_t *))(il2cpp::il2cpp_base() + 0x2F1053C))(
                 0, _session, _assetname, _bcooktemplatedgeos, _newassetid);
         }
 
@@ -84,7 +84,7 @@ namespace houdiniengineunity {
         cooknodeinhoudini(std::uintptr_t _session, std::int32_t _nodeid,
                           bool _bcooktemplatedgeos, il2cpp_string *_assetname) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, bool,
-                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2C3CC2C))(
+                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2F10C54))(
                 0, _session, _nodeid, _bcooktemplatedgeos, _assetname);
         }
 
@@ -92,7 +92,7 @@ namespace houdiniengineunity {
         static T processhoudinicookstatus(std::uintptr_t _session,
                                           il2cpp_string *_assetname) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C3C8C0))(0, _session, _assetname);
+                il2cpp::il2cpp_base() + 0x2F10864))(0, _session, _assetname);
         }
 
         template <typename T = std::uintptr_t>
@@ -102,7 +102,7 @@ namespace houdiniengineunity {
                                 std::uintptr_t _session, bool _bbuildasync) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           std::uintptr_t, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x2C3CC8C))(0, _assettype, _rootname,
+                il2cpp::il2cpp_base() + 0x2F10CCC))(0, _assettype, _rootname,
                                                     _parenttransform, _session,
                                                     _bbuildasync);
         }
@@ -112,7 +112,7 @@ namespace houdiniengineunity {
                                      std::uintptr_t _session,
                                      bool _bbuildasync) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x2C3D528))(0, _parenttransform,
+                il2cpp::il2cpp_base() + 0x2F11590))(0, _parenttransform,
                                                     _session, _bbuildasync);
         }
 
@@ -121,21 +121,21 @@ namespace houdiniengineunity {
                                      std::uintptr_t _session,
                                      bool _bbuildasync) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x2C3D5C8))(0, _parenttransform,
+                il2cpp::il2cpp_base() + 0x2F11630))(0, _parenttransform,
                                                     _session, _bbuildasync);
         }
 
         template <typename T = void>
         static T destroychildren(std::uintptr_t _intransform) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C3D668))(0, _intransform);
+                                                   0x2F116D0))(0, _intransform);
         }
 
         template <typename T = void>
         static T destroygameobject(std::uintptr_t _gameobect,
                                    bool _bregisterundo) {
             return ((T(*)(void *, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x2C3DBD0))(0, _gameobect,
+                il2cpp::il2cpp_base() + 0x2F11C84))(0, _gameobect,
                                                     _bregisterundo);
         }
 
@@ -149,13 +149,13 @@ namespace houdiniengineunity {
         static T isassetvalidinhoudini(std::uintptr_t _session,
                                        std::int32_t _assetid) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C3DBFC))(0, _session, _assetid);
+                il2cpp::il2cpp_base() + 0x2F11CB0))(0, _session, _assetid);
         }
 
         template <typename T = std::uintptr_t>
         static T getassetinscene(std::int32_t _assetid) {
             return ((T(*)(void *, std::int32_t))(il2cpp::il2cpp_base() +
-                                                 0x2C3DD48))(0, _assetid);
+                                                 0x2F11E28))(0, _assetid);
         }
 
         template <typename T = void>
@@ -163,7 +163,7 @@ namespace houdiniengineunity {
         applyworldtransfromfromhoudinitounity(std::uintptr_t _hapitransform,
                                               std::uintptr_t _unitytransform) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C3DED4))(0, _hapitransform,
+                il2cpp::il2cpp_base() + 0x2F11FB4))(0, _hapitransform,
                                                     _unitytransform);
         }
 
@@ -172,7 +172,7 @@ namespace houdiniengineunity {
         applylocaltransfromfromhoudinitounity(std::uintptr_t _hapitransform,
                                               std::uintptr_t _unitytransform) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C3E214))(0, _hapitransform,
+                il2cpp::il2cpp_base() + 0x2F122F4))(0, _hapitransform,
                                                     _unitytransform);
         }
 
@@ -180,46 +180,46 @@ namespace houdiniengineunity {
         static T applymatrixtolocaltransform(std::uintptr_t _matrix,
                                              std::uintptr_t _transform) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C3E4C8))(0, _matrix, _transform);
+                il2cpp::il2cpp_base() + 0x2F125A8))(0, _matrix, _transform);
         }
 
         template <typename T = std::uintptr_t>
         static T getmatrixfromhapitransform(std::uintptr_t _hapitransform,
                                             bool _bconverttounity) {
             return ((T(*)(void *, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x2C2FD7C))(0, _hapitransform,
+                il2cpp::il2cpp_base() + 0x2F03D08))(0, _hapitransform,
                                                     _bconverttounity);
         }
 
         template <typename T = il2cpp_quaternion>
         static T getquaternion(std::uintptr_t _m) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C3E560))(0, _m);
+                                                   0x2F12640))(0, _m);
         }
 
         template <typename T = il2cpp_vec3>
         static T getposition(std::uintptr_t _m) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C30154))(0, _m);
+                                                   0x2F040E0))(0, _m);
         }
 
         template <typename T = void>
         static T setmatrixposition(std::uintptr_t _m,
                                    std::uintptr_t _position) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C3E9F8))(0, _m, _position);
+                il2cpp::il2cpp_base() + 0x2F12AD8))(0, _m, _position);
         }
 
         template <typename T = il2cpp_vec3>
         static T getscale(std::uintptr_t _m) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C301A4))(0, _m);
+                                                   0x2F04130))(0, _m);
         }
 
         template <typename T = std::uintptr_t>
         static T gethapitransformfrommatrix(std::uintptr_t _mat) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C3EA54))(0, _mat);
+                                                   0x2F12B34))(0, _mat);
         }
 
         template <typename T = std::uintptr_t>
@@ -227,7 +227,7 @@ namespace houdiniengineunity {
                                   std::uintptr_t _s) {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, std::uintptr_t))(
-                    il2cpp::il2cpp_base() + 0x2C3ED68))(0, _p, _r, _s);
+                    il2cpp::il2cpp_base() + 0x2F12E48))(0, _p, _r, _s);
         }
 
         template <typename T = std::uintptr_t>
@@ -235,7 +235,7 @@ namespace houdiniengineunity {
                               std::uintptr_t _s) {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, std::uintptr_t))(
-                    il2cpp::il2cpp_base() + 0x2C3EFEC))(0, _p, _r, _s);
+                    il2cpp::il2cpp_base() + 0x2F130CC))(0, _p, _r, _s);
         }
 
         template <typename T = bool>
@@ -244,7 +244,7 @@ namespace houdiniengineunity {
                                  std::uintptr_t _s) {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, std::uintptr_t,
-                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C3F158))(
+                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F13238))(
                 0, _transformmatrix, _p, _r, _s);
         }
 
@@ -256,7 +256,7 @@ namespace houdiniengineunity {
                                  std::uintptr_t _attributeinfo) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
                           il2cpp_string *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C3F31C))(0, _session, _geoid,
+                il2cpp::il2cpp_base() + 0x2F133FC))(0, _session, _geoid,
                                                     _partid, _attrname, _owner,
                                                     _attributeinfo);
         }
@@ -266,7 +266,7 @@ namespace houdiniengineunity {
             std::uintptr_t _animcurve,
             il2cpp_list<std::int32_t> *_tangentvalues) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_list<std::int32_t> *))(
-                il2cpp::il2cpp_base() + 0x2C3F394))(0, _animcurve,
+                il2cpp::il2cpp_base() + 0x2F13498))(0, _animcurve,
                                                     _tangentvalues);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_houdiniassetcliffcomponent.h

@@ -17,14 +17,14 @@ namespace houdiniengineunity {
         template <typename T = il2cpp_list<std::uintptr_t> *>
         T get_clifflist() {
             return ((T(*)(heuhoudiniassetcliffcomponent *))(
-                il2cpp::il2cpp_base() + 0x2C5CFA4))(this);
+                il2cpp::il2cpp_base() + 0x2F30D68))(this);
         }
 
         template <typename T = void>
         T set_clifflist(il2cpp_list<std::uintptr_t> *_value) {
             return ((T(*)(heuhoudiniassetcliffcomponent *,
                           il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C5CFAC))(this, _value);
+                il2cpp::il2cpp_base() + 0x2F30D70))(this, _value);
         }
 
         template <typename T = void>
@@ -33,14 +33,14 @@ namespace houdiniengineunity {
                       il2cpp_vec3 _instancenormal, float _scale) {
             return ((T(*)(heuhoudiniassetcliffcomponent *, il2cpp_string *,
                           il2cpp_vec3, il2cpp_vec3, float))(
-                il2cpp::il2cpp_base() + 0x2C5CFB4))(this, _instancename,
+                il2cpp::il2cpp_base() + 0x2F30D78))(this, _instancename,
                                                     _instanceposition,
                                                     _instancenormal, _scale);
         }
 
         template <typename T = void> T processparam() {
             return ((T(*)(heuhoudiniassetcliffcomponent *))(
-                il2cpp::il2cpp_base() + 0x2C5D138))(this);
+                il2cpp::il2cpp_base() + 0x2F30EFC))(this);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_houdiniassetfoliagecomponent.h

@@ -27,23 +27,23 @@ namespace houdiniengineunity {
 
         template <typename T = il2cpp_list<std::uintptr_t> *> T get_treelist() {
             return ((T(*)(heuhoudiniassetfoliagecomponent *))(
-                il2cpp::il2cpp_base() + 0x2C5D3C0))(this);
+                il2cpp::il2cpp_base() + 0x2F31184))(this);
         }
 
         template <typename T = il2cpp_list<std::uintptr_t> *>
         T get_grasslist() {
             return ((T(*)(heuhoudiniassetfoliagecomponent *))(
-                il2cpp::il2cpp_base() + 0x2C5D3C8))(this);
+                il2cpp::il2cpp_base() + 0x2F3118C))(this);
         }
 
         template <typename T = il2cpp_list<std::uintptr_t> *> T get_rocklist() {
             return ((T(*)(heuhoudiniassetfoliagecomponent *))(
-                il2cpp::il2cpp_base() + 0x2C5D3D0))(this);
+                il2cpp::il2cpp_base() + 0x2F31194))(this);
         }
 
         template <typename T = void> T processparam() {
             return ((T(*)(heuhoudiniassetfoliagecomponent *))(
-                il2cpp::il2cpp_base() + 0x2C5D3D8))(this);
+                il2cpp::il2cpp_base() + 0x2F3119C))(this);
         }
 
         template <typename T = void>
@@ -52,19 +52,19 @@ namespace houdiniengineunity {
                       il2cpp_vec3 _instancenormal, float _scale) {
             return ((T(*)(heuhoudiniassetfoliagecomponent *, il2cpp_string *,
                           il2cpp_vec3, il2cpp_vec3, float))(
-                il2cpp::il2cpp_base() + 0x2C5D510))(this, _instancename,
+                il2cpp::il2cpp_base() + 0x2F312D4))(this, _instancename,
                                                     _instanceposition,
                                                     _instancenormal, _scale);
         }
 
         template <typename T = void> T exporttoterrain() {
             return ((T(*)(heuhoudiniassetfoliagecomponent *))(
-                il2cpp::il2cpp_base() + 0x2C5DE88))(this);
+                il2cpp::il2cpp_base() + 0x2F31C4C))(this);
         }
 
         template <typename T = void> T onvalidate() {
             return ((T(*)(heuhoudiniassetfoliagecomponent *))(
-                il2cpp::il2cpp_base() + 0x2C5F3CC))(this);
+                il2cpp::il2cpp_base() + 0x2F33190))(this);
         }
 
         template <typename T = void>
@@ -72,7 +72,7 @@ namespace houdiniengineunity {
                   il2cpp_vec3 _instancenormal, float _scale) {
             return ((T(*)(heuhoudiniassetfoliagecomponent *, il2cpp_string *,
                           il2cpp_vec3, il2cpp_vec3, float))(
-                il2cpp::il2cpp_base() + 0x2C5D8F4))(this, _instancename,
+                il2cpp::il2cpp_base() + 0x2F316B8))(this, _instancename,
                                                     _instanceposition,
                                                     _instancenormal, _scale);
         }
@@ -82,7 +82,7 @@ namespace houdiniengineunity {
                    il2cpp_vec3 _instancenormal, float _scale) {
             return ((T(*)(heuhoudiniassetfoliagecomponent *, il2cpp_string *,
                           il2cpp_vec3, il2cpp_vec3, float))(
-                il2cpp::il2cpp_base() + 0x2C5DAD0))(this, _instancename,
+                il2cpp::il2cpp_base() + 0x2F31894))(this, _instancename,
                                                     _instanceposition,
                                                     _instancenormal, _scale);
         }
@@ -92,7 +92,7 @@ namespace houdiniengineunity {
                   il2cpp_vec3 _instancenormal, float _scale) {
             return ((T(*)(heuhoudiniassetfoliagecomponent *, il2cpp_string *,
                           il2cpp_vec3, il2cpp_vec3, float))(
-                il2cpp::il2cpp_base() + 0x2C5DCAC))(this, _instancename,
+                il2cpp::il2cpp_base() + 0x2F31A70))(this, _instancename,
                                                     _instanceposition,
                                                     _instancenormal, _scale);
         }
@@ -100,7 +100,7 @@ namespace houdiniengineunity {
         template <typename T = il2cpp_array<std::uintptr_t> *>
         T getterraintreeprototypes() {
             return ((T(*)(heuhoudiniassetfoliagecomponent *))(
-                il2cpp::il2cpp_base() + 0x2C5F334))(this);
+                il2cpp::il2cpp_base() + 0x2F330F8))(this);
         }
 
         template <typename T = il2cpp_array<std::uintptr_t> *>
@@ -108,13 +108,13 @@ namespace houdiniengineunity {
             il2cpp_array<std::uintptr_t> *_terrainbounds) {
             return ((T(*)(heuhoudiniassetfoliagecomponent *,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C5E358))(this, _terrainbounds);
+                il2cpp::il2cpp_base() + 0x2F3211C))(this, _terrainbounds);
         }
 
         template <typename T = bool>
         T createprototype(il2cpp_string *_instancename) {
             return ((T(*)(heuhoudiniassetfoliagecomponent *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C5D604))(this, _instancename);
+                il2cpp::il2cpp_base() + 0x2F313C8))(this, _instancename);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_houdiniassetinstancecomponent.h

@@ -27,13 +27,13 @@ namespace houdiniengineunity {
         template <typename T = std::uintptr_t>
         T getinstancetype(il2cpp_string *_instancename) {
             return ((T(*)(heuhoudiniassetinstancecomponent *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C5D808))(this, _instancename);
+                il2cpp::il2cpp_base() + 0x2F315CC))(this, _instancename);
         }
 
         template <typename T = std::uintptr_t>
         T getinstanceprefab(il2cpp_string *_instancename) {
             return ((T(*)(heuhoudiniassetinstancecomponent *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C5F484))(this, _instancename);
+                il2cpp::il2cpp_base() + 0x2F33270))(this, _instancename);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_houdiniassetinstancedatabase.h

@@ -12,19 +12,19 @@ namespace houdiniengineunity {
         template <typename T = void>
         T addinstance(std::uintptr_t _instanceinfo) {
             return ((T(*)(heuhoudiniassetinstancedatabase *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C5F7A8))(this, _instanceinfo);
+                il2cpp::il2cpp_base() + 0x2F33594))(this, _instanceinfo);
         }
 
         template <typename T = void>
         T addinstances(il2cpp_list<std::uintptr_t> *_instanceinfos) {
             return ((T(*)(heuhoudiniassetinstancedatabase *,
                           il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C5F878))(this, _instanceinfos);
+                il2cpp::il2cpp_base() + 0x2F33664))(this, _instanceinfos);
         }
 
         template <typename T = void> T clear() {
             return ((T(*)(heuhoudiniassetinstancedatabase *))(
-                il2cpp::il2cpp_base() + 0x2C5F918))(this);
+                il2cpp::il2cpp_base() + 0x2F33704))(this);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_houdiniassetinstanceoptions.h

@@ -15,13 +15,13 @@ namespace houdiniengineunity {
 
         template <typename T = void> T onvalidate() {
             return ((T(*)(heuhoudiniassetinstanceoptions *))(
-                il2cpp::il2cpp_base() + 0x2C5FA90))(this);
+                il2cpp::il2cpp_base() + 0x2F3387C))(this);
         }
 
         template <typename T = std::uintptr_t>
         T getinstancedatabyname(il2cpp_string *_name) {
             return ((T(*)(heuhoudiniassetinstanceoptions *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C5F570))(this, _name);
+                il2cpp::il2cpp_base() + 0x2F3335C))(this, _name);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_houdiniassetroot.h

@@ -14,23 +14,23 @@ namespace houdiniengineunity {
 
         template <typename T = void> T ondestroy() {
             return ((T(*)(heuhoudiniassetroot *))(il2cpp::il2cpp_base() +
-                                                  0x2C5FD04))(this);
+                                                  0x2F33AF0))(this);
         }
 
         template <typename T = void> T removehoudiniengineassetdata() {
             return ((T(*)(heuhoudiniassetroot *))(il2cpp::il2cpp_base() +
-                                                  0x2C5FEE4))(this);
+                                                  0x2F33CD0))(this);
         }
 
         template <typename T = void> T clearhoudinienginereferences() {
             return ((T(*)(heuhoudiniassetroot *))(il2cpp::il2cpp_base() +
-                                                  0x2C60034))(this);
+                                                  0x2F33E20))(this);
         }
 
         template <typename T = void>
         static T destroyrootcomponent(std::uintptr_t _assetroot) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C600D4))(0, _assetroot);
+                                                   0x2F33EC0))(0, _assetroot);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_houdiniengineerror.h

@@ -10,7 +10,7 @@ namespace houdiniengineunity {
 
         template <typename T = il2cpp_string *> T tostring() {
             return ((T(*)(heuhoudiniengineerror *))(il2cpp::il2cpp_base() +
-                                                    0x2C603F8))(this);
+                                                    0x2F341E4))(this);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_inputmeshutility.h

@@ -9,14 +9,14 @@ namespace houdiniengineunity {
         generatemeshdatasfrominputobject(std::uintptr_t _inputobject,
                                          std::uintptr_t *_bhaslodgroup) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t *))(
-                il2cpp::il2cpp_base() + 0x2C60408))(0, _inputobject,
+                il2cpp::il2cpp_base() + 0x2F341F4))(0, _inputobject,
                                                     _bhaslodgroup);
         }
 
         template <typename T = std::uintptr_t>
         static T createsinglemeshdata(std::uintptr_t _meshgameobject) {
             return ((T(*)(void *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C606C8))(0, _meshgameobject);
+                il2cpp::il2cpp_base() + 0x2F344B4))(0, _meshgameobject);
         }
 
         template <typename T = bool>
@@ -26,7 +26,7 @@ namespace houdiniengineunity {
                                      bool _bhaslodgroup) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t,
                           il2cpp_list<std::uintptr_t> *,
-                          bool))(il2cpp::il2cpp_base() + 0x2C6099C))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F34788))(
                 0, _session, _inputnodeid, _uploadmeshes, _bhaslodgroup);
         }
 
@@ -37,7 +37,7 @@ namespace houdiniengineunity {
                                             std::uintptr_t *_inputnodeid) {
             return (
                 (T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
-                      std::uintptr_t *))(il2cpp::il2cpp_base() + 0x2C63560))(
+                      std::uintptr_t *))(il2cpp::il2cpp_base() + 0x2F37430))(
                 0, _session, _assetid, _inputobject, _inputnodeid);
         }
 
@@ -49,7 +49,7 @@ namespace houdiniengineunity {
             bool _bkeepworldtransform) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::uintptr_t,
                           std::uintptr_t, std::uintptr_t,
-                          bool))(il2cpp::il2cpp_base() + 0x2C637D4))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F376D0))(
                 0, _session, _assetid, _connectedassetid, _inputobjects,
                 _inputobjectsconnectedassetids, _bkeepworldtransform);
         }
@@ -60,7 +60,7 @@ namespace houdiniengineunity {
                                             std::int32_t _connectedassetid,
                                             bool _bkeepworldtransform) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t, std::int32_t,
-                          bool))(il2cpp::il2cpp_base() + 0x2C64088))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F37FC4))(
                 0, _session, _inputobject, _connectedassetid,
                 _bkeepworldtransform);
         }
@@ -74,7 +74,7 @@ namespace houdiniengineunity {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
                           il2cpp_string *, std::int32_t,
                           il2cpp_array<std::uintptr_t> *, std::uintptr_t,
-                          bool))(il2cpp::il2cpp_base() + 0x2C62948))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F36834))(
                 0, _session, _geoid, _partid, _attrname, _tuplesize, _data,
                 _partinfo, _bconverttohoudinicoordinatesystem);
         }
@@ -90,7 +90,7 @@ namespace houdiniengineunity {
                           il2cpp_string *, std::int32_t,
                           il2cpp_array<std::uintptr_t> *,
                           il2cpp_array<std::uintptr_t> *, std::uintptr_t,
-                          bool))(il2cpp::il2cpp_base() + 0x2C62CB8))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F36BCC))(
                 0, _session, _geoid, _partid, _attrname, _tuplesize, _data,
                 _indices, _partinfo, _bconverttohoudinicoordinatesystem);
         }
@@ -105,7 +105,7 @@ namespace houdiniengineunity {
                           il2cpp_string *, std::int32_t,
                           il2cpp_array<std::uintptr_t> *,
                           il2cpp_array<std::uintptr_t> *,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C63088))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F36FE4))(
                 0, _session, _geoid, _partid, _attrname, _tuplesize, _data,
                 _indices, _partinfo);
         }
@@ -118,7 +118,7 @@ namespace houdiniengineunity {
                                            std::uintptr_t _mesh) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
                           std::int32_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C64534))(0, _session, _assetnodeid,
+                il2cpp::il2cpp_base() + 0x2F384A0))(0, _session, _assetnodeid,
                                                     _objectid, _geoid, _mesh);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_inputnode.h

@@ -62,79 +62,79 @@ namespace houdiniengineunity {
         }
 
         template <typename T = std::uintptr_t> T get_inputtype() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C48E48))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F1D4C0))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_pendinginputobjecttype() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C65000))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F38FC0))(
                 this);
         }
 
         template <typename T = void>
         T set_pendinginputobjecttype(std::uintptr_t _value) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C65008))(this, _value);
+                il2cpp::il2cpp_base() + 0x2F38FC8))(this, _value);
         }
 
         template <typename T = bool> T get_requirescook() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C36CEC))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F0ABBC))(
                 this);
         }
 
         template <typename T = void> T set_requirescook(bool _value) {
             return ((T(*)(heuinputnode *, bool))(il2cpp::il2cpp_base() +
-                                                 0x2C4D6A8))(this, _value);
+                                                 0x2F21DC4))(this, _value);
         }
 
         template <typename T = bool> T get_requiresupload() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C48E50))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F1D4C8))(
                 this);
         }
 
         template <typename T = void> T set_requiresupload(bool _value) {
             return ((T(*)(heuinputnode *, bool))(il2cpp::il2cpp_base() +
-                                                 0x2C5B6B0))(this, _value);
+                                                 0x2F2F3C0))(this, _value);
         }
 
         template <typename T = il2cpp_string *> T get_inputname() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C58214))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F2BF24))(
                 this);
         }
 
         template <typename T = il2cpp_string *> T get_paramname() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C65010))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F38FD0))(
                 this);
         }
 
         template <typename T = void> T set_paramname(il2cpp_string *_value) {
             return ((T(*)(heuinputnode *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C65018))(this, _value);
+                il2cpp::il2cpp_base() + 0x2F38FD8))(this, _value);
         }
 
         template <typename T = bool> T get_keepworldtransform() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C65020))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F38FE0))(
                 this);
         }
 
         template <typename T = void> T set_keepworldtransform(bool _value) {
             return ((T(*)(heuinputnode *, bool))(il2cpp::il2cpp_base() +
-                                                 0x2C65028))(this, _value);
+                                                 0x2F38FE8))(this, _value);
         }
 
         template <typename T = bool> T get_packgeometrybeforemerging() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C65030))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F38FF0))(
                 this);
         }
 
         template <typename T = void>
         T set_packgeometrybeforemerging(bool _value) {
             return ((T(*)(heuinputnode *, bool))(il2cpp::il2cpp_base() +
-                                                 0x2C65038))(this, _value);
+                                                 0x2F38FF8))(this, _value);
         }
 
         template <typename T = std::uintptr_t> T get_parentasset() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C65040))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F39000))(
                 this);
         }
 
@@ -146,158 +146,158 @@ namespace houdiniengineunity {
                                   std::uintptr_t _parentasset) {
             return ((T(*)(void *, std::int32_t, std::int32_t, il2cpp_string *,
                           std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C33F18))(0, _nodeid, _inputindex,
+                il2cpp::il2cpp_base() + 0x2F07CB4))(0, _nodeid, _inputindex,
                                                     _inputname, _inputnodetype,
                                                     _parentasset);
         }
 
         template <typename T = void> T destroyalldata(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C31E04))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F05DCC))(this, _session);
         }
 
         template <typename T = void> T resetinputobjecttransforms() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C65304))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F3930C))(
                 this);
         }
 
         template <typename T = void> T resetinputnode(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C6545C))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F39464))(this, _session);
         }
 
         template <typename T = std::uintptr_t>
         T createinputobjectinfo(std::uintptr_t _inputgameobject) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C65570))(this, _inputgameobject);
+                il2cpp::il2cpp_base() + 0x2F39578))(this, _inputgameobject);
         }
 
         template <typename T = std::uintptr_t>
         T createinputterraininfo(std::uintptr_t _inputterrain) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C656E4))(this, _inputterrain);
+                il2cpp::il2cpp_base() + 0x2F396EC))(this, _inputterrain);
         }
 
         template <typename T = void>
         T insertinputobject(std::int32_t _index,
                             std::uintptr_t _newinputgameobject) {
             return ((T(*)(heuinputnode *, std::int32_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C65784))(this, _index,
+                il2cpp::il2cpp_base() + 0x2F3978C))(this, _index,
                                                     _newinputgameobject);
         }
 
         template <typename T = std::uintptr_t>
         T getinputobject(std::int32_t _index) {
             return ((T(*)(heuinputnode *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C65A04))(this, _index);
+                il2cpp::il2cpp_base() + 0x2F39A0C))(this, _index);
         }
 
         template <typename T = void>
         T addinputobjectatend(std::uintptr_t _newinputgameobject) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C65C78))(this, _newinputgameobject);
+                il2cpp::il2cpp_base() + 0x2F39C80))(this, _newinputgameobject);
         }
 
         template <typename T = void> T removeinputobject(std::int32_t _index) {
             return ((T(*)(heuinputnode *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C65D24))(this, _index);
+                il2cpp::il2cpp_base() + 0x2F39D2C))(this, _index);
         }
 
         template <typename T = void> T removeallinputobjects() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C654A8))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F394B0))(
                 this);
         }
 
         template <typename T = std::int32_t> T numinputobjects() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C65F90))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F39F98))(
                 this);
         }
 
         template <typename T = void>
         T changeinputtype(std::uintptr_t _session, std::uintptr_t _newtype) {
             return ((T(*)(heuinputnode *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C65540))(this, _session, _newtype);
+                il2cpp::il2cpp_base() + 0x2F39548))(this, _session, _newtype);
         }
 
         template <typename T = void>
         T resetconnectionforforceupdate(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C4CD78))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F21494))(this, _session);
         }
 
         template <typename T = void> T uploadinput(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C4CDB8))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F214D4))(this, _session);
         }
 
         template <typename T = bool> T isinputassetconnected() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C66028))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F3A030))(
                 this);
         }
 
         template <typename T = void>
         T connectinputassetactor(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C66AF4))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F3ABF8))(this, _session);
         }
 
         template <typename T = void>
         T disconnectinputassetactor(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C660D8))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F3A0E0))(this, _session);
         }
 
         template <typename T = void>
         T connectinputnode(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C66504))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F3A548))(this, _session);
         }
 
         template <typename T = void>
         T disconnectanddestroyinputassets(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C65054))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F39014))(this, _session);
         }
 
         template <typename T = bool>
         T uploadobjectmergetransformtype(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C66774))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F3A7F8))(this, _session);
         }
 
         template <typename T = bool>
         T uploadobjectmergepackgeometry(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C66934))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F3A9F8))(this, _session);
         }
 
         template <typename T = bool> T hasinputnodetransformchanged() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C48E58))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F1D4D0))(
                 this);
         }
 
         template <typename T = bool>
         T uploadinputobjecttransforms(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C6702C))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F3B130))(this, _session);
         }
 
         template <typename T = void>
         T cookupstreamconnectedasset(std::uintptr_t _session) {
             return ((T(*)(heuinputnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C52F98))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F2782C))(this, _session);
         }
 
         template <typename T = void>
         T copyinputvaluesto(std::uintptr_t _session,
                             std::uintptr_t _destinputnode) {
             return ((T(*)(heuinputnode *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C5B420))(this, _session,
+                il2cpp::il2cpp_base() + 0x2F2F130))(this, _session,
                                                     _destinputnode);
         }
 
         template <typename T = void> T clearuicache() {
-            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2C65048))(
+            return ((T(*)(heuinputnode *))(il2cpp::il2cpp_base() + 0x2F39008))(
                 this);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_inputobjectinfo.h

@@ -28,7 +28,7 @@ namespace houdiniengineunity {
 
         template <typename T = void> T copyto(std::uintptr_t _destobject) {
             return ((T(*)(heuinputobjectinfo *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C67218))(this, _destobject);
+                il2cpp::il2cpp_base() + 0x2F3B31C))(this, _destobject);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_inputvolumeutility.h

@@ -8,7 +8,7 @@ namespace houdiniengineunity {
         static T ishoudininodevalid(std::uintptr_t _session,
                                     std::int32_t _nodeid) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C6736C))(0, _session, _nodeid);
+                il2cpp::il2cpp_base() + 0x2F3B470))(0, _session, _nodeid);
         }
 
         template <typename T = bool>
@@ -18,7 +18,7 @@ namespace houdiniengineunity {
                                        std::int32_t _parentnodeid) {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, il2cpp_string *,
-                      std::int32_t))(il2cpp::il2cpp_base() + 0x2C674B4))(
+                      std::int32_t))(il2cpp::il2cpp_base() + 0x2F3B5E4))(
                 0, _session, _volumenodeid, _nodename, _parentnodeid);
         }
 
@@ -32,7 +32,7 @@ namespace houdiniengineunity {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, std::uintptr_t,
                       std::uintptr_t, std::uintptr_t, std::uintptr_t,
-                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C675C4))(
+                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F3B714))(
                 0, _session, _hostassetid, _terrain, _connectedassetid,
                 _outcreatednodeids, _bexportonlyselected, _bexportasheighfield);
         }
@@ -44,7 +44,7 @@ namespace houdiniengineunity {
                                             il2cpp_string *_nodename) {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, std::uintptr_t,
-                      il2cpp_string *))(il2cpp::il2cpp_base() + 0x2C678C4))(
+                      il2cpp_string *))(il2cpp::il2cpp_base() + 0x2F3BA44))(
                 0, _session, _displaynodeid, _mergenodeid, _nodename);
         }
 
@@ -54,7 +54,7 @@ namespace houdiniengineunity {
                                        std::int32_t _nodetoconnectto,
                                        std::uintptr_t _inputtoconnect) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C681E8))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F3C534))(
                 0, _session, _nodetocommit, _nodetoconnectto, _inputtoconnect);
         }
 
@@ -69,7 +69,7 @@ namespace houdiniengineunity {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
                           il2cpp_array<std::uintptr_t> *, std::uintptr_t,
                           il2cpp_string *,
-                          std::int32_t))(il2cpp::il2cpp_base() + 0x2C68380))(
+                          std::int32_t))(il2cpp::il2cpp_base() + 0x2F3C724))(
                 0, _session, _volumenodeid, _partid, _floatvalues, _volumeinfo,
                 _heightfieldname, _tileindex);
         }
@@ -84,7 +84,7 @@ namespace houdiniengineunity {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
                           std::int32_t, std::int32_t,
                           il2cpp_array<std::uintptr_t> *, std::uintptr_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C68644))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F3CA5C))(
                 0, _terraindata, _minx, _miny, _maxx, _maxy, _heightdata,
                 _xsize, _ysize);
         }
@@ -92,7 +92,7 @@ namespace houdiniengineunity {
         template <typename T = bool>
         static T getterrainlayerdate(std::uintptr_t _terraindata) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C688CC))(0, _terraindata);
+                                                   0x2F3CCE4))(0, _terraindata);
         }
 
         template <typename T = bool>
@@ -102,7 +102,7 @@ namespace houdiniengineunity {
             std::uintptr_t _heightfieldvolumeinfo) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t,
                           std::uintptr_t, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C688D4))(0, _session, _xsize, _ysize,
+                il2cpp::il2cpp_base() + 0x2F3CCEC))(0, _session, _xsize, _ysize,
                                                     _terraintrans,
                                                     _heightfieldvolumeinfo);
         }
@@ -115,7 +115,7 @@ namespace houdiniengineunity {
                                    std::uintptr_t _inputobject) {
             return (
                 (T(*)(void *, std::uintptr_t, std::uintptr_t, std::uintptr_t,
-                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C66D10))(
+                      std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F3AE14))(
                 0, _session, _connectedassetid, _inputterrainconnectassetid,
                 _inputobject);
         }
@@ -128,7 +128,7 @@ namespace houdiniengineunity {
                                               std::uintptr_t _mergeinputindex) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t,
                           std::uintptr_t, std::uintptr_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C67E8C))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F3C1D8))(
                 0, _session, _terrain, _inputmergenodeid, _componentindex,
                 _mergeinputindex);
         }

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_materialdata.h

@@ -16,14 +16,14 @@ namespace houdiniengineunity {
 
         template <typename T = bool> T isexistingmaterial() {
             return ((T(*)(heumaterialdata *))(il2cpp::il2cpp_base() +
-                                              0x2C68A70))(this);
+                                              0x2F3CE88))(this);
         }
 
         template <typename T = void>
         T updatematerialfromhoudini(std::uintptr_t _materialinfo,
                                     il2cpp_string *_assetcachefolderpath) {
             return ((T(*)(heumaterialdata *, std::uintptr_t, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C55B28))(this, _materialinfo,
+                il2cpp::il2cpp_base() + 0x2F297F4))(this, _materialinfo,
                                                     _assetcachefolderpath);
         }
 
@@ -32,7 +32,7 @@ namespace houdiniengineunity {
                                                      std::int32_t _nodeid,
                                                      std::uintptr_t _parminfo) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C68C84))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F3D0B0))(
                 0, _session, _nodeid, _parminfo);
         }
 
@@ -42,7 +42,7 @@ namespace houdiniengineunity {
                               il2cpp_array<std::uintptr_t> *_parameters) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C68A88))(0, _session, _nodeid,
+                il2cpp::il2cpp_base() + 0x2F3CEA0))(0, _session, _nodeid,
                                                     _parameters);
         }
 
@@ -50,7 +50,7 @@ namespace houdiniengineunity {
         static T getsupportedfileformat(std::uintptr_t _session,
                                         std::uintptr_t _imageinfo) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C69778))(0, _session, _imageinfo);
+                il2cpp::il2cpp_base() + 0x2F3DC24))(0, _session, _imageinfo);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_materialfactory.h

@@ -7,19 +7,19 @@ namespace houdiniengineunity {
         template <typename T = std::uintptr_t>
         static T findshader(il2cpp_string *_shadername) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C69910))(0, _shadername);
+                                                    0x2F3DDBC))(0, _shadername);
         }
 
         template <typename T = il2cpp_string *>
         static T gethoudinishaderpath(il2cpp_string *_shadername) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C699D0))(0, _shadername);
+                                                    0x2F3DE7C))(0, _shadername);
         }
 
         template <typename T = std::uintptr_t>
         static T findpluginshader(il2cpp_string *_shadername) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C68B48))(0, _shadername);
+                                                    0x2F3CF60))(0, _shadername);
         }
 
         template <typename T = std::uintptr_t>
@@ -29,7 +29,7 @@ namespace houdiniengineunity {
                                           bool _bwritetofile) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_string *,
                           il2cpp_string *, bool))(
-                il2cpp::il2cpp_base() + 0x2C69A94))(0, _assetcachefolderpath,
+                il2cpp::il2cpp_base() + 0x2F3DF40))(0, _assetcachefolderpath,
                                                     _shadername, _materialname,
                                                     _bwritetofile);
         }
@@ -40,7 +40,7 @@ namespace houdiniengineunity {
                                          il2cpp_string *_materialname,
                                          bool _bwritetofile) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_string *, bool))(
-                il2cpp::il2cpp_base() + 0x2C542B8))(
+                il2cpp::il2cpp_base() + 0x2F28644))(
                 0, _assetcachefolderpath, _materialname, _bwritetofile);
         }
 
@@ -49,28 +49,28 @@ namespace houdiniengineunity {
                                            il2cpp_string *_assetcachefolderpath,
                                            il2cpp_string *_materialname) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
-                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2C5450C))(
+                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2F28898))(
                 0, _material, _assetcachefolderpath, _materialname);
         }
 
         template <typename T = bool>
         static T doesmaterialexistinassetcache(std::uintptr_t _material) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C69D14))(0, _material);
+                                                   0x2F3E1C0))(0, _material);
         }
 
         template <typename T = void>
         static T destroynonassetmaterial(std::uintptr_t _material,
                                          bool _bregisterundo) {
             return ((T(*)(void *, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x2C69DD4))(0, _material,
+                il2cpp::il2cpp_base() + 0x2F3E280))(0, _material,
                                                     _bregisterundo);
         }
 
         template <typename T = void>
         static T deleteassetmaterial(std::uintptr_t _material) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C56430))(0, _material);
+                                                   0x2F2A140))(0, _material);
         }
 
         template <typename T = std::uintptr_t>
@@ -80,7 +80,7 @@ namespace houdiniengineunity {
             il2cpp_string *_assetcachefolderpath) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t, std::int32_t,
                           il2cpp_string *,
-                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2C68F2C))(
+                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2F3D370))(
                 0, _session, _materialinfo, _textureparmid, _texturename,
                 _assetcachefolderpath);
         }
@@ -91,7 +91,7 @@ namespace houdiniengineunity {
                                             std::uintptr_t _materialinfo,
                                             il2cpp_string *_imageplanes) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t,
-                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2C6A30C))(
+                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2F3E7FC))(
                 0, _session, _materialinfo, _imageplanes);
         }
 
@@ -100,7 +100,7 @@ namespace houdiniengineunity {
                                                  std::uintptr_t _materialinfo,
                                                  il2cpp_string *_imageplanes) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t,
-                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2C69EC8))(
+                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2F3E374))(
                 0, _session, _materialinfo, _imageplanes);
         }
 
@@ -110,7 +110,7 @@ namespace houdiniengineunity {
             il2cpp_string *_imageplanes, il2cpp_string *_assetcachefolderpath) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t,
                           il2cpp_string *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C6A59C))(0, _session, _materialinfo,
+                il2cpp::il2cpp_base() + 0x2F3EAC4))(0, _session, _materialinfo,
                                                     _imageplanes,
                                                     _assetcachefolderpath);
         }
@@ -118,14 +118,14 @@ namespace houdiniengineunity {
         template <typename T = std::uintptr_t>
         static T loadunitymaterial(il2cpp_string *_materialpath) {
             return ((T(*)(void *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C5506C))(0, _materialpath);
+                il2cpp::il2cpp_base() + 0x2F28F68))(0, _materialpath);
         }
 
         template <typename T = std::uintptr_t>
         static T loadsubstancematerialwithname(il2cpp_string *_materialpath,
                                                il2cpp_string *_substancename) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C54AE4))(0, _materialpath,
+                il2cpp::il2cpp_base() + 0x2F289E0))(0, _materialpath,
                                                     _substancename);
         }
 
@@ -134,7 +134,7 @@ namespace houdiniengineunity {
         loadsubstancematerialwithindex(il2cpp_string *_materialpath,
                                        std::int32_t _substancematerialindex) {
             return ((T(*)(void *, il2cpp_string *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C54D2C))(0, _materialpath,
+                il2cpp::il2cpp_base() + 0x2F28C28))(0, _materialpath,
                                                     _substancematerialindex);
         }
 
@@ -143,37 +143,37 @@ namespace houdiniengineunity {
                                               il2cpp_string *_substancename,
                                               std::int32_t _substanceindex) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_string *,
-                          std::int32_t))(il2cpp::il2cpp_base() + 0x2C6A81C))(
+                          std::int32_t))(il2cpp::il2cpp_base() + 0x2EF8B58))(
                 0, _unitymaterialpath, _substancename, _substanceindex);
         }
 
         template <typename T = std::int32_t>
         static T materialnametokey(il2cpp_string *_materialname) {
             return ((T(*)(void *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C54010))(0, _materialname);
+                il2cpp::il2cpp_base() + 0x2F0033C))(0, _materialname);
         }
 
         template <typename T = void>
         static T enablegpuinstancing(std::uintptr_t _material) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C6A9C0))(0, _material);
+                                                   0x2EFD3BC))(0, _material);
         }
 
         template <typename T = bool>
         static T materialhasgpuinstancingenabled(std::uintptr_t _material) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C6A9F0))(0, _material);
+                                                   0x2F3ED70))(0, _material);
         }
 
         template <typename T = std::uintptr_t>
         static T copymaterial(std::uintptr_t _material) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C6AA1C))(0, _material);
+                                                   0x2F3ED9C))(0, _material);
         }
 
         template <typename T = std::uintptr_t>
         static T getdefaultstandardmaterial() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2C6AAB0))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2F3EE30))(0);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_objectnode.h

@@ -21,44 +21,44 @@ namespace houdiniengineunity {
         }
 
         template <typename T = std::int32_t> T get_objectid() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C340B0))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F07E4C))(
                 this);
         }
 
         template <typename T = il2cpp_string *> T get_objectname() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C36B94))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F0AA4C))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_parentasset() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C31818))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F057A4))(
                 this);
         }
 
         template <typename T = bool> T isinstancer() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C32C84))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F06A10))(
                 this);
         }
 
         template <typename T = bool> T isinstanced() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C34EC0))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F08C5C))(
                 this);
         }
 
         template <typename T = bool> T isvisible() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C316C8))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F05654))(
                 this);
         }
 
         template <typename T = void> T reset() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C6AEF8))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F3F060))(
                 this);
         }
 
         template <typename T = void>
         T syncwithobjectinfo(std::uintptr_t _session) {
             return ((T(*)(heuobjectnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C6B0C4))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F3F22C))(this, _session);
         }
 
         template <typename T = void>
@@ -67,146 +67,146 @@ namespace houdiniengineunity {
                      std::uintptr_t _parentasset) {
             return ((T(*)(heuobjectnode *, std::uintptr_t, std::uintptr_t,
                           std::uintptr_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C4DF68))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F22738))(
                 this, _session, _objectinfo, _objecttranform, _parentasset);
         }
 
         template <typename T = void> T destroyalldata() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C49390))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F1DA28))(
                 this);
         }
 
         template <typename T = std::uintptr_t>
         T creategeonode(std::uintptr_t _session, std::uintptr_t _geoinfo) {
             return ((T(*)(heuobjectnode *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C6B2CC))(this, _session, _geoinfo);
+                il2cpp::il2cpp_base() + 0x2F3F46C))(this, _session, _geoinfo);
         }
 
         template <typename T = void> T getdebuginfo(std::uintptr_t _sb) {
             return ((T(*)(heuobjectnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C6B3D0))(this, _sb);
+                il2cpp::il2cpp_base() + 0x2F3F570))(this, _sb);
         }
 
         template <typename T = void>
         T setobjectinfo(std::uintptr_t _newobjectinfo) {
             return ((T(*)(heuobjectnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C4DF48))(this, _newobjectinfo);
+                il2cpp::il2cpp_base() + 0x2F22718))(this, _newobjectinfo);
         }
 
         template <typename T = void>
         T updateobject(std::uintptr_t _session, bool _bforceupdate) {
             return ((T(*)(heuobjectnode *, std::uintptr_t, bool))(
-                il2cpp::il2cpp_base() + 0x2C47518))(this, _session,
+                il2cpp::il2cpp_base() + 0x2F1BADC))(this, _session,
                                                     _bforceupdate);
         }
 
         template <typename T = void>
         T generategeometry(std::uintptr_t _session) {
             return ((T(*)(heuobjectnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C4E414))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F22C20))(this, _session);
         }
 
         template <typename T = void>
         T generatepartinstances(std::uintptr_t _session) {
             return ((T(*)(heuobjectnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C4ED9C))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F235A8))(this, _session);
         }
 
         template <typename T = void> T applyobjecttransformtogeonodes() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C6BBC4))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F3FCFC))(
                 this);
         }
 
         template <typename T = bool>
         T isusingmaterial(std::uintptr_t _materialdata) {
             return ((T(*)(heuobjectnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C56258))(this, _materialdata);
+                il2cpp::il2cpp_base() + 0x2F29F68))(this, _materialdata);
         }
 
         template <typename T = void>
         T getclonableparts(il2cpp_list<std::uintptr_t> *_clonableparts) {
             return ((T(*)(heuobjectnode *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C567DC))(this, _clonableparts);
+                il2cpp::il2cpp_base() + 0x2F2A4EC))(this, _clonableparts);
         }
 
         template <typename T = std::uintptr_t>
         T getpartwithid(std::int32_t _partid) {
             return ((T(*)(heuobjectnode *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C56B14))(this, _partid);
+                il2cpp::il2cpp_base() + 0x2F2A824))(this, _partid);
         }
 
         template <typename T = void>
         T getoutputgameobjects(il2cpp_list<std::uintptr_t> *_outputobjects) {
             return ((T(*)(heuobjectnode *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C56CAC))(this, _outputobjects);
+                il2cpp::il2cpp_base() + 0x2F2A9BC))(this, _outputobjects);
         }
 
         template <typename T = void>
         T getoutput(il2cpp_list<std::uintptr_t> *_outputs) {
             return ((T(*)(heuobjectnode *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C56FD4))(this, _outputs);
+                il2cpp::il2cpp_base() + 0x2F2ACE4))(this, _outputs);
         }
 
         template <typename T = std::uintptr_t>
         T gethdapartwithgameobject(std::uintptr_t _outputgameobject) {
             return ((T(*)(heuobjectnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C5738C))(this, _outputgameobject);
+                il2cpp::il2cpp_base() + 0x2F2B09C))(this, _outputgameobject);
         }
 
         template <typename T = std::uintptr_t>
         T getgeonode(std::int32_t _nodeid) {
             return ((T(*)(heuobjectnode *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C577D4))(this, _nodeid);
+                il2cpp::il2cpp_base() + 0x2F2B4E4))(this, _nodeid);
         }
 
         template <typename T = void>
         T getcurves(il2cpp_list<std::uintptr_t> *_curves, bool _beditableonly) {
             return ((T(*)(heuobjectnode *, il2cpp_list<std::uintptr_t> *,
-                          bool))(il2cpp::il2cpp_base() + 0x2C6BEB0))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F3FFE8))(
                 this, _curves, _beditableonly);
         }
 
         template <typename T = void>
         T generateobjectinstances(std::uintptr_t _session) {
             return ((T(*)(heuobjectnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C4EF30))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F2373C))(this, _session);
         }
 
         template <typename T = void>
         T populateobjectinstanceinfos(
             il2cpp_list<std::uintptr_t> *_objinstanceinfos) {
             return ((T(*)(heuobjectnode *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C59350))(this, _objinstanceinfos);
+                il2cpp::il2cpp_base() + 0x2F2D060))(this, _objinstanceinfos);
         }
 
         template <typename T = void>
         T processunityscriptattributes(std::uintptr_t _session) {
             return ((T(*)(heuobjectnode *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C441F8))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F18544))(this, _session);
         }
 
         template <typename T = void> T hideallgeometry() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C59A78))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F2D788))(
                 this);
         }
 
         template <typename T = void> T calculatevisibility() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C59D90))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F2DAA0))(
                 this);
         }
 
         template <typename T = void> T calculatecolliderstate() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C5A3C4))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F2E0D4))(
                 this);
         }
 
         template <typename T = void> T disableallcolliders() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C5A0AC))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F2DDBC))(
                 this);
         }
 
         template <typename T = il2cpp_string *> T tostring() {
-            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2C6E490))(
+            return ((T(*)(heuobjectnode *))(il2cpp::il2cpp_base() + 0x2F42678))(
                 this);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_parameteraccessor.h

@@ -9,7 +9,7 @@ namespace houdiniengineunity {
                            std::uintptr_t *_outvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           std::uintptr_t *))(il2cpp::il2cpp_base() +
-                                             0x2C6E5B4))(0, _asset, _paramname,
+                                             0x2F4279C))(0, _asset, _paramname,
                                                          _outvalue);
         }
 
@@ -17,7 +17,7 @@ namespace houdiniengineunity {
         static T settoggle(std::uintptr_t _asset, il2cpp_string *_paramname,
                            bool _setvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *, bool))(
-                il2cpp::il2cpp_base() + 0x2C6E7AC))(0, _asset, _paramname,
+                il2cpp::il2cpp_base() + 0x2F42994))(0, _asset, _paramname,
                                                     _setvalue);
         }
 
@@ -26,7 +26,7 @@ namespace houdiniengineunity {
                         std::uintptr_t *_outvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           std::uintptr_t *))(il2cpp::il2cpp_base() +
-                                             0x2C6E984))(0, _asset, _paramname,
+                                             0x2F42B6C))(0, _asset, _paramname,
                                                          _outvalue);
         }
 
@@ -34,7 +34,7 @@ namespace houdiniengineunity {
         static T setint(std::uintptr_t _asset, il2cpp_string *_paramname,
                         std::int32_t _setvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
-                          std::int32_t))(il2cpp::il2cpp_base() + 0x2C6EB9C))(
+                          std::int32_t))(il2cpp::il2cpp_base() + 0x2F42D84))(
                 0, _asset, _paramname, _setvalue);
         }
 
@@ -43,7 +43,7 @@ namespace houdiniengineunity {
                           std::uintptr_t *_outvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           std::uintptr_t *))(il2cpp::il2cpp_base() +
-                                             0x2C6ED94))(0, _asset, _paramname,
+                                             0x2F42F7C))(0, _asset, _paramname,
                                                          _outvalue);
         }
 
@@ -52,7 +52,7 @@ namespace houdiniengineunity {
                            il2cpp_array<std::uintptr_t> **_outvalues) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           il2cpp_array<std::uintptr_t> **))(
-                il2cpp::il2cpp_base() + 0x2C6EFAC))(0, _asset, _paramname,
+                il2cpp::il2cpp_base() + 0x2F43194))(0, _asset, _paramname,
                                                     _outvalues);
         }
 
@@ -60,7 +60,7 @@ namespace houdiniengineunity {
         static T setfloat(std::uintptr_t _asset, il2cpp_string *_paramname,
                           float _setvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *, float))(
-                il2cpp::il2cpp_base() + 0x2C6F1C8))(0, _asset, _paramname,
+                il2cpp::il2cpp_base() + 0x2F433B0))(0, _asset, _paramname,
                                                     _setvalue);
         }
 
@@ -69,7 +69,7 @@ namespace houdiniengineunity {
                            il2cpp_array<std::uintptr_t> *_setvalues) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C6F3CC))(0, _asset, _paramname,
+                il2cpp::il2cpp_base() + 0x2F435B4))(0, _asset, _paramname,
                                                     _setvalues);
         }
 
@@ -78,7 +78,7 @@ namespace houdiniengineunity {
                            std::uintptr_t *_outvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           std::uintptr_t *))(il2cpp::il2cpp_base() +
-                                             0x2C6F5A4))(0, _asset, _paramname,
+                                             0x2F4378C))(0, _asset, _paramname,
                                                          _outvalue);
         }
 
@@ -86,7 +86,7 @@ namespace houdiniengineunity {
         static T setstring(std::uintptr_t _asset, il2cpp_string *_paramname,
                            il2cpp_string *_setvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
-                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2C6F7D8))(
+                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2F439C0))(
                 0, _asset, _paramname, _setvalue);
         }
 
@@ -94,7 +94,7 @@ namespace houdiniengineunity {
         static T setchoice(std::uintptr_t _asset, il2cpp_string *_paramname,
                            std::int32_t _setvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
-                          std::int32_t))(il2cpp::il2cpp_base() + 0x2C6F9FC))(
+                          std::int32_t))(il2cpp::il2cpp_base() + 0x2F43BE4))(
                 0, _asset, _paramname, _setvalue);
         }
 
@@ -103,7 +103,7 @@ namespace houdiniengineunity {
                            std::uintptr_t *_outvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           std::uintptr_t *))(il2cpp::il2cpp_base() +
-                                             0x2C6FC24))(0, _asset, _paramname,
+                                             0x2F43E0C))(0, _asset, _paramname,
                                                          _outvalue);
         }
 
@@ -112,7 +112,7 @@ namespace houdiniengineunity {
                               std::uintptr_t _obj, std::int32_t _index) {
             return (
                 (T(*)(void *, std::uintptr_t, il2cpp_string *, std::uintptr_t,
-                      std::int32_t))(il2cpp::il2cpp_base() + 0x2C6FE28))(
+                      std::int32_t))(il2cpp::il2cpp_base() + 0x2F44010))(
                 0, _asset, _paramname, _obj, _index);
         }
 
@@ -121,7 +121,7 @@ namespace houdiniengineunity {
                               std::int32_t _index, std::uintptr_t *_obj) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *, std::int32_t,
                           std::uintptr_t *))(il2cpp::il2cpp_base() +
-                                             0x2C70090))(0, _asset, _paramname,
+                                             0x2F44278))(0, _asset, _paramname,
                                                          _index, _obj);
         }
 
@@ -130,7 +130,7 @@ namespace houdiniengineunity {
                           std::uintptr_t *_getvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
                           std::uintptr_t *))(il2cpp::il2cpp_base() +
-                                             0x2C70330))(0, _asset, _paramname,
+                                             0x2F44518))(0, _asset, _paramname,
                                                          _getvalue);
         }
 
@@ -138,7 +138,7 @@ namespace houdiniengineunity {
         static T setcolor(std::uintptr_t _asset, il2cpp_string *_paramname,
                           std::uintptr_t _setvalue) {
             return ((T(*)(void *, std::uintptr_t, il2cpp_string *,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C70548))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F44730))(
                 0, _asset, _paramname, _setvalue);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_parameterdata.h

@@ -76,132 +76,132 @@ namespace houdiniengineunity {
 
         template <typename T = std::int32_t> T get_parmid() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C3A504))(this);
+                                               0x2F0E3AC))(this);
         }
 
         template <typename T = std::int32_t> T get_parentid() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C707E4))(this);
+                                               0x2F449CC))(this);
         }
 
         template <typename T = std::int32_t> T get_childindex() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C707EC))(this);
+                                               0x2F449D4))(this);
         }
 
         template <typename T = std::int32_t> T get_parmsize() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C707F4))(this);
+                                               0x2F449DC))(this);
         }
 
         template <typename T = bool> T isint() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C6EB88))(this);
+                                               0x2F42D70))(this);
         }
 
         template <typename T = bool> T isfloat() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C6EF98))(this);
+                                               0x2F43180))(this);
         }
 
         template <typename T = bool> T isstring() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C6F7AC))(this);
+                                               0x2F43994))(this);
         }
 
         template <typename T = bool> T ispathfile() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C6F7C0))(this);
+                                               0x2F439A8))(this);
         }
 
         template <typename T = bool> T hasmin() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C707FC))(this);
+                                               0x2F449E4))(this);
         }
 
         template <typename T = bool> T hasmax() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70804))(this);
+                                               0x2F449EC))(this);
         }
 
         template <typename T = bool> T hasuimin() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C7080C))(this);
+                                               0x2F449F4))(this);
         }
 
         template <typename T = bool> T hasuimax() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70814))(this);
+                                               0x2F449FC))(this);
         }
 
         template <typename T = std::int32_t> T get_intmin() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C7081C))(this);
+                                               0x2F44A04))(this);
         }
 
         template <typename T = std::int32_t> T get_intmax() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C708D0))(this);
+                                               0x2F44AB8))(this);
         }
 
         template <typename T = std::int32_t> T get_intuimin() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70984))(this);
+                                               0x2F44B6C))(this);
         }
 
         template <typename T = std::int32_t> T get_intuimax() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70A38))(this);
+                                               0x2F44C20))(this);
         }
 
         template <typename T = float> T get_floatmin() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70AEC))(this);
+                                               0x2F44CD4))(this);
         }
 
         template <typename T = float> T get_floatmax() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70AF4))(this);
+                                               0x2F44CDC))(this);
         }
 
         template <typename T = float> T get_floatuimin() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70AFC))(this);
+                                               0x2F44CE4))(this);
         }
 
         template <typename T = float> T get_floatuimax() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70B04))(this);
+                                               0x2F44CEC))(this);
         }
 
         template <typename T = bool> T iscontainer() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70B0C))(this);
+                                               0x2F44CF4))(this);
         }
 
         template <typename T = bool> T ismultiparam() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70BAC))(this);
+                                               0x2F44D94))(this);
         }
 
         template <typename T = bool> T isramp() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70BBC))(this);
+                                               0x2F44DA4))(this);
         }
 
         template <typename T = bool> T istoggle() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C6E798))(this);
+                                               0x2F42980))(this);
         }
 
         template <typename T = bool> T iscolor() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70534))(this);
+                                               0x2F4471C))(this);
         }
 
         template <typename T = il2cpp_vec3> T tovector3() {
             return ((T(*)(heuparameterdata *))(il2cpp::il2cpp_base() +
-                                               0x2C70BD0))(this);
+                                               0x2F44DB8))(this);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_parametermodifier.h

@@ -29,7 +29,7 @@ namespace houdiniengineunity {
                                 std::int32_t _instanceindex,
                                 std::int32_t _modifiervalue) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t, std::int32_t,
-                          std::int32_t))(il2cpp::il2cpp_base() + 0x2C70C80))(
+                          std::int32_t))(il2cpp::il2cpp_base() + 0x2F44E68))(
                 0, _action, _parameterindex, _instanceindex, _modifiervalue);
         }
     };

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_parameters.h

@@ -59,50 +59,50 @@ namespace houdiniengineunity {
         }
 
         template <typename T = bool> T get_requiresregeneration() {
-            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2C449CC))(
+            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2F18D18))(
                 this);
         }
 
         template <typename T = void> T set_requiresregeneration(bool _value) {
             return ((T(*)(heuparameters *, bool))(il2cpp::il2cpp_base() +
-                                                  0x2C70E6C))(this, _value);
+                                                  0x2F45054))(this, _value);
         }
 
         template <typename T = il2cpp_array<std::uintptr_t> *>
         T getpresetdata() {
-            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2C5B410))(
+            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2F2F120))(
                 this);
         }
 
         template <typename T = void>
         T setpresetdata(il2cpp_array<std::uintptr_t> *_data) {
             return ((T(*)(heuparameters *, il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C5B418))(this, _data);
+                il2cpp::il2cpp_base() + 0x2F2F128))(this, _data);
         }
 
         template <typename T = il2cpp_array<std::uintptr_t> *>
         T getdefaultpresetdata() {
-            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2C70E74))(
+            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2F4505C))(
                 this);
         }
 
         template <typename T = bool> T areparametersvalid() {
-            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2C70E7C))(
+            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2F45064))(
                 this);
         }
 
         template <typename T = bool> T get_recacheui() {
-            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2C70E84))(
+            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2F4506C))(
                 this);
         }
 
         template <typename T = void> T set_recacheui(bool _value) {
             return ((T(*)(heuparameters *, bool))(il2cpp::il2cpp_base() +
-                                                  0x2C70E8C))(this, _value);
+                                                  0x2F45074))(this, _value);
         }
 
         template <typename T = void> T cleanup() {
-            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2C498AC))(
+            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2F1DF44))(
                 this);
         }
 
@@ -118,7 +118,7 @@ namespace houdiniengineunity {
                           std::uintptr_t,
                           il2cpp_dict<il2cpp_string *, std::uintptr_t> *,
                           il2cpp_dict<il2cpp_string *, std::uintptr_t> *,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C4A1E8))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F1E880))(
                 this, _session, _nodeid, _nodeinfo, _previousparamfolders,
                 _previousparaminputnodes, _parentasset);
         }
@@ -126,54 +126,54 @@ namespace houdiniengineunity {
         template <typename T = void>
         T setuprampparameter(std::uintptr_t _rampparameter) {
             return ((T(*)(heuparameters *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C70E9C))(this, _rampparameter);
+                il2cpp::il2cpp_base() + 0x2F45084))(this, _rampparameter);
         }
 
         template <typename T = std::uintptr_t>
         T getparameter(std::int32_t _listindex) {
             return ((T(*)(heuparameters *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C3A50C))(this, _listindex);
+                il2cpp::il2cpp_base() + 0x2F0E3B4))(this, _listindex);
         }
 
         template <typename T = std::uintptr_t>
         T getparameter_1(il2cpp_string *_name) {
             return ((T(*)(heuparameters *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C66E38))(this, _name);
+                il2cpp::il2cpp_base() + 0x2F3AF3C))(this, _name);
         }
 
         template <typename T = std::uintptr_t>
         T getparameterwithparmid(std::int32_t _parmid) {
             return ((T(*)(heuparameters *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C3A290))(this, _parmid);
+                il2cpp::il2cpp_base() + 0x2F0E138))(this, _parmid);
         }
 
         template <typename T = void>
         T removeparameter(std::int32_t _listindex) {
             return ((T(*)(heuparameters *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C713C4))(this, _listindex);
+                il2cpp::il2cpp_base() + 0x2F455AC))(this, _listindex);
         }
 
         template <typename T = std::int32_t>
         T getchosenindexfromchoicelist(std::uintptr_t _inchoiceparameter) {
             return ((T(*)(heuparameters *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C714A4))(this, _inchoiceparameter);
+                il2cpp::il2cpp_base() + 0x2F4568C))(this, _inchoiceparameter);
         }
 
         template <typename T = il2cpp_string *>
         T getstringfromparameter(il2cpp_string *_paramname) {
             return ((T(*)(heuparameters *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C7160C))(this, _paramname);
+                il2cpp::il2cpp_base() + 0x2F457F4))(this, _paramname);
         }
 
         template <typename T = void>
         T setstringtoparameter(il2cpp_string *_paramname,
                                il2cpp_string *_value) {
             return ((T(*)(heuparameters *, il2cpp_string *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C7166C))(this, _paramname, _value);
+                il2cpp::il2cpp_base() + 0x2F45854))(this, _paramname, _value);
         }
 
         template <typename T = bool> T haveparameterschanged() {
-            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2C48874))(
+            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2F1CEEC))(
                 this);
         }
 
@@ -181,7 +181,7 @@ namespace houdiniengineunity {
         T uploadvaluestohoudini(std::uintptr_t _session,
                                 std::uintptr_t _parentasset, bool _bdocheck) {
             return ((T(*)(heuparameters *, std::uintptr_t, std::uintptr_t,
-                          bool))(il2cpp::il2cpp_base() + 0x2C4538C))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F197F0))(
                 this, _session, _parentasset, _bdocheck);
         }
 
@@ -190,7 +190,7 @@ namespace houdiniengineunity {
                                     std::int32_t _instanceindex,
                                     std::int32_t _numinstancestoadd) {
             return ((T(*)(heuparameters *, std::int32_t, std::int32_t,
-                          std::int32_t))(il2cpp::il2cpp_base() + 0x2C716F0))(
+                          std::int32_t))(il2cpp::il2cpp_base() + 0x2F458D8))(
                 this, _unityparamindex, _instanceindex, _numinstancestoadd);
         }
 
@@ -199,25 +199,25 @@ namespace houdiniengineunity {
                                        std::int32_t _instanceindex,
                                        std::int32_t _numinstancestoremove) {
             return ((T(*)(heuparameters *, std::int32_t, std::int32_t,
-                          std::int32_t))(il2cpp::il2cpp_base() + 0x2C717B8))(
+                          std::int32_t))(il2cpp::il2cpp_base() + 0x2F459A0))(
                 this, _unityparamindex, _instanceindex, _numinstancestoremove);
         }
 
         template <typename T = void>
         T clearinstancesfrommultiparm(std::int32_t _unityparamindex) {
             return ((T(*)(heuparameters *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C71880))(this, _unityparamindex);
+                il2cpp::il2cpp_base() + 0x2F45A68))(this, _unityparamindex);
         }
 
         template <typename T = bool> T hasmodifierspending() {
-            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2C449D4))(
+            return ((T(*)(heuparameters *))(il2cpp::il2cpp_base() + 0x2F18D20))(
                 this);
         }
 
         template <typename T = void>
         T processmodifiers(std::uintptr_t _session) {
             return ((T(*)(heuparameters *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C44A7C))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F18DC8))(this, _session);
         }
 
         template <typename T = void>
@@ -227,7 +227,7 @@ namespace houdiniengineunity {
             return ((T(*)(heuparameters *,
                           il2cpp_dict<il2cpp_string *, std::uintptr_t> *,
                           il2cpp_dict<il2cpp_string *, std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C49FBC))(this, _folderparams,
+                il2cpp::il2cpp_base() + 0x2F1E654))(this, _folderparams,
                                                     _inputnodeparams);
         }
 
@@ -235,25 +235,25 @@ namespace houdiniengineunity {
         T getinputnodeconnectionobjects(
             il2cpp_list<std::uintptr_t> *_inputnodeobjects) {
             return ((T(*)(heuparameters *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C52F94))(this, _inputnodeobjects);
+                il2cpp::il2cpp_base() + 0x2F27828))(this, _inputnodeobjects);
         }
 
         template <typename T = void>
         T downloadpresetdata(std::uintptr_t _session) {
             return ((T(*)(heuparameters *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C4C9D8))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F210C4))(this, _session);
         }
 
         template <typename T = void>
         T uploadpresetdata(std::uintptr_t _session) {
             return ((T(*)(heuparameters *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C4CA38))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F2113C))(this, _session);
         }
 
         template <typename T = void>
         T downloadasdefaultpresetdata(std::uintptr_t _session) {
             return ((T(*)(heuparameters *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C423F8))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F16694))(this, _session);
         }
 
         template <typename T = void>
@@ -261,7 +261,7 @@ namespace houdiniengineunity {
                                 std::uintptr_t _parentasset,
                                 bool _bforceupdate) {
             return ((T(*)(heuparameters *, std::uintptr_t, std::uintptr_t,
-                          bool))(il2cpp::il2cpp_base() + 0x2C4CA9C))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F211B8))(
                 this, _session, _parentasset, _bforceupdate);
         }
 
@@ -269,7 +269,7 @@ namespace houdiniengineunity {
         T updatetransformparameters(std::uintptr_t _session,
                                     std::uintptr_t _hapitransform) {
             return ((T(*)(heuparameters *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C71944))(this, _session,
+                il2cpp::il2cpp_base() + 0x2F45B2C))(this, _session,
                                                     _hapitransform);
         }
 
@@ -277,20 +277,20 @@ namespace houdiniengineunity {
         T syncparameterfromhoudini(std::uintptr_t _session,
                                    il2cpp_string *_parametername) {
             return ((T(*)(heuparameters *, std::uintptr_t, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C71A08))(this, _session,
+                il2cpp::il2cpp_base() + 0x2F45BF0))(this, _session,
                                                     _parametername);
         }
 
         template <typename T = void>
         T syncinternalparametersforundocompare(std::uintptr_t _session) {
             return ((T(*)(heuparameters *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C5C8C8))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F305D8))(this, _session);
         }
 
         template <typename T = void>
         T resetalltodefault(std::uintptr_t _session) {
             return ((T(*)(heuparameters *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C5BA90))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F2F7A0))(this, _session);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_parameterutility.h

@@ -11,7 +11,7 @@ namespace houdiniengineunity {
                                   il2cpp_string *_parametername) {
             return (
                 (T(*)(void *, std::uintptr_t, il2cpp_array<std::uintptr_t> *,
-                      il2cpp_string *))(il2cpp::il2cpp_base() + 0x2C71ACC))(
+                      il2cpp_string *))(il2cpp::il2cpp_base() + 0x2F45CD8))(
                 0, _session, _parameters, _parametername);
         }
 
@@ -22,7 +22,7 @@ namespace houdiniengineunity {
             il2cpp_string *_parametername) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t,
                           il2cpp_array<std::uintptr_t> *,
-                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2C68C08))(
+                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2F3D020))(
                 0, _session, _nodeid, _parameters, _parametername);
         }
 
@@ -34,7 +34,7 @@ namespace houdiniengineunity {
                                float _defaultvalue) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t,
                           il2cpp_array<std::uintptr_t> *, il2cpp_string *,
-                          float))(il2cpp::il2cpp_base() + 0x2C69398))(
+                          float))(il2cpp::il2cpp_base() + 0x2F3D7F4))(
                 0, _session, _nodeid, _parameters, _parametername,
                 _defaultvalue);
         }
@@ -47,7 +47,7 @@ namespace houdiniengineunity {
                                 std::uintptr_t _defaultvalue) {
             return ((T(*)(void *, std::uintptr_t, std::int32_t,
                           il2cpp_array<std::uintptr_t> *, il2cpp_string *,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C69508))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F3D978))(
                 0, _session, _nodeid, _parameters, _parametername,
                 _defaultvalue);
         }

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_partdata.h

@@ -67,93 +67,93 @@ namespace houdiniengineunity {
         }
 
         template <typename T = std::int32_t> T get_partid() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C33F10))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F07CAC))(
                 this);
         }
 
         template <typename T = il2cpp_string *> T get_partname() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C32F84))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F06D10))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_parentgeonode() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C6BBBC))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F3FCF4))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_parentasset() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C71CAC))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F45EB8))(
                 this);
         }
 
         template <typename T = bool> T ispartinstancer() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C35C98))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F09AC4))(
                 this);
         }
 
         template <typename T = bool> T ispartinstanced() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C34EB8))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F08C54))(
                 this);
         }
 
         template <typename T = std::int32_t> T getpartpointcount() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C71D88))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F45F94))(
                 this);
         }
 
         template <typename T = bool> T isobjectinstancer() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C71D90))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F45F9C))(
                 this);
         }
 
         template <typename T = bool> T get_objectinstancesbeengenerated() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C6C1DC))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F40314))(
                 this);
         }
 
         template <typename T = void>
         T set_objectinstancesbeengenerated(bool _value) {
             return ((T(*)(heupartdata *, bool))(il2cpp::il2cpp_base() +
-                                                0x2C36B54))(this, _value);
+                                                0x2F0AA0C))(this, _value);
         }
 
         template <typename T = bool> T ispartvolume() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C35070))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F08E0C))(
                 this);
         }
 
         template <typename T = bool> T ispartcurve() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C34EC8))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F08C64))(
                 this);
         }
 
         template <typename T = bool> T ispartmesh() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C35060))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F08DFC))(
                 this);
         }
 
         template <typename T = bool> T isparteditable() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C71D98))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F45FA4))(
                 this);
         }
 
         template <typename T = bool> T haveinstancesbeengenerated() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C35CAC))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F09AD8))(
                 this);
         }
 
         template <typename T = std::int32_t> T get_meshvertexcount() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C71DA0))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F45FAC))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_generatedoutput() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C71DA8))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F45FB4))(
                 this);
         }
 
         template <typename T = std::uintptr_t> T get_outputgameobject() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C33EE0))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F07C7C))(
                 this);
         }
 
@@ -165,7 +165,7 @@ namespace houdiniengineunity {
             return ((T(*)(heupartdata *, std::uintptr_t, std::int32_t,
                           std::int32_t, std::int32_t, std::uintptr_t,
                           std::uintptr_t, std::uintptr_t,
-                          bool))(il2cpp::il2cpp_base() + 0x2C340B8))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F07E54))(
                 this, _session, _partid, _geoid, _objectnodeid, _geonode,
                 _partinfo, _partoutputtype, _iseditable);
         }
@@ -173,110 +173,110 @@ namespace houdiniengineunity {
         template <typename T = void>
         T setgameobjectname(il2cpp_string *_partname) {
             return ((T(*)(heupartdata *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C34A08))(this, _partname);
+                il2cpp::il2cpp_base() + 0x2F087A4))(this, _partname);
         }
 
         template <typename T = void>
         T setgameobject(std::uintptr_t _gameobject) {
             return ((T(*)(heupartdata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C34E88))(this, _gameobject);
+                il2cpp::il2cpp_base() + 0x2F08C24))(this, _gameobject);
         }
 
         template <typename T = void> T destroyalldata() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C71DB0))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F45FBC))(
                 this);
         }
 
         template <typename T = void>
         T applyhapitransform(std::uintptr_t _hapitransform) {
             return ((T(*)(heupartdata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C36E88))(this, _hapitransform);
+                il2cpp::il2cpp_base() + 0x2F0AD58))(this, _hapitransform);
         }
 
         template <typename T = void> T getdebuginfo(std::uintptr_t _sb) {
             return ((T(*)(heupartdata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C374C0))(this, _sb);
+                il2cpp::il2cpp_base() + 0x2F0B390))(this, _sb);
         }
 
         template <typename T = bool>
         T isusingmaterial(std::uintptr_t _materialdata) {
             return ((T(*)(heupartdata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C379B4))(this, _materialdata);
+                il2cpp::il2cpp_base() + 0x2F0B884))(this, _materialdata);
         }
 
         template <typename T = void>
         T getclonableobjects(il2cpp_list<std::uintptr_t> *_clonableobjects) {
             return ((T(*)(heupartdata *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C720D0))(this, _clonableobjects);
+                il2cpp::il2cpp_base() + 0x2F462DC))(this, _clonableobjects);
         }
 
         template <typename T = void>
         T getclonableparts(il2cpp_list<std::uintptr_t> *_clonableparts) {
             return ((T(*)(heupartdata *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C37B7C))(this, _clonableparts);
+                il2cpp::il2cpp_base() + 0x2F0BA4C))(this, _clonableparts);
         }
 
         template <typename T = void>
         T getoutputgameobjects(il2cpp_list<std::uintptr_t> *_outputobjects) {
             return ((T(*)(heupartdata *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C37E20))(this, _outputobjects);
+                il2cpp::il2cpp_base() + 0x2F0BCF0))(this, _outputobjects);
         }
 
         template <typename T = void>
         T getoutput(il2cpp_list<std::uintptr_t> *_outputs) {
             return ((T(*)(heupartdata *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C380CC))(this, _outputs);
+                il2cpp::il2cpp_base() + 0x2F0BF9C))(this, _outputs);
         }
 
         template <typename T = std::uintptr_t>
         T gethdapartwithgameobject(std::uintptr_t _ingameobject) {
             return ((T(*)(heupartdata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C383A8))(this, _ingameobject);
+                il2cpp::il2cpp_base() + 0x2F0C278))(this, _ingameobject);
         }
 
         template <typename T = void>
         T setobjectinstancer(bool _bobjectinstancer) {
             return ((T(*)(heupartdata *, bool))(
-                il2cpp::il2cpp_base() + 0x2C721E8))(this, _bobjectinstancer);
+                il2cpp::il2cpp_base() + 0x2F463F4))(this, _bobjectinstancer);
         }
 
         template <typename T = void> T clearinstances() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C6C1E4))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F4031C))(
                 this);
         }
 
         template <typename T = void> T clearobjectinstanceinfos() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C71F9C))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F461A8))(
                 this);
         }
 
         template <typename T = void> T clearinvalidobjectinstanceinfos() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C6C320))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F40458))(
                 this);
         }
 
         template <typename T = void> T cleargenerateddata() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C32F94))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F06D20))(
                 this);
         }
 
         template <typename T = void>
         T exportcustominstance(std::uintptr_t _session) {
             return ((T(*)(heupartdata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C352E0))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F0907C))(this, _session);
         }
 
         template <typename T = void>
         T generatepartinstances(std::uintptr_t _session) {
             return ((T(*)(heupartdata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C35CB4))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F09AE0))(this, _session);
         }
 
         template <typename T = void>
         T generateinstancesfromobjectid(std::uintptr_t _session,
                                         std::int32_t _objectnodeid) {
             return ((T(*)(heupartdata *, std::uintptr_t, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C6DF04))(this, _session,
+                il2cpp::il2cpp_base() + 0x2F420C8))(this, _session,
                                                     _objectnodeid);
         }
 
@@ -284,21 +284,21 @@ namespace houdiniengineunity {
         T generateinstancesfromobject(std::uintptr_t _session,
                                       std::uintptr_t _sourceobject) {
             return ((T(*)(heupartdata *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C72AAC))(this, _session,
+                il2cpp::il2cpp_base() + 0x2F46D14))(this, _session,
                                                     _sourceobject);
         }
 
         template <typename T = void>
         T generateinstancesfromobjectids(std::uintptr_t _session) {
             return ((T(*)(heupartdata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C6C624))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F4075C))(this, _session);
         }
 
         template <typename T = void>
         T generateinstancesfromunityassetpathattribute(
             std::uintptr_t _session, il2cpp_string *_unityinstanceattr) {
             return ((T(*)(heupartdata *, std::uintptr_t, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C6CDE4))(this, _session,
+                il2cpp::il2cpp_base() + 0x2F40F4C))(this, _session,
                                                     _unityinstanceattr);
         }
 
@@ -306,7 +306,7 @@ namespace houdiniengineunity {
         T generateinstancesfromunityassetpath(std::uintptr_t _session,
                                               il2cpp_string *_assetpath) {
             return ((T(*)(heupartdata *, std::uintptr_t, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C6D8CC))(this, _session, _assetpath);
+                il2cpp::il2cpp_base() + 0x2F41A70))(this, _session, _assetpath);
         }
 
         template <typename T = void>
@@ -321,7 +321,7 @@ namespace houdiniengineunity {
             return ((T(*)(heupartdata *, std::uintptr_t, std::int32_t,
                           std::uintptr_t, std::uintptr_t, std::int32_t,
                           il2cpp_string *, il2cpp_vec3,
-                          il2cpp_vec3))(il2cpp::il2cpp_base() + 0x2C72638))(
+                          il2cpp_vec3))(il2cpp::il2cpp_base() + 0x2F468A0))(
                 this, _sourceobject, _instanceindex, _parenttransform,
                 _hapitransform, _instancedobjectnodeid, _instancedobjectpath,
                 _rotationoffset, _scaleoffset);
@@ -329,29 +329,29 @@ namespace houdiniengineunity {
 
         template <typename T = std::uintptr_t> T getcurve(bool _beditableonly) {
             return ((T(*)(heupartdata *, bool))(
-                il2cpp::il2cpp_base() + 0x2C38878))(this, _beditableonly);
+                il2cpp::il2cpp_base() + 0x2F0C748))(this, _beditableonly);
         }
 
         template <typename T = void> T setvisiblity(bool _bvisibility) {
             return ((T(*)(heupartdata *, bool))(il2cpp::il2cpp_base() +
-                                                0x2C38C58))(this, _bvisibility);
+                                                0x2F0CB28))(this, _bvisibility);
         }
 
         template <typename T = void>
         T calculatevisibility(bool _bparentvisibility,
                               bool _bparentdisplaygeo) {
             return ((T(*)(heupartdata *, bool, bool))(
-                il2cpp::il2cpp_base() + 0x2C38B34))(this, _bparentvisibility,
+                il2cpp::il2cpp_base() + 0x2F0CA04))(this, _bparentvisibility,
                                                     _bparentdisplaygeo);
         }
 
         template <typename T = void> T setcolliderstate(bool _benabled) {
             return ((T(*)(heupartdata *, bool))(il2cpp::il2cpp_base() +
-                                                0x2C393C0))(this, _benabled);
+                                                0x2F0D290))(this, _benabled);
         }
 
         template <typename T = void> T calculatecolliderstate() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C38F8C))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F0CE5C))(
                 this);
         }
 
@@ -371,7 +371,7 @@ namespace houdiniengineunity {
                           il2cpp_dict<std::uintptr_t, std::uintptr_t> *,
                           il2cpp_dict<std::uintptr_t, std::uintptr_t> *, bool,
                           std::uintptr_t, std::uintptr_t, il2cpp_string *, bool,
-                          bool))(il2cpp::il2cpp_base() + 0x2C73040))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F472C4))(
                 this, _sourcego, _targetgo, _assetname, _sourcetotargetmeshmap,
                 _sourcetocopiedmaterials, _bwritemeshestoassetdatabase,
                 _bakedassetpath, _assetdbobject, _assetobjectfilename,
@@ -394,7 +394,7 @@ namespace houdiniengineunity {
                           il2cpp_dict<std::uintptr_t, std::uintptr_t> *,
                           il2cpp_dict<std::uintptr_t, std::uintptr_t> *, bool,
                           std::uintptr_t, std::uintptr_t, il2cpp_string *, bool,
-                          bool))(il2cpp::il2cpp_base() + 0x2C74838))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F48ABC))(
                 this, _sourcego, _targetgo, _assetname, _sourcetotargetmeshmap,
                 _sourcetocopiedmaterials, _bwritemeshestoassetdatabase,
                 _bakedassetpath, _assetdbobject, _assetobjectfilename,
@@ -414,7 +414,7 @@ namespace houdiniengineunity {
                           il2cpp_dict<std::uintptr_t, std::uintptr_t> *,
                           il2cpp_dict<std::uintptr_t, std::uintptr_t> *,
                           std::uintptr_t, il2cpp_string *,
-                          bool))(il2cpp::il2cpp_base() + 0x2C50C18))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F25498))(
                 this, _parenttransform, _bwritemeshestoassetdatabase,
                 _bakedassetpath, _sourcetotargetmeshmap,
                 _sourcetocopiedmaterials, _assetdbobject, _assetobjectfilename,
@@ -435,7 +435,7 @@ namespace houdiniengineunity {
                 heupartdata *, std::uintptr_t, bool, bool, bool, std::uintptr_t,
                 il2cpp_dict<std::uintptr_t, std::uintptr_t> *,
                 il2cpp_dict<std::uintptr_t, std::uintptr_t> *, std::uintptr_t,
-                il2cpp_string *, bool))(il2cpp::il2cpp_base() + 0x2C5257C))(
+                il2cpp_string *, bool))(il2cpp::il2cpp_base() + 0x2F26E10))(
                 this, _targetgo, _bdeleteexistingcomponents,
                 _bdontdeletepersistantresources, _bwritemeshestoassetdatabase,
                 _bakedassetpath, _sourcetotargetmeshmap,
@@ -448,7 +448,7 @@ namespace houdiniengineunity {
                        bool _bgeneratetangents, bool _bgeneratenormals,
                        bool _buselodgroups) {
             return ((T(*)(heupartdata *, std::uintptr_t, bool, bool, bool,
-                          bool))(il2cpp::il2cpp_base() + 0x2C6B758))(
+                          bool))(il2cpp::il2cpp_base() + 0x2F3F8F8))(
                 this, _session, _bgenerateuvs, _bgeneratetangents,
                 _bgeneratenormals, _buselodgroups);
         }
@@ -456,25 +456,25 @@ namespace houdiniengineunity {
         template <typename T = void>
         T processcurvepart(std::uintptr_t _session) {
             return ((T(*)(heupartdata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C344DC))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F08278))(this, _session);
         }
 
         template <typename T = void>
         T syncattributesstore(std::uintptr_t _session, std::int32_t _geoid,
                               std::uintptr_t _partinfo) {
             return ((T(*)(heupartdata *, std::uintptr_t, std::int32_t,
-                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2C34B70))(
+                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x2F0890C))(
                 this, _session, _geoid, _partinfo);
         }
 
         template <typename T = void>
         T setupattributegeometry(std::uintptr_t _session) {
             return ((T(*)(heupartdata *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C6BD58))(this, _session);
+                il2cpp::il2cpp_base() + 0x2F3FE90))(this, _session);
         }
 
         template <typename T = void> T destroyattributesstore() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C34D18))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F08AB4))(
                 this);
         }
 
@@ -482,20 +482,20 @@ namespace houdiniengineunity {
         T populateobjectinstanceinfos(
             il2cpp_list<std::uintptr_t> *_objinstanceinfos) {
             return ((T(*)(heupartdata *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C6E3F0))(this, _objinstanceinfos);
+                il2cpp::il2cpp_base() + 0x2F425D8))(this, _objinstanceinfos);
         }
 
         template <typename T = void>
         T setobjectinstanceinfos(
             il2cpp_list<std::uintptr_t> *_sourceobjectinstanceinfos) {
             return ((T(*)(heupartdata *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C33A80))(this,
+                il2cpp::il2cpp_base() + 0x2F0781C))(this,
                                                     _sourceobjectinstanceinfos);
         }
 
         template <typename T = il2cpp_list<std::uintptr_t> *>
         T getobjectinstanceinfos() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C32F8C))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F06D18))(
                 this);
         }
 
@@ -504,7 +504,7 @@ namespace houdiniengineunity {
                                    std::int32_t _instancedobjectnodeid,
                                    il2cpp_string *_instancedobjectpath) {
             return ((T(*)(heupartdata *, std::uintptr_t, std::int32_t,
-                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2C72EF8))(
+                          il2cpp_string *))(il2cpp::il2cpp_base() + 0x2F4717C))(
                 this, _instancedobject, _instancedobjectnodeid,
                 _instancedobjectpath);
         }
@@ -512,51 +512,51 @@ namespace houdiniengineunity {
         template <typename T = std::uintptr_t>
         T getobjectinstanceinfowithobjectpath(il2cpp_string *_path) {
             return ((T(*)(heupartdata *, il2cpp_string *))(
-                il2cpp::il2cpp_base() + 0x2C72DB4))(this, _path);
+                il2cpp::il2cpp_base() + 0x2F47038))(this, _path);
         }
 
         template <typename T = std::uintptr_t>
         T getobjectinstanceinfowithobjectid(std::int32_t _objnodeid) {
             return ((T(*)(heupartdata *, std::int32_t))(
-                il2cpp::il2cpp_base() + 0x2C724FC))(this, _objnodeid);
+                il2cpp::il2cpp_base() + 0x2F46764))(this, _objnodeid);
         }
 
         template <typename T = void>
         T setterrainpart(std::uintptr_t _terraindataobject,
                          il2cpp_vec3 _offsetposition) {
             return ((T(*)(heupartdata *, std::uintptr_t, il2cpp_vec3))(
-                il2cpp::il2cpp_base() + 0x2C74B98))(this, _terraindataobject,
+                il2cpp::il2cpp_base() + 0x2F48E1C))(this, _terraindataobject,
                                                     _offsetposition);
         }
 
         template <typename T = il2cpp_string *>
         static T appendbakedclonename(il2cpp_string *_name) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C52BAC))(0, _name);
+                                                    0x2F27440))(0, _name);
         }
 
         template <typename T = il2cpp_string *> T tostring() {
-            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2C74BB0))(
+            return ((T(*)(heupartdata *))(il2cpp::il2cpp_base() + 0x2F48E34))(
                 this);
         }
 
         template <typename T = void>
         static T destroyparts(il2cpp_list<std::uintptr_t> *_parts) {
             return ((T(*)(void *, il2cpp_list<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C31AB0))(0, _parts);
+                il2cpp::il2cpp_base() + 0x2F05A3C))(0, _parts);
         }
 
         template <typename T = void>
         static T destroypart(std::uintptr_t _part) {
             return ((T(*)(void *, std::uintptr_t))(il2cpp::il2cpp_base() +
-                                                   0x2C31F58))(0, _part);
+                                                   0x2F05F20))(0, _part);
         }
 
         template <typename T = std::int32_t>
         static T copygameobjectcomponentsm__0(std::uintptr_t _a,
                                               std::uintptr_t _b) {
             return ((T(*)(void *, std::uintptr_t, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C74CD4))(0, _a, _b);
+                il2cpp::il2cpp_base() + 0x2F48F58))(0, _a, _b);
         }
     };
 

ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/heu_platform.h

@@ -5,60 +5,60 @@ namespace houdiniengineunity {
     class heuplatform {
       public:
         template <typename T = il2cpp_string *> static T get_libpath() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2C74D58))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2F48FDC))(0);
         }
 
         template <typename T = bool> static T get_ispathset() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2C74E08))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2F4908C))(0);
         }
 
         template <typename T = il2cpp_string *>
         static T gethoudinienginepath() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2C74EB8))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2F4913C))(0);
         }
 
         template <typename T = void> static T sethoudinienginepath() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2C74D4C))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2F48FD0))(0);
         }
 
         template <typename T = il2cpp_string *>
         static T getallfoldersinpath(il2cpp_string *_path) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C74F88))(0, _path);
+                                                    0x2F4920C))(0, _path);
         }
 
         template <typename T = void>
         static T getallfoldersinpathhelper(il2cpp_string *_inpath,
                                            std::uintptr_t _pathbuilder) {
             return ((T(*)(void *, il2cpp_string *, std::uintptr_t))(
-                il2cpp::il2cpp_base() + 0x2C750E4))(0, _inpath, _pathbuilder);
+                il2cpp::il2cpp_base() + 0x2F4937C))(0, _inpath, _pathbuilder);
         }
 
         template <typename T = il2cpp_string *>
         static T getfilename(il2cpp_string *_path) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C552BC))(0, _path);
+                                                    0x2F291B8))(0, _path);
         }
 
         template <typename T = il2cpp_string *>
         static T getfilenamewithoutextension(il2cpp_string *_path) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C752A8))(0, _path);
+                                                    0x2F49554))(0, _path);
         }
 
         template <typename T = il2cpp_string *>
         static T getfolderpath(il2cpp_string *_path) {
             return ((T(*)(void *, il2cpp_string *))(il2cpp::il2cpp_base() +
-                                                    0x2C517A4))(0, _path);
+                                                    0x2F26024))(0, _path);
         }
 
         template <typename T = char> static T get_directoryseparator() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2C75350))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2F495FC))(0);
         }
 
         template <typename T = il2cpp_string *>
         static T get_directoryseparatorstr() {
-            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2C75358))(0);
+            return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x2F49604))(0);
         }
 
         template <typename T = il2cpp_string *>
@@ -66,44 +66,44 @@ namespace houdiniengineunity {
                            il2cpp_array<std::uintptr_t> *_args) {
             return ((T(*)(void *, il2cpp_string *, il2cpp_string *,
                           il2cpp_array<std::uintptr_t> *))(
-                il2cpp::il2cpp_base() + 0x2C51A70))(0, _folder1, _folder2,
+                il2cpp::il2cpp_base() + 0x2F262F0))(0, _folder1, _folder2,
                                                     _args);
         }
 
         template <typename T = il2cpp_string *>
         static T getvalidrelativepath(il2cpp_