Android_Reverse_Engineering
/
codm
6
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

added sdk back

Browse Source
master
xerox 4 years ago
parent 6023a2fc1d
commit f9498c3dc5
19947 changed files with 1335827 additions and 0 deletions
Show Stats Download Patch File Download Diff File

112
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/-.h
Unescape View File

@ -0,0 +1,112 @@
#include "includes/$arraytype=32.h"
#include "includes/activetodisabledc__iterator2.h"
#include "includes/activetokinematicc__iterator3.h"
#include "includes/alivetodeadc__iterator4.h"
#include "includes/animatorevent.h"
#include "includes/antialiasinglevel.h"
#include "includes/assetbuildaction.h"
#include "includes/assetcookresult.h"
#include "includes/assetcookstatus.h"
#include "includes/attributestate.h"
#include "includes/attributetype.h"
#include "includes/autodetectparams.h"
#include "includes/behaviourdelegate.h"
#include "includes/boneside.h"
#include "includes/bonetype.h"
#include "includes/buildtype.h"
#include "includes/chunk.h"
#include "includes/collidertype.h"
#include "includes/collisiondelegate.h"
#include "includes/collisionimpulsedelegate.h"
#include "includes/collisionresistancemultiplier.h"
#include "includes/createsessionfromtypedelegate.h"
#include "includes/cubemapdepth.h"
#include "includes/cubemaprendermethod.h"
#include "includes/cubemapresolution.h"
#include "includes/curvedrawcollision.h"
#include "includes/curveeditstate.h"
#include "includes/custominstancetype.h"
#include "includes/datatype.h"
#include "includes/delaydeadc__iterator0.h"
#include "includes/delayfreezec__iterator0.h"
#include "includes/disabledtoactivec__iterator0.h"
#include "includes/downscale.h"
#include "includes/exportalphamapexrpath.h"
#include "includes/fadeoutmuscleweightc__iterator2.h"
#include "includes/fadeoutpinweightc__iterator1.h"
#include "includes/fallparams.h"
#include "includes/fallparamsgroup.h"
#include "includes/finalrendercapturec__iterator0.h"
#include "includes/framerate.h"
#include "includes/getarray1argdel`1.h"
#include "includes/getarray2argdel`2.h"
#include "includes/getattributearrayinputfunc`1.h"
#include "includes/graphicsdebuggerclient.h"
#include "includes/group.h"
#include "includes/headdata.h"
#include "includes/heu_asseteventreceivertest.h"
#include "includes/heu_assettype.h"
#include "includes/heu_handleparamtype.h"
#include "includes/heu_handletype.h"
#include "includes/heu_importassetoptions.h"
#include "includes/heu_inputobjectuicache.h"
#include "includes/heu_layerattribute.h"
#include "includes/heu_replaceprefaboptions.h"
#include "includes/heu_scriptcallbackexample.h"
#include "includes/heu_scriptparameterexample.h"
#include "includes/heu_uploadmeshdata.h"
#include "includes/heu_uploadvolumedata.h"
#include "includes/hitdelegate.h"
#include "includes/humanoidmuscle.h"
#include "includes/initializec__anonstorey0.h"
#include "includes/inputactions.h"
#include "includes/inputnodetype.h"
#include "includes/inputobjecttype.h"
#include "includes/interaction.h"
#include "includes/kinematictoactivec__iterator1.h"
#include "includes/limborientation.h"
#include "includes/logger.h"
#include "includes/losebalancec__iterator0.h"
#include "includes/masterprops.h"
#include "includes/mode.h"
#include "includes/modifieraction.h"
#include "includes/module.h"
#include "includes/muscledelegate.h"
#include "includes/muscleprops.h"
#include "includes/musclepropsgroup.h"
#include "includes/normalmode.h"
#include "includes/outputextension.h"
#include "includes/outputpath.h"
#include "includes/outputtype.h"
#include "includes/paintmergemode.h"
#include "includes/parser.h"
#include "includes/partoutputtype.h"
#include "includes/pixelformat.h"
#include "includes/pluginevent.h"
#include "includes/postcapturesettings.h"
#include "includes/privateimplementationdetails.h"
#include "includes/props.h"
#include "includes/puppetevent.h"
#include "includes/puppetupdatelimit.h"
#include "includes/resolution.h"
#include "includes/serializer.h"
#include "includes/sessionconnectionstate.h"
#include "includes/setattributearrayfunc`1.h"
#include "includes/setattributevaluefunc.h"
#include "includes/settings.h"
#include "includes/smoothactivatec__iterator0.h"
#include "includes/smoothactivatec__iterator1.h"
#include "includes/source.h"
#include "includes/splatchannelname.h"
#include "includes/splatprototypedata.h"
#include "includes/state.h"
#include "includes/statesettings.h"
#include "includes/storedata.h"
#include "includes/storedataarray`1.h"
#include "includes/taskcallback.h"
#include "includes/taskresult.h"
#include "includes/taskstatus.h"
#include "includes/token.h"
#include "includes/updatedelegate.h"
#include "includes/updatemode.h"
#include "includes/updateuidelegate.h"

140
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/houdiniengineunity.h
Unescape View File

