codm/ligma-cheat/ligma-cheat/SDK/assembly-csharp.dll/includes/gameengine/tacticsgaunsight.h

#pragma once
#include <il2cpp/il2cpp.h>
namespace gameengine {

    class tacticsgaunsight {
      public:
        template <typename T = il2cpp_list<std::uintptr_t> *> T &mfoes() {
            return *(T *)((std::uintptr_t)this + 0x24);
        }
        template <typename T = std::uintptr_t> T &mcb() {
            return *(T *)((std::uintptr_t)this + 0x28);
        }
        template <typename T = std::uintptr_t> T &mcaptureaftercb() {
            return *(T *)((std::uintptr_t)this + 0x2C);
        }
        template <typename T = std::int32_t> T &mbeforetex() {
            return *(T *)((std::uintptr_t)this + 0x30);
        }
        template <typename T = std::uintptr_t> T &maftertex() {
            return *(T *)((std::uintptr_t)this + 0x34);
        }
        template <typename T = std::uintptr_t> T &mmat() {
            return *(T *)((std::uintptr_t)this + 0x38);
        }
        template <typename T = std::uintptr_t> T &mhudmat() {
            return *(T *)((std::uintptr_t)this + 0x3C);
        }
        template <typename T = std::uintptr_t> T &mhudmesh() {
            return *(T *)((std::uintptr_t)this + 0x44);
        }
        template <typename T = std::uintptr_t> T &mcurhudrenderer() {
            return *(T *)((std::uintptr_t)this + 0x48);
        }
        template <typename T = std::uintptr_t> T &mcurcrossrenderer() {
            return *(T *)((std::uintptr_t)this + 0x4C);
        }
        template <typename T = std::uintptr_t> T &mfirstcamera() {
            return *(T *)((std::uintptr_t)this + 0x50);
        }
        template <typename T = std::uintptr_t> T &mcam() {
            return *(T *)((std::uintptr_t)this + 0x54);
        }
        template <typename T = il2cpp_array<std::uintptr_t> *> T &mrais() {
            return *(T *)((std::uintptr_t)this + 0x58);
        }
        template <typename T = std::uintptr_t> T &ftick() {
            return *(T *)((std::uintptr_t)this + 0x5C);
        }

        template <typename T = void> T loadasset() {
            return ((T(*)(tacticsgaunsight *))(il2cpp::il2cpp_base() +
                                               0x3C07938))(this);
        }

        template <typename T = void>
        T onloadassets(il2cpp_array<std::uintptr_t> *_inassets,
                       std::uintptr_t _inobj) {
            return ((T(*)(tacticsgaunsight *, il2cpp_array<std::uintptr_t> *,
                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x3C07AF8))(
                this, _inassets, _inobj);
        }

        template <typename T = void>
        T init(std::uintptr_t _weapon, std::uintptr_t _weaponpart) {
            return ((T(*)(tacticsgaunsight *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x3C07DB8))(this, _weapon, _weaponpart);
        }

        template <typename T = void> T close() {
            return ((T(*)(tacticsgaunsight *))(il2cpp::il2cpp_base() +
                                               0x3C08D2C))(this);
        }

        template <typename T = void> T shutdown() {
            return ((T(*)(tacticsgaunsight *))(il2cpp::il2cpp_base() +
                                               0x3C091EC))(this);
        }

        template <typename T = bool> T updateshowpawn() {
            return ((T(*)(tacticsgaunsight *))(il2cpp::il2cpp_base() +
                                               0x3C09518))(this);
        }

        template <typename T = void> T resethudbuffer() {
            return ((T(*)(tacticsgaunsight *))(il2cpp::il2cpp_base() +
                                               0x3C09B9C))(this);
        }

        template <typename T = void> T stopresethudbuffer() {
            return ((T(*)(tacticsgaunsight *))(il2cpp::il2cpp_base() +
                                               0x3C0A308))(this);
        }

        template <typename T = void> T resetcommandbuffer() {
            return ((T(*)(tacticsgaunsight *))(il2cpp::il2cpp_base() +
                                               0x3C09EE4))(this);
        }

        template <typename T = void>
        T fcheckstate(float _delta, std::uintptr_t _inweapon) {
            return ((T(*)(tacticsgaunsight *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x3C0AE20))(this, _delta, _inweapon);
        }

        template <typename T = void>
        T fdrawtemplate(float _delta, std::uintptr_t _inweapon) {
            return ((T(*)(tacticsgaunsight *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x3C0B2F8))(this, _delta, _inweapon);
        }

        template <typename T = void>
        T tick(float _deltatime, std::uintptr_t _inweapon) {
            return ((T(*)(tacticsgaunsight *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x3C0B3F8))(this, _deltatime,
                                                    _inweapon);
        }

        template <typename T = void>
        T fupdate(float _delta, std::uintptr_t _inweapon) {
            return ((T(*)(tacticsgaunsight *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x3C0B7D0))(this, _delta, _inweapon);
        }

        template <typename T = void> T xluabaseproxy_loadasset() {
            return ((T(*)(tacticsgaunsight *))(il2cpp::il2cpp_base() +
                                               0x3C0C04C))(this);
        }

        template <typename T = void>
        T xluabaseproxy_onloadassets(il2cpp_array<std::uintptr_t> *_p0,
                                     std::uintptr_t _p1) {
            return ((T(*)(tacticsgaunsight *, il2cpp_array<std::uintptr_t> *,
                          std::uintptr_t))(il2cpp::il2cpp_base() + 0x3C0C054))(
                this, _p0, _p1);
        }

        template <typename T = void>
        T xluabaseproxy_init(std::uintptr_t _p0, std::uintptr_t _p1) {
            return ((T(*)(tacticsgaunsight *, std::uintptr_t, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x3C0C05C))(this, _p0, _p1);
        }

        template <typename T = void> T xluabaseproxy_close() {
            return ((T(*)(tacticsgaunsight *))(il2cpp::il2cpp_base() +
                                               0x3C0C064))(this);
        }

        template <typename T = void> T xluabaseproxy_shutdown() {
            return ((T(*)(tacticsgaunsight *))(il2cpp::il2cpp_base() +
                                               0x3C0C06C))(this);
        }

        template <typename T = void>
        T xluabaseproxy_tick(float _p0, std::uintptr_t _p1) {
            return ((T(*)(tacticsgaunsight *, float, std::uintptr_t))(
                il2cpp::il2cpp_base() + 0x3C0C074))(this, _p0, _p1);
        }
    };

} // namespace gameengine