@ -0,0 +1,140 @@
#include "includes/houdiniengineunity/arrayextensions.h"
#include "includes/houdiniengineunity/bakedevent.h"
#include "includes/houdiniengineunity/cookedevent.h"
#include "includes/houdiniengineunity/hapi_assetinfo.h"
#include "includes/houdiniengineunity/hapi_attributeinfo.h"
#include "includes/houdiniengineunity/hapi_attributeowner.h"
#include "includes/houdiniengineunity/hapi_attributetypeinfo.h"
#include "includes/houdiniengineunity/hapi_boxinfo.h"
#include "includes/houdiniengineunity/hapi_cacheproperty.h"
#include "includes/houdiniengineunity/hapi_choicelisttype.h"
#include "includes/houdiniengineunity/hapi_cookoptions.h"
#include "includes/houdiniengineunity/hapi_curveinfo.h"
#include "includes/houdiniengineunity/hapi_curveorders.h"
#include "includes/houdiniengineunity/hapi_curvetype.h"
#include "includes/houdiniengineunity/hapi_envinttype.h"
#include "includes/houdiniengineunity/hapi_errorcode.h"
#include "includes/houdiniengineunity/hapi_geoinfo.h"
#include "includes/houdiniengineunity/hapi_geotype.h"
#include "includes/houdiniengineunity/hapi_grouptype.h"
#include "includes/houdiniengineunity/hapi_handlebindinginfo.h"
#include "includes/houdiniengineunity/hapi_handleinfo.h"
#include "includes/houdiniengineunity/hapi_imagedataformat.h"
#include "includes/houdiniengineunity/hapi_imagefileformat.h"
#include "includes/houdiniengineunity/hapi_imageinfo.h"
#include "includes/houdiniengineunity/hapi_imagepacking.h"
#include "includes/houdiniengineunity/hapi_inputtype.h"
#include "includes/houdiniengineunity/hapi_keyframe.h"
#include "includes/houdiniengineunity/hapi_license.h"
#include "includes/houdiniengineunity/hapi_materialinfo.h"
#include "includes/houdiniengineunity/hapi_nodeflags.h"
#include "includes/houdiniengineunity/hapi_nodeinfo.h"
#include "includes/houdiniengineunity/hapi_nodetype.h"
#include "includes/houdiniengineunity/hapi_objectinfo.h"
#include "includes/houdiniengineunity/hapi_packedpriminstancingmode.h"
#include "includes/houdiniengineunity/hapi_parmchoiceinfo.h"
#include "includes/houdiniengineunity/hapi_parminfo.h"
#include "includes/houdiniengineunity/hapi_parminput.h"
#include "includes/houdiniengineunity/hapi_parmtype.h"
#include "includes/houdiniengineunity/hapi_partinfo.h"
#include "includes/houdiniengineunity/hapi_parttype.h"
#include "includes/houdiniengineunity/hapi_pdg_cooktype.h"
#include "includes/houdiniengineunity/hapi_pdg_eventinfo.h"
#include "includes/houdiniengineunity/hapi_pdg_eventtype.h"
#include "includes/houdiniengineunity/hapi_pdg_state.h"
#include "includes/houdiniengineunity/hapi_pdg_workiteminfo.h"
#include "includes/houdiniengineunity/hapi_pdg_workitemresultinfo.h"
#include "includes/houdiniengineunity/hapi_pdg_workitemstate.h"
#include "includes/houdiniengineunity/hapi_permissions.h"
#include "includes/houdiniengineunity/hapi_presettype.h"
#include "includes/houdiniengineunity/hapi_ramptype.h"
#include "includes/houdiniengineunity/hapi_result.h"
#include "includes/houdiniengineunity/hapi_rstorder.h"
#include "includes/houdiniengineunity/hapi_session.h"
#include "includes/houdiniengineunity/hapi_sessionenvinttype.h"
#include "includes/houdiniengineunity/hapi_sessiontype.h"
#include "includes/houdiniengineunity/hapi_sphereinfo.h"
#include "includes/houdiniengineunity/hapi_state.h"
#include "includes/houdiniengineunity/hapi_statustype.h"
#include "includes/houdiniengineunity/hapi_statusverbosity.h"
#include "includes/houdiniengineunity/hapi_storagetype.h"
#include "includes/houdiniengineunity/hapi_thriftserveroptions.h"
#include "includes/houdiniengineunity/hapi_timelineoptions.h"
#include "includes/houdiniengineunity/hapi_transform.h"
#include "includes/houdiniengineunity/hapi_transformcomponent.h"
#include "includes/houdiniengineunity/hapi_transformeuler.h"
#include "includes/houdiniengineunity/hapi_volumeinfo.h"
#include "includes/houdiniengineunity/hapi_volumetileinfo.h"
#include "includes/houdiniengineunity/hapi_volumetype.h"
#include "includes/houdiniengineunity/hapi_xyzorder.h"
#include "includes/houdiniengineunity/heu_assetdatabase.h"
#include "includes/houdiniengineunity/heu_assetpreset.h"
#include "includes/houdiniengineunity/heu_assetpresetutility.h"
#include "includes/houdiniengineunity/heu_assettask.h"
#include "includes/houdiniengineunity/heu_assetupdater.h"
#include "includes/houdiniengineunity/heu_attributedata.h"
#include "includes/houdiniengineunity/heu_attributesstore.h"
#include "includes/houdiniengineunity/heu_curve.h"
#include "includes/houdiniengineunity/heu_defines.h"
#include "includes/houdiniengineunity/heu_editorutility.h"
#include "includes/houdiniengineunity/heu_generalutility.h"
#include "includes/houdiniengineunity/heu_generatedoutput.h"
#include "includes/houdiniengineunity/heu_generatedoutputdata.h"
#include "includes/houdiniengineunity/heu_generategeocache.h"
#include "includes/houdiniengineunity/heu_geogroup.h"
#include "includes/houdiniengineunity/heu_geometryutility.h"
#include "includes/houdiniengineunity/heu_geonode.h"
#include "includes/houdiniengineunity/heu_handle.h"
#include "includes/houdiniengineunity/heu_handleparambinding.h"
#include "includes/houdiniengineunity/heu_hapiimports.h"
#include "includes/houdiniengineunity/heu_hapiutility.h"
#include "includes/houdiniengineunity/heu_houdiniasset.h"
#include "includes/houdiniengineunity/heu_houdiniassetcliffcomponent.h"
#include "includes/houdiniengineunity/heu_houdiniassetfoliagecomponent.h"
#include "includes/houdiniengineunity/heu_houdiniassetinstancecomponent.h"
#include "includes/houdiniengineunity/heu_houdiniassetinstancedatabase.h"
#include "includes/houdiniengineunity/heu_houdiniassetinstanceoptions.h"
#include "includes/houdiniengineunity/heu_houdiniassetroot.h"
#include "includes/houdiniengineunity/heu_houdiniassetterraincomponent.h"
#include "includes/houdiniengineunity/heu_houdiniassetterrainoptions.h"
#include "includes/houdiniengineunity/heu_houdiniengineerror.h"
#include "includes/houdiniengineunity/heu_houdiniversion.h"
#include "includes/houdiniengineunity/heu_inputmeshutility.h"
#include "includes/houdiniengineunity/heu_inputnode.h"
#include "includes/houdiniengineunity/heu_inputnodeuicache.h"
#include "includes/houdiniengineunity/heu_inputobjectinfo.h"
#include "includes/houdiniengineunity/heu_inputvolumeutility.h"
#include "includes/houdiniengineunity/heu_instancedinput.h"
#include "includes/houdiniengineunity/heu_materialdata.h"
#include "includes/houdiniengineunity/heu_materialfactory.h"
#include "includes/houdiniengineunity/heu_meshdata.h"
#include "includes/houdiniengineunity/heu_objectinstanceinfo.h"
#include "includes/houdiniengineunity/heu_objectnode.h"
#include "includes/houdiniengineunity/heu_parameteraccessor.h"
#include "includes/houdiniengineunity/heu_parameterdata.h"
#include "includes/houdiniengineunity/heu_parametermodifier.h"
#include "includes/houdiniengineunity/heu_parameters.h"
#include "includes/houdiniengineunity/heu_parameterutility.h"
#include "includes/houdiniengineunity/heu_partdata.h"
#include "includes/houdiniengineunity/heu_platform.h"
#include "includes/houdiniengineunity/heu_platformwin.h"
#include "includes/houdiniengineunity/heu_pluginsettings.h"
#include "includes/houdiniengineunity/heu_pluginstorage.h"
#include "includes/houdiniengineunity/heu_serializabledictionary`2.h"
#include "includes/houdiniengineunity/heu_sessionbase.h"
#include "includes/houdiniengineunity/heu_sessiondata.h"
#include "includes/houdiniengineunity/heu_sessionhapi.h"
#include "includes/houdiniengineunity/heu_sessionmanager.h"
#include "includes/houdiniengineunity/heu_task.h"
#include "includes/houdiniengineunity/heu_taskmanager.h"
#include "includes/houdiniengineunity/heu_toolsinfo.h"
#include "includes/houdiniengineunity/heu_unitymaterialinfo.h"
#include "includes/houdiniengineunity/heu_vertexentry.h"
#include "includes/houdiniengineunity/heu_volumecache.h"
#include "includes/houdiniengineunity/heu_volumedata.h"
#include "includes/houdiniengineunity/instancedata.h"
#include "includes/houdiniengineunity/instanceinfo.h"
#include "includes/houdiniengineunity/instancetype.h"
#include "includes/houdiniengineunity/reloadevent.h"
#include "includes/houdiniengineunity/reversecompare.h"
#include "includes/houdiniengineunity/terrainbound.h"

6
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/$arraytype=32.h
Unescape View File

@ -0,0 +1,6 @@
#pragma once
#include <il2cpp/il2cpp.h>
class arraytype32 {
public:
};

51
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/activetodisabledc__iterator2.h
Unescape View File

@ -0,0 +1,51 @@
#pragma once
#include <il2cpp/il2cpp.h>
class activetodisabledciterator2 {
public:
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar0() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::int32_t> T &$locvar1() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = std::uintptr_t> T &$this() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::uintptr_t> T &$current() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = bool> T &$disposing() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = std::int32_t> T &$pc() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
template <typename T = bool> T movenext() {
return ((T(*)(activetodisabledciterator2 *))(il2cpp::il2cpp_base() +
0x39A56FC))(this);
}
template <typename T = std::uintptr_t>
T system_collections_generic_ienumeratorobject_get_current() {
return ((T(*)(activetodisabledciterator2 *))(il2cpp::il2cpp_base() +
0x39A58E8))(this);
}
template <typename T = std::uintptr_t>
T system_collections_ienumerator_get_current() {
return ((T(*)(activetodisabledciterator2 *))(il2cpp::il2cpp_base() +
0x39A58F0))(this);
}
template <typename T = void> T dispose() {
return ((T(*)(activetodisabledciterator2 *))(il2cpp::il2cpp_base() +
0x39A58F8))(this);
}
template <typename T = void> T reset() {
return ((T(*)(activetodisabledciterator2 *))(il2cpp::il2cpp_base() +
0x39A590C))(this);
}
};

57
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/activetokinematicc__iterator3.h
Unescape View File

@ -0,0 +1,57 @@
#pragma once
#include <il2cpp/il2cpp.h>
class activetokinematicciterator3 {
public:
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar0() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::int32_t> T &$locvar1() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar2() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &$locvar3() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = std::uintptr_t> T &$this() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = std::uintptr_t> T &$current() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
template <typename T = bool> T &$disposing() {
return *(T *)((std::uintptr_t)this + 0x20);
}
template <typename T = std::int32_t> T &$pc() {
return *(T *)((std::uintptr_t)this + 0x24);
}
template <typename T = bool> T movenext() {
return ((T(*)(activetokinematicciterator3 *))(il2cpp::il2cpp_base() +
0x39A59A0))(this);
}
template <typename T = std::uintptr_t>
T system_collections_generic_ienumeratorobject_get_current() {
return ((T(*)(activetokinematicciterator3 *))(il2cpp::il2cpp_base() +
0x39A5CE8))(this);
}
template <typename T = std::uintptr_t>
T system_collections_ienumerator_get_current() {
return ((T(*)(activetokinematicciterator3 *))(il2cpp::il2cpp_base() +
0x39A5CF0))(this);
}
template <typename T = void> T dispose() {
return ((T(*)(activetokinematicciterator3 *))(il2cpp::il2cpp_base() +
0x39A5CF8))(this);
}
template <typename T = void> T reset() {
return ((T(*)(activetokinematicciterator3 *))(il2cpp::il2cpp_base() +
0x39A5D0C))(this);
}
};

84
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/alivetodeadc__iterator4.h
Unescape View File

@ -0,0 +1,84 @@
#pragma once
#include <il2cpp/il2cpp.h>
class alivetodeadciterator4 {
public:
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar0() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::int32_t> T &$locvar1() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = float> T &range__0() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar2() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = std::int32_t> T &$locvar3() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = float> T &mw__1() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar4() {
return *(T *)((std::uintptr_t)this + 0x20);
}
template <typename T = std::int32_t> T &$locvar5() {
return *(T *)((std::uintptr_t)this + 0x24);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar6() {
return *(T *)((std::uintptr_t)this + 0x28);
}
template <typename T = std::int32_t> T &$locvar7() {
return *(T *)((std::uintptr_t)this + 0x2C);
}
template <typename T = bool> T &freeze() {
return *(T *)((std::uintptr_t)this + 0x30);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar8() {
return *(T *)((std::uintptr_t)this + 0x34);
}
template <typename T = std::int32_t> T &$locvar9() {
return *(T *)((std::uintptr_t)this + 0x38);
}
template <typename T = std::uintptr_t> T &$this() {
return *(T *)((std::uintptr_t)this + 0x3C);
}
template <typename T = std::uintptr_t> T &$current() {
return *(T *)((std::uintptr_t)this + 0x40);
}
template <typename T = bool> T &$disposing() {
return *(T *)((std::uintptr_t)this + 0x44);
}
template <typename T = std::int32_t> T &$pc() {
return *(T *)((std::uintptr_t)this + 0x48);
}
template <typename T = bool> T movenext() {
return ((T(*)(alivetodeadciterator4 *))(il2cpp::il2cpp_base() +
0x39A5DA0))(this);
}
template <typename T = std::uintptr_t>
T system_collections_generic_ienumeratorobject_get_current() {
return ((T(*)(alivetodeadciterator4 *))(il2cpp::il2cpp_base() +
0x39A6348))(this);
}
template <typename T = std::uintptr_t>
T system_collections_ienumerator_get_current() {
return ((T(*)(alivetodeadciterator4 *))(il2cpp::il2cpp_base() +
0x39A6350))(this);
}
template <typename T = void> T dispose() {
return ((T(*)(alivetodeadciterator4 *))(il2cpp::il2cpp_base() +
0x39A6358))(this);
}
template <typename T = void> T reset() {
return ((T(*)(alivetodeadciterator4 *))(il2cpp::il2cpp_base() +
0x39A636C))(this);
}
};

34
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/animatorevent.h
Unescape View File

@ -0,0 +1,34 @@
#pragma once
#include <il2cpp/il2cpp.h>
class animatorevent {
public:
template <typename T = il2cpp_string *> T &animationstate() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = float> T &crossfadetime() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = std::int32_t> T &layer() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = bool> T &resetnormalizedtime() {
return *(T *)((std::uintptr_t)this + 0x14);
}
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);
}
template <typename T = void> T activate_1(std::uintptr_t _animator) {
return ((T(*)(animatorevent *, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x397F088))(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);
}
};

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/antialiasinglevel.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/assetbuildaction.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/assetcookresult.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/assetcookstatus.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/attributestate.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/attributetype.h
Unescape View File

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

16
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/autodetectparams.h
Unescape View File

@ -0,0 +1,16 @@
#pragma once
#include <il2cpp/il2cpp.h>
class autodetectparams {
public:
template <typename T = bool> T &legsparentinspine() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = bool> T &includeeyes() {
return *(T *)((std::uintptr_t)this + 0x1);
}
template <typename T = std::uintptr_t> static T get_default() {
return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x3979A14))(0);
}
};

21
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/behaviourdelegate.h
Unescape View File

@ -0,0 +1,21 @@
#pragma once
#include <il2cpp/il2cpp.h>
class behaviourdelegate {
public:
template <typename T = void> T invoke() {
return ((T(*)(behaviourdelegate *))(il2cpp::il2cpp_base() + 0x397C700))(
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);
}
template <typename T = void> T endinvoke(std::uintptr_t _result) {
return ((T(*)(behaviourdelegate *, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x397F3C8))(this, _result);
}
};

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/boneside.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/bonetype.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/buildtype.h
Unescape View File

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

15
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/chunk.h
Unescape View File

@ -0,0 +1,15 @@
#pragma once
#include <il2cpp/il2cpp.h>
class chunk {
public:
template <typename T = std::uint32_t> T &id() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::int64_t> T &size() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int64_t> T &offset() {
return *(T *)((std::uintptr_t)this + 0x18);
}
};

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/collidertype.h
Unescape View File

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

23
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/collisiondelegate.h
Unescape View File

@ -0,0 +1,23 @@
#pragma once
#include <il2cpp/il2cpp.h>
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);
}
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))(
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);
}
};

24
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/collisionimpulsedelegate.h
Unescape View File

@ -0,0 +1,24 @@
#pragma once
#include <il2cpp/il2cpp.h>
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);
}
template <typename T = std::uintptr_t>
T begininvoke(std::uintptr_t _m, float _impulse, std::uintptr_t _callback,
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,
_object);
}
template <typename T = void> T endinvoke(std::uintptr_t _result) {
return ((T(*)(collisionimpulsedelegate *, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x3986434))(this, _result);
}
};

15
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/collisionresistancemultiplier.h
Unescape View File

@ -0,0 +1,15 @@
#pragma once
#include <il2cpp/il2cpp.h>
class collisionresistancemultiplier {
public:
template <typename T = std::uintptr_t> T &layers() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = float> T &multiplier() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = float> T &collisionthreshold() {
return *(T *)((std::uintptr_t)this + 0x8);
}
};

24
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/createsessionfromtypedelegate.h
Unescape View File

@ -0,0 +1,24 @@
#pragma once
#include <il2cpp/il2cpp.h>
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);
}
template <typename T = std::uintptr_t>
T begininvoke(std::uintptr_t _type, std::uintptr_t _callback,
std::uintptr_t _object) {
return ((T(*)(createsessionfromtypedelegate *, std::uintptr_t,
std::uintptr_t, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x2C7D230))(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);
}
};

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/cubemapdepth.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/cubemaprendermethod.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/cubemapresolution.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/curvedrawcollision.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/curveeditstate.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/custominstancetype.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/datatype.h
Unescape View File

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

45
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/delaydeadc__iterator0.h
Unescape View File

@ -0,0 +1,45 @@
#pragma once
#include <il2cpp/il2cpp.h>
class delaydeadciterator0 {
public:
template <typename T = std::uintptr_t> T &$this() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::uintptr_t> T &$current() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = bool> T &$disposing() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &$pc() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = bool> T movenext() {
return ((T(*)(delaydeadciterator0 *))(il2cpp::il2cpp_base() +
0x397A338))(this);
}
template <typename T = std::uintptr_t>
T system_collections_generic_ienumeratorobject_get_current() {
return ((T(*)(delaydeadciterator0 *))(il2cpp::il2cpp_base() +
0x397A4C8))(this);
}
template <typename T = std::uintptr_t>
T system_collections_ienumerator_get_current() {
return ((T(*)(delaydeadciterator0 *))(il2cpp::il2cpp_base() +
0x397A4D0))(this);
}
template <typename T = void> T dispose() {
return ((T(*)(delaydeadciterator0 *))(il2cpp::il2cpp_base() +
0x397A4D8))(this);
}
template <typename T = void> T reset() {
return ((T(*)(delaydeadciterator0 *))(il2cpp::il2cpp_base() +
0x397A4EC))(this);
}
};

45
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/delayfreezec__iterator0.h
Unescape View File

@ -0,0 +1,45 @@
#pragma once
#include <il2cpp/il2cpp.h>
class delayfreezeciterator0 {
public:
template <typename T = std::uintptr_t> T &$this() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::uintptr_t> T &$current() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = bool> T &$disposing() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &$pc() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = bool> T movenext() {
return ((T(*)(delayfreezeciterator0 *))(il2cpp::il2cpp_base() +
0x397FAEC))(this);
}
template <typename T = std::uintptr_t>
T system_collections_generic_ienumeratorobject_get_current() {
return ((T(*)(delayfreezeciterator0 *))(il2cpp::il2cpp_base() +
0x397FC64))(this);
}
template <typename T = std::uintptr_t>
T system_collections_ienumerator_get_current() {
return ((T(*)(delayfreezeciterator0 *))(il2cpp::il2cpp_base() +
0x397FC6C))(this);
}
template <typename T = void> T dispose() {
return ((T(*)(delayfreezeciterator0 *))(il2cpp::il2cpp_base() +
0x397FC74))(this);
}
template <typename T = void> T reset() {
return ((T(*)(delayfreezeciterator0 *))(il2cpp::il2cpp_base() +
0x397FC88))(this);
}
};

63
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/disabledtoactivec__iterator0.h
Unescape View File

@ -0,0 +1,63 @@
#pragma once
#include <il2cpp/il2cpp.h>
class disabledtoactiveciterator0 {
public:
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar0() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::int32_t> T &$locvar1() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar2() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &$locvar3() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &$locvar4() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = std::int32_t> T &$locvar5() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
template <typename T = std::uintptr_t> T &$this() {
return *(T *)((std::uintptr_t)this + 0x20);
}
template <typename T = std::uintptr_t> T &$current() {
return *(T *)((std::uintptr_t)this + 0x24);
}
template <typename T = bool> T &$disposing() {
return *(T *)((std::uintptr_t)this + 0x28);
}
template <typename T = std::int32_t> T &$pc() {
return *(T *)((std::uintptr_t)this + 0x2C);
}
template <typename T = bool> T movenext() {
return ((T(*)(disabledtoactiveciterator0 *))(il2cpp::il2cpp_base() +
0x39A6400))(this);
}
template <typename T = std::uintptr_t>
T system_collections_generic_ienumeratorobject_get_current() {
return ((T(*)(disabledtoactiveciterator0 *))(il2cpp::il2cpp_base() +
0x39A67B8))(this);
}
template <typename T = std::uintptr_t>
T system_collections_ienumerator_get_current() {
return ((T(*)(disabledtoactiveciterator0 *))(il2cpp::il2cpp_base() +
0x39A67C0))(this);
}
template <typename T = void> T dispose() {
return ((T(*)(disabledtoactiveciterator0 *))(il2cpp::il2cpp_base() +
0x39A67C8))(this);
}
template <typename T = void> T reset() {
return ((T(*)(disabledtoactiveciterator0 *))(il2cpp::il2cpp_base() +
0x39A67DC))(this);
}
};

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/downscale.h
Unescape View File

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

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/exportalphamapexrpath.h
Unescape View File

@ -0,0 +1,12 @@
#pragma once
#include <il2cpp/il2cpp.h>
class exportalphamapexrpath {
public:
template <typename T = il2cpp_string *> T &rgbpath() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = il2cpp_string *> T &alphapath() {
return *(T *)((std::uintptr_t)this + 0xC);
}
};

45
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/fadeoutmuscleweightc__iterator2.h
Unescape View File

@ -0,0 +1,45 @@
#pragma once
#include <il2cpp/il2cpp.h>
class fadeoutmuscleweightciterator2 {
public:
template <typename T = std::uintptr_t> T &$this() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::uintptr_t> T &$current() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = bool> T &$disposing() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &$pc() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = bool> T movenext() {
return ((T(*)(fadeoutmuscleweightciterator2 *))(il2cpp::il2cpp_base() +
0x397A580))(this);
}
template <typename T = std::uintptr_t>
T system_collections_generic_ienumeratorobject_get_current() {
return ((T(*)(fadeoutmuscleweightciterator2 *))(il2cpp::il2cpp_base() +
0x397A6DC))(this);
}
template <typename T = std::uintptr_t>
T system_collections_ienumerator_get_current() {
return ((T(*)(fadeoutmuscleweightciterator2 *))(il2cpp::il2cpp_base() +
0x397A6E4))(this);
}
template <typename T = void> T dispose() {
return ((T(*)(fadeoutmuscleweightciterator2 *))(il2cpp::il2cpp_base() +
0x397A6EC))(this);
}
template <typename T = void> T reset() {
return ((T(*)(fadeoutmuscleweightciterator2 *))(il2cpp::il2cpp_base() +
0x397A700))(this);
}
};

45
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/fadeoutpinweightc__iterator1.h
Unescape View File

@ -0,0 +1,45 @@
#pragma once
#include <il2cpp/il2cpp.h>
class fadeoutpinweightciterator1 {
public:
template <typename T = std::uintptr_t> T &$this() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::uintptr_t> T &$current() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = bool> T &$disposing() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &$pc() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = bool> T movenext() {
return ((T(*)(fadeoutpinweightciterator1 *))(il2cpp::il2cpp_base() +
0x397A794))(this);
}
template <typename T = std::uintptr_t>
T system_collections_generic_ienumeratorobject_get_current() {
return ((T(*)(fadeoutpinweightciterator1 *))(il2cpp::il2cpp_base() +
0x397A8EC))(this);
}
template <typename T = std::uintptr_t>
T system_collections_ienumerator_get_current() {
return ((T(*)(fadeoutpinweightciterator1 *))(il2cpp::il2cpp_base() +
0x397A8F4))(this);
}
template <typename T = void> T dispose() {
return ((T(*)(fadeoutpinweightciterator1 *))(il2cpp::il2cpp_base() +
0x397A8FC))(this);
}
template <typename T = void> T reset() {
return ((T(*)(fadeoutpinweightciterator1 *))(il2cpp::il2cpp_base() +
0x397A910))(this);
}
};

15
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/fallparams.h
Unescape View File

@ -0,0 +1,15 @@
#pragma once
#include <il2cpp/il2cpp.h>
class fallparams {
public:
template <typename T = float> T &startpinweightmlp() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = float> T &startmuscleweightmlp() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = float> T &losepinspeed() {
return *(T *)((std::uintptr_t)this + 0x8);
}
};

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/fallparamsgroup.h
Unescape View File

@ -0,0 +1,12 @@
#pragma once
#include <il2cpp/il2cpp.h>
class fallparamsgroup {
public:
template <typename T = il2cpp_array<std::uintptr_t> *> T &groups() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::uintptr_t> T &fallparams() {
return *(T *)((std::uintptr_t)this + 0x4);
}
};

48
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/finalrendercapturec__iterator0.h
Unescape View File

@ -0,0 +1,48 @@
#pragma once
#include <il2cpp/il2cpp.h>
class finalrendercaptureciterator0 {
public:
template <typename T = bool> T &cangrab__0() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::uintptr_t> T &$this() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = std::uintptr_t> T &$current() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = bool> T &$disposing() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = std::int32_t> T &$pc() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = bool> T movenext() {
return ((T(*)(finalrendercaptureciterator0 *))(il2cpp::il2cpp_base() +
0x396102C))(this);
}
template <typename T = std::uintptr_t>
T system_collections_generic_ienumeratorobject_get_current() {
return ((T(*)(finalrendercaptureciterator0 *))(il2cpp::il2cpp_base() +
0x39611E0))(this);
}
template <typename T = std::uintptr_t>
T system_collections_ienumerator_get_current() {
return ((T(*)(finalrendercaptureciterator0 *))(il2cpp::il2cpp_base() +
0x39611E8))(this);
}
template <typename T = void> T dispose() {
return ((T(*)(finalrendercaptureciterator0 *))(il2cpp::il2cpp_base() +
0x39611F0))(this);
}
template <typename T = void> T reset() {
return ((T(*)(finalrendercaptureciterator0 *))(il2cpp::il2cpp_base() +
0x3961204))(this);
}
};

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/framerate.h
Unescape View File

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

30
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/getarray1argdel`1.h
Unescape View File

@ -0,0 +1,30 @@
#pragma once
#include <il2cpp/il2cpp.h>
class getarray1argdel1 {
public:
template <typename T = bool>
T invoke(std::int32_t _arg1, il2cpp_array<std::uintptr_t> **_data,
std::int32_t _start, std::int32_t _length) {
return ((T(*)(getarray1argdel1 *, std::int32_t,
il2cpp_array<std::uintptr_t> **, std::int32_t,
std::int32_t))(il2cpp::il2cpp_base() + 0x0))(
this, _arg1, _data, _start, _length);
}
template <typename T = std::uintptr_t>
T begininvoke(std::int32_t _arg1, il2cpp_array<std::uintptr_t> **_data,
std::int32_t _start, std::int32_t _length,
std::uintptr_t _callback, std::uintptr_t _object) {
return ((T(*)(getarray1argdel1 *, std::int32_t,
il2cpp_array<std::uintptr_t> **, std::int32_t,
std::int32_t, std::uintptr_t, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x0))(this, _arg1, _data, _start, _length,
_callback, _object);
}
template <typename T = bool> T endinvoke(std::uintptr_t _result) {
return ((T(*)(getarray1argdel1 *, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x0))(this, _result);
}
};

32
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/getarray2argdel`2.h
Unescape View File

@ -0,0 +1,32 @@
#pragma once
#include <il2cpp/il2cpp.h>
class getarray2argdel2 {
public:
template <typename T = bool>
T invoke(std::int32_t _arg1, std::uintptr_t _arg2,
il2cpp_array<std::uintptr_t> **_data, std::int32_t _start,
std::int32_t _length) {
return ((T(*)(getarray2argdel2 *, std::int32_t, std::uintptr_t,
il2cpp_array<std::uintptr_t> **, std::int32_t,
std::int32_t))(il2cpp::il2cpp_base() + 0x0))(
this, _arg1, _arg2, _data, _start, _length);
}
template <typename T = std::uintptr_t>
T begininvoke(std::int32_t _arg1, std::uintptr_t _arg2,
il2cpp_array<std::uintptr_t> **_data, std::int32_t _start,
std::int32_t _length, std::uintptr_t _callback,
std::uintptr_t _object) {
return ((T(*)(getarray2argdel2 *, std::int32_t, std::uintptr_t,
il2cpp_array<std::uintptr_t> **, std::int32_t,
std::int32_t, std::uintptr_t, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x0))(this, _arg1, _arg2, _data, _start,
_length, _callback, _object);
}
template <typename T = bool> T endinvoke(std::uintptr_t _result) {
return ((T(*)(getarray2argdel2 *, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x0))(this, _result);
}
};

38
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/getattributearrayinputfunc`1.h
Unescape View File

@ -0,0 +1,38 @@
#pragma once
#include <il2cpp/il2cpp.h>
class getattributearrayinputfunc1 {
public:
template <typename T = bool>
T invoke(std::int32_t _geoid, std::int32_t _partid, il2cpp_string *_name,
std::uintptr_t _info, il2cpp_array<std::uintptr_t> **_items,
std::int32_t _start, std::int32_t _end) {
return ((T(*)(getattributearrayinputfunc1 *, std::int32_t, std::int32_t,
il2cpp_string *, std::uintptr_t,
il2cpp_array<std::uintptr_t> **, std::int32_t,
std::int32_t))(il2cpp::il2cpp_base() + 0x0))(
this, _geoid, _partid, _name, _info, _items, _start, _end);
}
template <typename T = std::uintptr_t>
T begininvoke(std::int32_t _geoid, std::int32_t _partid,
il2cpp_string *_name, std::uintptr_t _info,
il2cpp_array<std::uintptr_t> **_items, std::int32_t _start,
std::int32_t _end, std::uintptr_t _callback,
std::uintptr_t _object) {
return ((T(*)(getattributearrayinputfunc1 *, std::int32_t, std::int32_t,
il2cpp_string *, std::uintptr_t,
il2cpp_array<std::uintptr_t> **, std::int32_t,
std::int32_t, std::uintptr_t, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x0))(this, _geoid, _partid, _name, _info,
_items, _start, _end, _callback,
_object);
}
template <typename T = bool>
T endinvoke(std::uintptr_t _info, std::uintptr_t _result) {
return ((T(*)(getattributearrayinputfunc1 *, std::uintptr_t,
std::uintptr_t))(il2cpp::il2cpp_base() + 0x0))(
this, _info, _result);
}
};

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/graphicsdebuggerclient.h
Unescape View File

@ -0,0 +1,9 @@
#pragma once
#include <il2cpp/il2cpp.h>
class graphicsdebuggerclient {
public:
template <typename T = void> static T initializeonloadentrypoint() {
return ((T(*)(void *))(il2cpp::il2cpp_base() + 0x4C72BA4))(0);
}
};

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/group.h
Unescape View File

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

16
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/headdata.h
Unescape View File

@ -0,0 +1,16 @@
#pragma once
#include <il2cpp/il2cpp.h>
class headdata {
public:
template <typename T = unsigned char> T &type() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::int32_t> T &tag() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = void> T clear() {
return ((T(*)(headdata *))(il2cpp::il2cpp_base() + 0x4FCA2B8))(this);
}
};

32
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_asseteventreceivertest.h
Unescape View File

@ -0,0 +1,32 @@
#pragma once
#include <il2cpp/il2cpp.h>
class heuasseteventreceivertest {
public:
template <typename T = void>
T reloadcallback(std::uintptr_t _asset, bool _success,
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,
_outputlist);
}
template <typename T = void>
T cookedcallback(std::uintptr_t _asset, bool _success,
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,
_outputlist);
}
template <typename T = void>
T bakedcallback(std::uintptr_t _asset, bool _success,
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,
_outputlist);
}
};

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_assettype.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_handleparamtype.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_handletype.h
Unescape View File

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

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_importassetoptions.h
Unescape View File

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

6
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_inputobjectuicache.h
Unescape View File

@ -0,0 +1,6 @@
#pragma once
#include <il2cpp/il2cpp.h>
class heuinputobjectuicache {
public:
};

6
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_layerattribute.h
Unescape View File

@ -0,0 +1,6 @@
#pragma once
#include <il2cpp/il2cpp.h>
class heulayerattribute {
public:
};

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_replaceprefaboptions.h
Unescape View File

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

19
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_scriptcallbackexample.h
Unescape View File

@ -0,0 +1,19 @@
#pragma once
#include <il2cpp/il2cpp.h>
class heuscriptcallbackexample {
public:
template <typename T = il2cpp_string *> T &_msg() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = void> T assetcallbackwithmsg(il2cpp_string *_msg) {
return ((T(*)(heuscriptcallbackexample *, il2cpp_string *))(
il2cpp::il2cpp_base() + 0x4C73544))(this, _msg);
}
template <typename T = void> T assetcallbacknomsg() {
return ((T(*)(heuscriptcallbackexample *))(il2cpp::il2cpp_base() +
0x4C73650))(this);
}
};

28
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_scriptparameterexample.h
Unescape View File

@ -0,0 +1,28 @@
#pragma once
#include <il2cpp/il2cpp.h>
class heuscriptparameterexample {
public:
template <typename T = std::uintptr_t> T &_evergreengameobject() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = std::uintptr_t> T &_evergreenasset() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = float> T &_updaterate() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = float> T &_scale() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = void> T start() {
return ((T(*)(heuscriptparameterexample *))(il2cpp::il2cpp_base() +
0x4C7372C))(this);
}
template <typename T = void> T updategravity() {
return ((T(*)(heuscriptparameterexample *))(il2cpp::il2cpp_base() +
0x4C73890))(this);
}
};

33
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_uploadmeshdata.h
Unescape View File

@ -0,0 +1,33 @@
#pragma once
#include <il2cpp/il2cpp.h>
class heuuploadmeshdata {
public:
template <typename T = std::uintptr_t> T &_mesh() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &_materials() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = il2cpp_string *> T &_meshpath() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = il2cpp_string *> T &_meshname() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = std::int32_t> T &_numvertices() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = std::int32_t> T &_numsubmeshes() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &_indexstart() {
return *(T *)((std::uintptr_t)this + 0x20);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &_indexcount() {
return *(T *)((std::uintptr_t)this + 0x24);
}
template <typename T = float> T &_lodscreentransition() {
return *(T *)((std::uintptr_t)this + 0x28);
}
};

6
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/heu_uploadvolumedata.h
Unescape View File

@ -0,0 +1,6 @@
#pragma once
#include <il2cpp/il2cpp.h>
class heuuploadvolumedata {
public:
};

23
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/hitdelegate.h
Unescape View File

@ -0,0 +1,23 @@
#pragma once
#include <il2cpp/il2cpp.h>
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);
}
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))(
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);
}
};

24
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/arrayextensions.h
Unescape View File

@ -0,0 +1,24 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class arrayextensions {
public:
template <typename T = void>
static T init(il2cpp_array<std::uintptr_t> *_array,
std::uintptr_t _defaultvalue) {
return (
(T(*)(void *, il2cpp_array<std::uintptr_t> *, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x0))(0, _array, _defaultvalue);
}
template <typename T = void>
static T init_1(il2cpp_list<std::uintptr_t> *_array,
std::uintptr_t _defaultvalue) {
return (
(T(*)(void *, il2cpp_list<std::uintptr_t> *, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x0))(0, _array, _defaultvalue);
}
};
} // namespace houdiniengineunity

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/bakedevent.h
Unescape View File

@ -0,0 +1,9 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class bakedevent {
public:
};
} // namespace houdiniengineunity

9
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/cookedevent.h
Unescape View File

@ -0,0 +1,9 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class cookedevent {
public:
};
} // namespace houdiniengineunity

54
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_assetinfo.h
Unescape View File

@ -0,0 +1,54 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapiassetinfo {
public:
template <typename T = std::int32_t> T &nodeid() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &objectnodeid() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = bool> T &hasevercooked() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::int32_t> T &namesh() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = std::int32_t> T &labelsh() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &filepathsh() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = std::int32_t> T &versionsh() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = std::int32_t> T &fullopnamesh() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
template <typename T = std::int32_t> T &helptextsh() {
return *(T *)((std::uintptr_t)this + 0x20);
}
template <typename T = std::int32_t> T &objectcount() {
return *(T *)((std::uintptr_t)this + 0x24);
}
template <typename T = std::int32_t> T &handlecount() {
return *(T *)((std::uintptr_t)this + 0x28);
}
template <typename T = std::int32_t> T &transforminputcount() {
return *(T *)((std::uintptr_t)this + 0x2C);
}
template <typename T = std::int32_t> T &geoinputcount() {
return *(T *)((std::uintptr_t)this + 0x30);
}
template <typename T = bool> T &haveobjectschanged() {
return *(T *)((std::uintptr_t)this + 0x34);
}
template <typename T = bool> T &havematerialschanged() {
return *(T *)((std::uintptr_t)this + 0x35);
}
};
} // namespace houdiniengineunity

30
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_attributeinfo.h
Unescape View File

@ -0,0 +1,30 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapiattributeinfo {
public:
template <typename T = bool> T &exists() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::uintptr_t> T &owner() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::uintptr_t> T &storage() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::uintptr_t> T &originalowner() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = std::int32_t> T &count() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &tuplesize() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = std::uintptr_t> T &typeinfo() {
return *(T *)((std::uintptr_t)this + 0x18);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_attributeowner.h
Unescape View File

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

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_attributetypeinfo.h
Unescape View File

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

18
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_boxinfo.h
Unescape View File

@ -0,0 +1,18 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapiboxinfo {
public:
template <typename T = il2cpp_array<std::uintptr_t> *> T &center() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &size() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = il2cpp_array<std::uintptr_t> *> T &rotation() {
return *(T *)((std::uintptr_t)this + 0x8);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_cacheproperty.h
Unescape View File

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

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_choicelisttype.h
Unescape View File

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

42
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_cookoptions.h
Unescape View File

@ -0,0 +1,42 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapicookoptions {
public:
template <typename T = bool> T &splitgeosbygroup() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &maxverticesperprimitive() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = bool> T &refinecurvetolinear() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = float> T &curverefinelod() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = bool> T &clearerrorsandwarnings() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = bool> T &cooktemplatedgeos() {
return *(T *)((std::uintptr_t)this + 0x11);
}
template <typename T = bool> T &splitpointsbyvertexattributes() {
return *(T *)((std::uintptr_t)this + 0x12);
}
template <typename T = std::uintptr_t> T &packedpriminstancingmode() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = bool> T &handleboxparttypes() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = bool> T &handlesphereparttypes() {
return *(T *)((std::uintptr_t)this + 0x19);
}
template <typename T = std::int32_t> T &extraflags() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
};
} // namespace houdiniengineunity

33
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_curveinfo.h
Unescape View File

@ -0,0 +1,33 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapicurveinfo {
public:
template <typename T = std::uintptr_t> T &curvetype() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &curvecount() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::int32_t> T &vertexcount() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::int32_t> T &knotcount() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = bool> T &isperiodic() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = bool> T &isrational() {
return *(T *)((std::uintptr_t)this + 0x11);
}
template <typename T = std::int32_t> T &order() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = bool> T &hasknots() {
return *(T *)((std::uintptr_t)this + 0x18);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_curveorders.h
Unescape View File

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

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_curvetype.h
Unescape View File

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

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_envinttype.h
Unescape View File

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

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_errorcode.h
Unescape View File

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

48
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_geoinfo.h
Unescape View File

@ -0,0 +1,48 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapigeoinfo {
public:
template <typename T = std::uintptr_t> T &type() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &namesh() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::int32_t> T &nodeid() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = bool> T &iseditable() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = bool> T &istemplated() {
return *(T *)((std::uintptr_t)this + 0xD);
}
template <typename T = bool> T &isdisplaygeo() {
return *(T *)((std::uintptr_t)this + 0xE);
}
template <typename T = bool> T &hasgeochanged() {
return *(T *)((std::uintptr_t)this + 0xF);
}
template <typename T = bool> T &hasmaterialchanged() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &pointgroupcount() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = std::int32_t> T &primitivegroupcount() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = std::int32_t> T &partcount() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
template <typename T = std::int32_t>
T getgroupcountbytype(std::uintptr_t _type) {
return ((T(*)(hapigeoinfo *, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x4C73F2C))(this, _type);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_geotype.h
Unescape View File

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

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_grouptype.h
Unescape View File

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

18
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_handlebindinginfo.h
Unescape View File

@ -0,0 +1,18 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapihandlebindinginfo {
public:
template <typename T = std::int32_t> T &handleparmnamesh() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &assetparmnamesh() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::int32_t> T &assetparmid() {
return *(T *)((std::uintptr_t)this + 0x8);
}
};
} // namespace houdiniengineunity

18
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_handleinfo.h
Unescape View File

@ -0,0 +1,18 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapihandleinfo {
public:
template <typename T = std::int32_t> T &namesh() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &typenamesh() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::int32_t> T &bindingscount() {
return *(T *)((std::uintptr_t)this + 0x8);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_imagedataformat.h
Unescape View File

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

18
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_imagefileformat.h
Unescape View File

@ -0,0 +1,18 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapiimagefileformat {
public:
template <typename T = std::int32_t> T &namesh() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &descriptionsh() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::int32_t> T &defaultextensionsh() {
return *(T *)((std::uintptr_t)this + 0x8);
}
};
} // namespace houdiniengineunity

30
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_imageinfo.h
Unescape View File

@ -0,0 +1,30 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapiimageinfo {
public:
template <typename T = std::int32_t> T &imagefileformatnamesh() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &xres() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::int32_t> T &yres() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::uintptr_t> T &dataformat() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = bool> T &interleaved() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::uintptr_t> T &packing() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = double> T &gamma() {
return *(T *)((std::uintptr_t)this + 0x18);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_imagepacking.h
Unescape View File

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

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_inputtype.h
Unescape View File

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

21
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_keyframe.h
Unescape View File

@ -0,0 +1,21 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapikeyframe {
public:
template <typename T = float> T &time() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = float> T &value() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = float> T &intangent() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = float> T &outtangent() {
return *(T *)((std::uintptr_t)this + 0xC);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_license.h
Unescape View File

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

18
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_materialinfo.h
Unescape View File

@ -0,0 +1,18 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapimaterialinfo {
public:
template <typename T = std::int32_t> T &nodeid() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = bool> T &exists() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = bool> T &haschanged() {
return *(T *)((std::uintptr_t)this + 0x5);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_nodeflags.h
Unescape View File

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

57
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_nodeinfo.h
Unescape View File

@ -0,0 +1,57 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapinodeinfo {
public:
template <typename T = std::int32_t> T &id() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &parentid() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::int32_t> T &namesh() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::uintptr_t> T &type() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = bool> T &isvalid() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &totalcookcount() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = std::int32_t> T &uniquehoudininodeid() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = std::int32_t> T &internalnodepathsh() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
template <typename T = std::int32_t> T &parmcount() {
return *(T *)((std::uintptr_t)this + 0x20);
}
template <typename T = std::int32_t> T &parmintvaluecount() {
return *(T *)((std::uintptr_t)this + 0x24);
}
template <typename T = std::int32_t> T &parmfloatvaluecount() {
return *(T *)((std::uintptr_t)this + 0x28);
}
template <typename T = std::int32_t> T &parmstringvaluecount() {
return *(T *)((std::uintptr_t)this + 0x2C);
}
template <typename T = std::int32_t> T &parmchoicecount() {
return *(T *)((std::uintptr_t)this + 0x30);
}
template <typename T = std::int32_t> T &childnodecount() {
return *(T *)((std::uintptr_t)this + 0x34);
}
template <typename T = std::int32_t> T &inputcount() {
return *(T *)((std::uintptr_t)this + 0x38);
}
template <typename T = bool> T &createdpostassetload() {
return *(T *)((std::uintptr_t)this + 0x3C);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_nodetype.h
Unescape View File

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

39
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_objectinfo.h
Unescape View File

@ -0,0 +1,39 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapiobjectinfo {
public:
template <typename T = std::int32_t> T &namesh() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &objectinstancepathsh() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = bool> T &hastransformchanged() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = bool> T &havegeoschanged() {
return *(T *)((std::uintptr_t)this + 0x9);
}
template <typename T = bool> T &isvisible() {
return *(T *)((std::uintptr_t)this + 0xA);
}
template <typename T = bool> T &isinstancer() {
return *(T *)((std::uintptr_t)this + 0xB);
}
template <typename T = bool> T &isinstanced() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = std::int32_t> T &geocount() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &nodeid() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = std::int32_t> T &objecttoinstanceid() {
return *(T *)((std::uintptr_t)this + 0x18);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_packedpriminstancingmode.h
Unescape View File

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

18
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_parmchoiceinfo.h
Unescape View File

@ -0,0 +1,18 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapiparmchoiceinfo {
public:
template <typename T = std::int32_t> T &parentparmid() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &labelsh() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::int32_t> T &valuesh() {
return *(T *)((std::uintptr_t)this + 0x8);
}
};
} // namespace houdiniengineunity

156
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_parminfo.h
Unescape View File

@ -0,0 +1,156 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapiparminfo {
public:
template <typename T = std::int32_t> T &id() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &parentid() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::int32_t> T &childindex() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::uintptr_t> T &type() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = std::int32_t> T &typeinfosh() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::uintptr_t> T &permissions() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = std::int32_t> T &tagcount() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = std::int32_t> T &size() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
template <typename T = std::uintptr_t> T &choicelisttype() {
return *(T *)((std::uintptr_t)this + 0x20);
}
template <typename T = std::int32_t> T &choicecount() {
return *(T *)((std::uintptr_t)this + 0x24);
}
template <typename T = std::int32_t> T &namesh() {
return *(T *)((std::uintptr_t)this + 0x28);
}
template <typename T = std::int32_t> T &labelsh() {
return *(T *)((std::uintptr_t)this + 0x2C);
}
template <typename T = std::int32_t> T &templatenamesh() {
return *(T *)((std::uintptr_t)this + 0x30);
}
template <typename T = std::int32_t> T &helpsh() {
return *(T *)((std::uintptr_t)this + 0x34);
}
template <typename T = bool> T &hasmin() {
return *(T *)((std::uintptr_t)this + 0x38);
}
template <typename T = bool> T &hasmax() {
return *(T *)((std::uintptr_t)this + 0x39);
}
template <typename T = bool> T &hasuimin() {
return *(T *)((std::uintptr_t)this + 0x3A);
}
template <typename T = bool> T &hasuimax() {
return *(T *)((std::uintptr_t)this + 0x3B);
}
template <typename T = float> T &min() {
return *(T *)((std::uintptr_t)this + 0x3C);
}
template <typename T = float> T &max() {
return *(T *)((std::uintptr_t)this + 0x40);
}
template <typename T = float> T &uimin() {
return *(T *)((std::uintptr_t)this + 0x44);
}
template <typename T = float> T &uimax() {
return *(T *)((std::uintptr_t)this + 0x48);
}
template <typename T = bool> T &invisible() {
return *(T *)((std::uintptr_t)this + 0x4C);
}
template <typename T = bool> T &disabled() {
return *(T *)((std::uintptr_t)this + 0x4D);
}
template <typename T = bool> T &spare() {
return *(T *)((std::uintptr_t)this + 0x4E);
}
template <typename T = bool> T &joinnext() {
return *(T *)((std::uintptr_t)this + 0x4F);
}
template <typename T = bool> T &labelnone() {
return *(T *)((std::uintptr_t)this + 0x50);
}
template <typename T = std::int32_t> T &intvaluesindex() {
return *(T *)((std::uintptr_t)this + 0x54);
}
template <typename T = std::int32_t> T &floatvaluesindex() {
return *(T *)((std::uintptr_t)this + 0x58);
}
template <typename T = std::int32_t> T &stringvaluesindex() {
return *(T *)((std::uintptr_t)this + 0x5C);
}
template <typename T = std::int32_t> T &choiceindex() {
return *(T *)((std::uintptr_t)this + 0x60);
}
template <typename T = std::uintptr_t> T &inputnodetype() {
return *(T *)((std::uintptr_t)this + 0x64);
}
template <typename T = std::uintptr_t> T &inputnodeflag() {
return *(T *)((std::uintptr_t)this + 0x68);
}
template <typename T = bool> T &ischildofmultiparm() {
return *(T *)((std::uintptr_t)this + 0x6C);
}
template <typename T = std::int32_t> T &instancenum() {
return *(T *)((std::uintptr_t)this + 0x70);
}
template <typename T = std::int32_t> T &instancelength() {
return *(T *)((std::uintptr_t)this + 0x74);
}
template <typename T = std::int32_t> T &instancecount() {
return *(T *)((std::uintptr_t)this + 0x78);
}
template <typename T = std::int32_t> T &instancestartoffset() {
return *(T *)((std::uintptr_t)this + 0x7C);
}
template <typename T = std::uintptr_t> T &ramptype() {
return *(T *)((std::uintptr_t)this + 0x80);
}
template <typename T = bool> T isint() {
return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73F64))(
this);
}
template <typename T = bool> T isfloat() {
return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73F78))(
this);
}
template <typename T = bool> T isstring() {
return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73F90))(
this);
}
template <typename T = bool> T ispath() {
return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73FA8))(
this);
}
template <typename T = bool> T isnode() {
return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73FC0))(
this);
}
template <typename T = bool> T isnonvalue() {
return ((T(*)(hapiparminfo *))(il2cpp::il2cpp_base() + 0x4C73FD4))(
this);
}
};
} // namespace houdiniengineunity

24
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_parminput.h
Unescape View File

@ -0,0 +1,24 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapiparminput {
public:
template <typename T = bool> T &isasset() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::uintptr_t> T &inputobject() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::uintptr_t> T &newinputobject() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::int32_t> T &inputnodeid() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = std::int32_t> T &inputnodeuniqueid() {
return *(T *)((std::uintptr_t)this + 0x10);
}
};
} // namespace houdiniengineunity

12
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_parmtype.h
Unescape View File

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

101
ligma-cheat/ligma-cheat/SDK/assembly-csharp-firstpass.dll/includes/houdiniengineunity/hapi_partinfo.h
Unescape View File

@ -0,0 +1,101 @@
#pragma once
#include <il2cpp/il2cpp.h>
namespace houdiniengineunity {
class hapipartinfo {
public:
template <typename T = std::int32_t> T &id() {
return *(T *)((std::uintptr_t)this + 0x0);
}
template <typename T = std::int32_t> T &namesh() {
return *(T *)((std::uintptr_t)this + 0x4);
}
template <typename T = std::uintptr_t> T &type() {
return *(T *)((std::uintptr_t)this + 0x8);
}
template <typename T = std::int32_t> T &facecount() {
return *(T *)((std::uintptr_t)this + 0xC);
}
template <typename T = std::int32_t> T &vertexcount() {
return *(T *)((std::uintptr_t)this + 0x10);
}
template <typename T = std::int32_t> T &pointcount() {
return *(T *)((std::uintptr_t)this + 0x14);
}
template <typename T = il2cpp_array<std::uintptr_t> *>
T &attributecounts() {
return *(T *)((std::uintptr_t)this + 0x18);
}
template <typename T = bool> T &isinstanced() {
return *(T *)((std::uintptr_t)this + 0x1C);
}
template <typename T = std::int32_t> T &instancedpartcount() {
return *(T *)((std::uintptr_t)this + 0x20);
}
template <typename T = std::int32_t> T &instancecount() {
return *(T *)((std::uintptr_t)this + 0x24);
}
template <typename T = std::int32_t>
T getelementcountbyattributeowner(std::uintptr_t _owner) {
return ((T(*)(hapipartinfo *, std::uintptr_t))(
il2cpp::il2cpp_base() + 0x4C7422C))(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);
}
template <typename T = void> T init() {
return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x4C74368))(
this);
}
template <typename T = std::int32_t> T get_pointattributecount() {
return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x4C743B4))(
this);
}
template <typename T = void>
T set_pointattributecount(std::int32_t _value) {
return ((T(*)(hapipartinfo *, std::int32_t))(
il2cpp::il2cpp_base() + 0x4C74404))(this, _value);
}
template <typename T = std::int32_t> T get_primitiveattributecount() {
return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x4C74450))(
this);
}
template <typename T = void>
T set_primitiveattributecount(std::int32_t _value) {
return ((T(*)(hapipartinfo *, std::int32_t))(
il2cpp::il2cpp_base() + 0x4C744A0))(this, _value);
}
template <typename T = std::int32_t> T get_vertexattributecount() {
return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x4C744EC))(
this);
}
template <typename T = void>
T set_vertexattributecount(std::int32_t _value) {
return ((T(*)(hapipartinfo *, std::int32_t))(
il2cpp::il2cpp_base() + 0x4C7453C))(this, _value);
}
template <typename T = std::int32_t> T get_detailattributecount() {
return ((T(*)(hapipartinfo *))(il2cpp::il2cpp_base() + 0x4C74588))(
this);
}
template <typename T = void>
T set_detailattributecount(std::int32_t _value) {
return ((T(*)(hapipartinfo *, std::int32_t))(
il2cpp::il2cpp_base() + 0x4C745D8))(this, _value);
}
};
} // namespace houdiniengineunity

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save