11.09.2024

compile-ready SDK

sdk/engine2.hpp

@@ -1,140 +0,0 @@
-#pragma once
-#include <cstdint>
-#include "!GlobalTypes.hpp"
-
-// /////////////////////////////////////////////////////////////
-// Binary: engine2.dll
-// Classes count: 4 (Allocated) | 4 (Unallocated)
-// Enums count: 0 (Allocated) | 2 (Unallocated)
-// Created using source2gen - github.com/neverlosecc/source2gen
-// /////////////////////////////////////////////////////////////
-
-// Registered binary: engine2.dll (project 'engine2')
-// Enumerator count: 3
-// Alignment: 4
-// Size: 0x4
-enum class SpawnDebugOverrideState_t : std::uint32_t
-{
-	SPAWN_DEBUG_OVERRIDE_NONE = 0x0,
-	SPAWN_DEBUG_OVERRIDE_FORCE_ENABLED = 0x1,
-	SPAWN_DEBUG_OVERRIDE_FORCE_DISABLED = 0x2,
-};
-
-// Registered binary: engine2.dll (project 'engine2')
-// Enumerator count: 5
-// Alignment: 4
-// Size: 0x4
-enum class SpawnDebugRestrictionOverrideState_t : std::uint32_t
-{
-	SPAWN_DEBUG_RESTRICT_NONE = 0x0,
-	SPAWN_DEBUG_RESTRICT_IGNORE_MANAGER_DISTANCE_REQS = 0x1,
-	SPAWN_DEBUG_RESTRICT_IGNORE_TEMPLATE_DISTANCE_LOS_REQS = 0x2,
-	SPAWN_DEBUG_RESTRICT_IGNORE_TEMPLATE_COOLDOWN_LIMITS = 0x4,
-	SPAWN_DEBUG_RESTRICT_IGNORE_TARGET_COOLDOWN_LIMITS = 0x8,
-};
-
-struct ChangeAccessorFieldPathIndex_t;
-struct CEntityIdentity;
-struct CScriptComponent;
-
-// Registered binary: engine2.dll (project 'entity2')
-// Alignment: 8
-// Size: 0x8
-// Has VTable
-// Is Abstract
-// Has Trivial Destructor
-class CEntityComponent
-{
-private:
-	[[maybe_unused]] uint8_t __pad0000[0x8]; // 0x0
-public:
-	// No schema binary for binding
-};
-
-// Registered binary: engine2.dll (project 'entity2')
-// Alignment: 8
-// Size: 0x38
-// Has VTable
-// MClassHasEntityLimitedDataDesc
-// MNetworkAssumeNotNetworkable
-class CScriptComponent : public CEntityComponent
-{
-private:
-	[[maybe_unused]] uint8_t __pad0008[0x28]; // 0x8
-public:
-	CUtlSymbolLarge m_scriptClassName; // 0x30	
-	
-	// Static fields:
-	static EntComponentInfo_t &Get_s_EntComponentInfo(){return *reinterpret_cast<EntComponentInfo_t*>(interfaces::g_schema->FindTypeScopeForModule("engine2.dll")->FindDeclaredClass("CScriptComponent")->GetStaticFields()[0]->m_pInstance);};
-	static int32_t &Get_entity_component_error_class_decl_says_contained_but_impl_is_referenced(){return *reinterpret_cast<int32_t*>(interfaces::g_schema->FindTypeScopeForModule("engine2.dll")->FindDeclaredClass("CScriptComponent")->GetStaticFields()[1]->m_pInstance);};
-};
-
-// Registered binary: engine2.dll (project 'entity2')
-// Alignment: 8
-// Size: 0x78
-// MNetworkAssumeNotNetworkable
-// 
-// MNetworkVarNames "int32 m_nameStringableIndex"
-class CEntityIdentity
-{
-private:
-	[[maybe_unused]] uint8_t __pad0000[0x14]; // 0x0
-public:
-	// MNetworkEnable
-	// MNetworkChangeCallback "entityIdentityNameChanged"
-	int32_t m_nameStringableIndex; // 0x14	
-	CUtlSymbolLarge m_name; // 0x18	
-	CUtlSymbolLarge m_designerName; // 0x20	
-private:
-	[[maybe_unused]] uint8_t __pad0028[0x8]; // 0x28
-public:
-	uint32_t m_flags; // 0x30	
-private:
-	[[maybe_unused]] uint8_t __pad0034[0x4]; // 0x34
-public:
-	// MNetworkDisable
-	WorldGroupId_t m_worldGroupId; // 0x38	
-	uint32_t m_fDataObjectTypes; // 0x3c	
-	// MNetworkDisable
-	// MNetworkChangeAccessorFieldPathIndex
-	ChangeAccessorFieldPathIndex_t m_PathIndex; // 0x40	
-private:
-	[[maybe_unused]] uint8_t __pad0044[0x14]; // 0x44
-public:
-	CEntityIdentity* m_pPrev; // 0x58	
-	CEntityIdentity* m_pNext; // 0x60	
-	CEntityIdentity* m_pPrevByClass; // 0x68	
-	CEntityIdentity* m_pNextByClass; // 0x70	
-	
-	// Datamap fields:
-	// void m_pAttributes; // 0x48
-};
-
-// Registered binary: engine2.dll (project 'entity2')
-// Alignment: 8
-// Size: 0x38
-// Has VTable
-// Construct disallowed
-// MConstructibleClassBase
-// 
-// MNetworkVarNames "CEntityIdentity * m_pEntity"
-// MNetworkVarNames "CScriptComponent::Storage_t m_CScriptComponent"
-class CEntityInstance
-{
-private:
-	[[maybe_unused]] uint8_t __pad0000[0x8]; // 0x0
-public:
-	// MNetworkDisable
-	CUtlSymbolLarge m_iszPrivateVScripts; // 0x8	
-	// MNetworkEnable
-	// MNetworkPriority "56"
-	CEntityIdentity* m_pEntity; // 0x10	
-private:
-	[[maybe_unused]] uint8_t __pad0018[0x10]; // 0x18
-public:
-	// MNetworkEnable
-	// MNetworkDisable
-	CScriptComponent* m_CScriptComponent; // 0x28	
-	bool m_bVisibleinPVS; // 0x30	
-};
-

sdk/host.hpp

@@ -1,24 +0,0 @@
-#pragma once
-#include <cstdint>
-#include "!GlobalTypes.hpp"
-
-// /////////////////////////////////////////////////////////////
-// Binary: host.dll
-// Classes count: 0 (Allocated) | 1 (Unallocated)
-// Enums count: 0 (Allocated) | 0 (Unallocated)
-// Created using source2gen - github.com/neverlosecc/source2gen
-// /////////////////////////////////////////////////////////////
-
-// Registered binary: host.dll (project 'host')
-// Alignment: 8
-// Size: 0x10
-// Has VTable
-// Is Abstract
-class CAnimScriptBase
-{
-private:
-	[[maybe_unused]] uint8_t __pad0000[0x8]; // 0x0
-public:
-	bool m_bIsValid; // 0x8	
-};
-

sdk/include/source2sdk/animationsystem/AnimParamButton_t.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 13
+    // Alignment: 4
+    // Size: 0x4
+    enum class AnimParamButton_t : std::uint32_t
+    {
+        // MPropertyFriendlyName "None"
+        ANIMPARAM_BUTTON_NONE = 0x0,
+        // MPropertyFriendlyName "Dpad Up"
+        ANIMPARAM_BUTTON_DPAD_UP = 0x1,
+        // MPropertyFriendlyName "Dpad Right"
+        ANIMPARAM_BUTTON_DPAD_RIGHT = 0x2,
+        // MPropertyFriendlyName "Dpad Down"
+        ANIMPARAM_BUTTON_DPAD_DOWN = 0x3,
+        // MPropertyFriendlyName "Dpad Left"
+        ANIMPARAM_BUTTON_DPAD_LEFT = 0x4,
+        // MPropertyFriendlyName "A"
+        ANIMPARAM_BUTTON_A = 0x5,
+        // MPropertyFriendlyName "B"
+        ANIMPARAM_BUTTON_B = 0x6,
+        // MPropertyFriendlyName "X"
+        ANIMPARAM_BUTTON_X = 0x7,
+        // MPropertyFriendlyName "Y"
+        ANIMPARAM_BUTTON_Y = 0x8,
+        // MPropertyFriendlyName "Left Shoulder"
+        ANIMPARAM_BUTTON_LEFT_SHOULDER = 0x9,
+        // MPropertyFriendlyName "Right Shoulder"
+        ANIMPARAM_BUTTON_RIGHT_SHOULDER = 0xa,
+        // MPropertyFriendlyName "Left Trigger"
+        ANIMPARAM_BUTTON_LTRIGGER = 0xb,
+        // MPropertyFriendlyName "Right Trigger"
+        ANIMPARAM_BUTTON_RTRIGGER = 0xc,
+    };
+};

sdk/include/source2sdk/animationsystem/AnimParamNetworkSetting.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 3
+    // Alignment: 4
+    // Size: 0x4
+    enum class AnimParamNetworkSetting : std::uint32_t
+    {
+        // MPropertyFriendlyName "Auto"
+        Auto = 0x0,
+        // MPropertyFriendlyName "Always Network"
+        AlwaysNetwork = 0x1,
+        // MPropertyFriendlyName "Never Network"
+        NeverNetwork = 0x2,
+    };
+};

sdk/include/source2sdk/animationsystem/AnimParamType_t.hpp

@@ -0,0 +1,26 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 9
+    // Alignment: 1
+    // Size: 0x1
+    enum class AnimParamType_t : std::uint8_t
+    {
+        ANIMPARAM_UNKNOWN = 0,
+        ANIMPARAM_BOOL = 1,
+        ANIMPARAM_ENUM = 2,
+        ANIMPARAM_INT = 3,
+        ANIMPARAM_FLOAT = 4,
+        ANIMPARAM_VECTOR = 5,
+        ANIMPARAM_QUATERNION = 6,
+        ANIMPARAM_GLOBALSYMBOL = 7,
+        ANIMPARAM_COUNT = 8,
+    };
+};

sdk/include/source2sdk/animationsystem/AnimPoseControl.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 3
+    // Alignment: 4
+    // Size: 0x4
+    enum class AnimPoseControl : std::uint32_t
+    {
+        // MPropertyFriendlyName "None"
+        NoPoseControl = 0x0,
+        // MPropertyFriendlyName "Absolute"
+        AbsolutePoseControl = 0x1,
+        // MPropertyFriendlyName "Relative"
+        RelativePoseControl = 0x2,
+    };
+};

sdk/include/source2sdk/animationsystem/AnimationDecodeDebugDumpElement_t.hpp

@@ -0,0 +1,50 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x70
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    struct AnimationDecodeDebugDumpElement_t
+    {
+    public:
+        int32_t m_nEntityIndex; // 0x0        
+        [[maybe_unused]] std::uint8_t pad_0x04[0x4]; // 0x4
+        CUtlString m_modelName; // 0x8        
+        // m_poseParams has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CUtlString> m_poseParams;
+        char m_poseParams[0x18]; // 0x10        
+        // m_decodeOps has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CUtlString> m_decodeOps;
+        char m_decodeOps[0x18]; // 0x28        
+        // m_internalOps has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CUtlString> m_internalOps;
+        char m_internalOps[0x18]; // 0x40        
+        // m_decodedAnims has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CUtlString> m_decodedAnims;
+        char m_decodedAnims[0x18]; // 0x58        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(AnimationDecodeDebugDumpElement_t, m_nEntityIndex) == 0x0);
+    static_assert(offsetof(AnimationDecodeDebugDumpElement_t, m_modelName) == 0x8);
+    static_assert(offsetof(AnimationDecodeDebugDumpElement_t, m_poseParams) == 0x10);
+    static_assert(offsetof(AnimationDecodeDebugDumpElement_t, m_decodeOps) == 0x28);
+    static_assert(offsetof(AnimationDecodeDebugDumpElement_t, m_internalOps) == 0x40);
+    static_assert(offsetof(AnimationDecodeDebugDumpElement_t, m_decodedAnims) == 0x58);
+    
+    static_assert(sizeof(AnimationDecodeDebugDumpElement_t) == 0x70);
+};

sdk/include/source2sdk/animationsystem/AnimationDecodeDebugDump_t.hpp

@@ -0,0 +1,38 @@
+#pragma once
+#include "source2sdk/animationsystem/AnimationDecodeDebugDumpElement_t.hpp"
+#include "source2sdk/animationsystem/AnimationProcessingType_t.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x20
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    struct AnimationDecodeDebugDump_t
+    {
+    public:
+        animationsystem::AnimationProcessingType_t m_processingType; // 0x0        
+        [[maybe_unused]] std::uint8_t pad_0x04[0x4]; // 0x4
+        // m_elems has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::AnimationDecodeDebugDumpElement_t> m_elems;
+        char m_elems[0x18]; // 0x8        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(AnimationDecodeDebugDump_t, m_processingType) == 0x0);
+    static_assert(offsetof(AnimationDecodeDebugDump_t, m_elems) == 0x8);
+    
+    static_assert(sizeof(AnimationDecodeDebugDump_t) == 0x20);
+};

sdk/include/source2sdk/animationsystem/AnimationProcessingType_t.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 6
+    // Alignment: 4
+    // Size: 0x4
+    enum class AnimationProcessingType_t : std::uint32_t
+    {
+        ANIMATION_PROCESSING_SERVER_SIMULATION = 0x0,
+        ANIMATION_PROCESSING_CLIENT_SIMULATION = 0x1,
+        ANIMATION_PROCESSING_CLIENT_PREDICTION = 0x2,
+        ANIMATION_PROCESSING_CLIENT_INTERPOLATION = 0x3,
+        ANIMATION_PROCESSING_CLIENT_RENDER = 0x4,
+        ANIMATION_PROCESSING_MAX = 0x5,
+    };
+};

sdk/include/source2sdk/animationsystem/AnimationSnapshotBase_t.hpp

@@ -0,0 +1,59 @@
+#pragma once
+#include "source2sdk/animationsystem/AnimationDecodeDebugDumpElement_t.hpp"
+#include "source2sdk/animationsystem/AnimationSnapshotType_t.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x10
+    // Alignment: 0x10
+    // Standard-layout class: true
+    // Size: 0x110
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    struct AnimationSnapshotBase_t
+    {
+    public:
+        float m_flRealTime; // 0x0        
+        [[maybe_unused]] std::uint8_t pad_0x04[0xc]; // 0x4
+        matrix3x4a_t m_rootToWorld; // 0x10        
+        bool m_bBonesInWorldSpace; // 0x40        
+        [[maybe_unused]] std::uint8_t pad_0x41[0x7]; // 0x41
+        // m_boneSetupMask has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<uint32_t> m_boneSetupMask;
+        char m_boneSetupMask[0x18]; // 0x48        
+        // m_boneTransforms has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<matrix3x4a_t> m_boneTransforms;
+        char m_boneTransforms[0x18]; // 0x60        
+        // m_flexControllers has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<float> m_flexControllers;
+        char m_flexControllers[0x18]; // 0x78        
+        animationsystem::AnimationSnapshotType_t m_SnapshotType; // 0x90        
+        bool m_bHasDecodeDump; // 0x94        
+        [[maybe_unused]] std::uint8_t pad_0x95[0x3]; // 0x95
+        animationsystem::AnimationDecodeDebugDumpElement_t m_DecodeDump; // 0x98        
+        [[maybe_unused]] std::uint8_t pad_0x108[0x8];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(AnimationSnapshotBase_t, m_flRealTime) == 0x0);
+    static_assert(offsetof(AnimationSnapshotBase_t, m_rootToWorld) == 0x10);
+    static_assert(offsetof(AnimationSnapshotBase_t, m_bBonesInWorldSpace) == 0x40);
+    static_assert(offsetof(AnimationSnapshotBase_t, m_boneSetupMask) == 0x48);
+    static_assert(offsetof(AnimationSnapshotBase_t, m_boneTransforms) == 0x60);
+    static_assert(offsetof(AnimationSnapshotBase_t, m_flexControllers) == 0x78);
+    static_assert(offsetof(AnimationSnapshotBase_t, m_SnapshotType) == 0x90);
+    static_assert(offsetof(AnimationSnapshotBase_t, m_bHasDecodeDump) == 0x94);
+    static_assert(offsetof(AnimationSnapshotBase_t, m_DecodeDump) == 0x98);
+    
+    static_assert(sizeof(AnimationSnapshotBase_t) == 0x110);
+};

sdk/include/source2sdk/animationsystem/AnimationSnapshotType_t.hpp

@@ -0,0 +1,24 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 7
+    // Alignment: 4
+    // Size: 0x4
+    enum class AnimationSnapshotType_t : std::uint32_t
+    {
+        ANIMATION_SNAPSHOT_SERVER_SIMULATION = 0x0,
+        ANIMATION_SNAPSHOT_CLIENT_SIMULATION = 0x1,
+        ANIMATION_SNAPSHOT_CLIENT_PREDICTION = 0x2,
+        ANIMATION_SNAPSHOT_CLIENT_INTERPOLATION = 0x3,
+        ANIMATION_SNAPSHOT_CLIENT_RENDER = 0x4,
+        ANIMATION_SNAPSHOT_FINAL_COMPOSITE = 0x5,
+        ANIMATION_SNAPSHOT_MAX = 0x6,
+    };
+};

sdk/include/source2sdk/animationsystem/AnimationSnapshot_t.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#include "source2sdk/animationsystem/AnimationSnapshotBase_t.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x10
+    // Alignment: 0x10
+    // Standard-layout class: false
+    // Size: 0x120
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    struct AnimationSnapshot_t : public animationsystem::AnimationSnapshotBase_t
+    {
+    public:
+        int32_t m_nEntIndex; // 0x110        
+        [[maybe_unused]] std::uint8_t pad_0x114[0x4]; // 0x114
+        CUtlString m_modelName; // 0x118        
+    };
+    #pragma pack(pop)
+    
+    // Cannot assert offsets of fields in AnimationSnapshot_t because it is not a standard-layout class
+    static_assert(sizeof(AnimationSnapshot_t) == 0x120);
+};

sdk/include/source2sdk/animationsystem/BoneTransformSpace_t.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 4
+    // Alignment: 4
+    // Size: 0x4
+    enum class BoneTransformSpace_t : std::uint32_t
+    {
+        // MPropertyFriendlyName "Invalid"
+        BoneTransformSpace_Invalid = 0xffffffff,
+        // MPropertyFriendlyName "Parent Space"
+        BoneTransformSpace_Parent = 0x0,
+        // MPropertyFriendlyName "Model Space"
+        BoneTransformSpace_Model = 0x1,
+        // MPropertyFriendlyName "World Space"
+        BoneTransformSpace_World = 0x2,
+    };
+};

sdk/include/source2sdk/animationsystem/CAnimActivity.hpp

@@ -0,0 +1,38 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x20
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimActivity
+    {
+    public:
+        CBufferString m_name; // 0x0        
+        int32_t m_nActivity; // 0x10        
+        int32_t m_nFlags; // 0x14        
+        int32_t m_nWeight; // 0x18        
+        [[maybe_unused]] std::uint8_t pad_0x1c[0x4];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimActivity, m_name) == 0x0);
+    static_assert(offsetof(CAnimActivity, m_nActivity) == 0x10);
+    static_assert(offsetof(CAnimActivity, m_nFlags) == 0x14);
+    static_assert(offsetof(CAnimActivity, m_nWeight) == 0x18);
+    
+    static_assert(sizeof(CAnimActivity) == 0x20);
+};

sdk/include/source2sdk/animationsystem/CAnimBone.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x48
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimBone
+    {
+    public:
+        CBufferString m_name; // 0x0        
+        int32_t m_parent; // 0x10        
+        Vector m_pos; // 0x14        
+        QuaternionStorage m_quat; // 0x20        
+        float m_scale; // 0x30        
+        QuaternionStorage m_qAlignment; // 0x34        
+        int32_t m_flags; // 0x44        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimBone, m_name) == 0x0);
+    static_assert(offsetof(CAnimBone, m_parent) == 0x10);
+    static_assert(offsetof(CAnimBone, m_pos) == 0x14);
+    static_assert(offsetof(CAnimBone, m_quat) == 0x20);
+    static_assert(offsetof(CAnimBone, m_scale) == 0x30);
+    static_assert(offsetof(CAnimBone, m_qAlignment) == 0x34);
+    static_assert(offsetof(CAnimBone, m_flags) == 0x44);
+    
+    static_assert(sizeof(CAnimBone) == 0x48);
+};

sdk/include/source2sdk/animationsystem/CAnimBoneDifference.hpp

@@ -0,0 +1,40 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x30
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimBoneDifference
+    {
+    public:
+        CBufferString m_name; // 0x0        
+        CBufferString m_parent; // 0x10        
+        Vector m_posError; // 0x20        
+        bool m_bHasRotation; // 0x2c        
+        bool m_bHasMovement; // 0x2d        
+        [[maybe_unused]] std::uint8_t pad_0x2e[0x2];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimBoneDifference, m_name) == 0x0);
+    static_assert(offsetof(CAnimBoneDifference, m_parent) == 0x10);
+    static_assert(offsetof(CAnimBoneDifference, m_posError) == 0x20);
+    static_assert(offsetof(CAnimBoneDifference, m_bHasRotation) == 0x2c);
+    static_assert(offsetof(CAnimBoneDifference, m_bHasMovement) == 0x2d);
+    
+    static_assert(sizeof(CAnimBoneDifference) == 0x30);
+};

sdk/include/source2sdk/animationsystem/CAnimData.hpp

@@ -0,0 +1,51 @@
+#pragma once
+#include "source2sdk/animationsystem/CAnimDecoder.hpp"
+#include "source2sdk/animationsystem/CAnimDesc.hpp"
+#include "source2sdk/animationsystem/CAnimFrameSegment.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x70
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimData
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x10]; // 0x0
+        CBufferString m_name; // 0x10        
+        // m_animArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimDesc> m_animArray;
+        char m_animArray[0x18]; // 0x20        
+        // m_decoderArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimDecoder> m_decoderArray;
+        char m_decoderArray[0x18]; // 0x38        
+        int32_t m_nMaxUniqueFrameIndex; // 0x50        
+        [[maybe_unused]] std::uint8_t pad_0x54[0x4]; // 0x54
+        // m_segmentArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimFrameSegment> m_segmentArray;
+        char m_segmentArray[0x18]; // 0x58        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimData, m_name) == 0x10);
+    static_assert(offsetof(CAnimData, m_animArray) == 0x20);
+    static_assert(offsetof(CAnimData, m_decoderArray) == 0x38);
+    static_assert(offsetof(CAnimData, m_nMaxUniqueFrameIndex) == 0x50);
+    static_assert(offsetof(CAnimData, m_segmentArray) == 0x58);
+    
+    static_assert(sizeof(CAnimData) == 0x70);
+};

sdk/include/source2sdk/animationsystem/CAnimDataChannelDesc.hpp

@@ -0,0 +1,53 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x90
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimDataChannelDesc
+    {
+    public:
+        CBufferString m_szChannelClass; // 0x0        
+        CBufferString m_szVariableName; // 0x10        
+        int32_t m_nFlags; // 0x20        
+        int32_t m_nType; // 0x24        
+        CBufferString m_szGrouping; // 0x28        
+        CBufferString m_szDescription; // 0x38        
+        // m_szElementNameArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CBufferString> m_szElementNameArray;
+        char m_szElementNameArray[0x18]; // 0x48        
+        // m_nElementIndexArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<int32_t> m_nElementIndexArray;
+        char m_nElementIndexArray[0x18]; // 0x60        
+        // m_nElementMaskArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<uint32_t> m_nElementMaskArray;
+        char m_nElementMaskArray[0x18]; // 0x78        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimDataChannelDesc, m_szChannelClass) == 0x0);
+    static_assert(offsetof(CAnimDataChannelDesc, m_szVariableName) == 0x10);
+    static_assert(offsetof(CAnimDataChannelDesc, m_nFlags) == 0x20);
+    static_assert(offsetof(CAnimDataChannelDesc, m_nType) == 0x24);
+    static_assert(offsetof(CAnimDataChannelDesc, m_szGrouping) == 0x28);
+    static_assert(offsetof(CAnimDataChannelDesc, m_szDescription) == 0x38);
+    static_assert(offsetof(CAnimDataChannelDesc, m_szElementNameArray) == 0x48);
+    static_assert(offsetof(CAnimDataChannelDesc, m_nElementIndexArray) == 0x60);
+    static_assert(offsetof(CAnimDataChannelDesc, m_nElementMaskArray) == 0x78);
+    
+    static_assert(sizeof(CAnimDataChannelDesc) == 0x90);
+};

sdk/include/source2sdk/animationsystem/CAnimDecoder.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x18
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimDecoder
+    {
+    public:
+        CBufferString m_szName; // 0x0        
+        int32_t m_nVersion; // 0x10        
+        int32_t m_nType; // 0x14        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimDecoder, m_szName) == 0x0);
+    static_assert(offsetof(CAnimDecoder, m_nVersion) == 0x10);
+    static_assert(offsetof(CAnimDecoder, m_nType) == 0x14);
+    
+    static_assert(sizeof(CAnimDecoder) == 0x18);
+};

sdk/include/source2sdk/animationsystem/CAnimDesc.hpp

@@ -0,0 +1,81 @@
+#pragma once
+#include "source2sdk/animationsystem/CAnimActivity.hpp"
+#include "source2sdk/animationsystem/CAnimDesc_Flag.hpp"
+#include "source2sdk/animationsystem/CAnimEncodedFrames.hpp"
+#include "source2sdk/animationsystem/CAnimEventDefinition.hpp"
+#include "source2sdk/animationsystem/CAnimLocalHierarchy.hpp"
+#include "source2sdk/animationsystem/CAnimMovement.hpp"
+#include "source2sdk/animationsystem/CAnimSequenceParams.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x10
+    // Alignment: 0x10
+    // Standard-layout class: true
+    // Size: 0x1d0
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimDesc
+    {
+    public:
+        CBufferString m_name; // 0x0        
+        animationsystem::CAnimDesc_Flag m_flags; // 0x10        
+        float fps; // 0x18        
+        [[maybe_unused]] std::uint8_t pad_0x1c[0x4]; // 0x1c
+        // metadata: MKV3TransferName "m_pData"
+        animationsystem::CAnimEncodedFrames m_Data; // 0x20        
+        // m_movementArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimMovement> m_movementArray;
+        char m_movementArray[0x18]; // 0xf8        
+        CTransform m_xInitialOffset; // 0x110        
+        // m_eventArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimEventDefinition> m_eventArray;
+        char m_eventArray[0x18]; // 0x130        
+        // m_activityArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimActivity> m_activityArray;
+        char m_activityArray[0x18]; // 0x148        
+        // m_hierarchyArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimLocalHierarchy> m_hierarchyArray;
+        char m_hierarchyArray[0x18]; // 0x160        
+        float framestalltime; // 0x178        
+        Vector m_vecRootMin; // 0x17c        
+        Vector m_vecRootMax; // 0x188        
+        [[maybe_unused]] std::uint8_t pad_0x194[0x4]; // 0x194
+        // m_vecBoneWorldMin has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<Vector> m_vecBoneWorldMin;
+        char m_vecBoneWorldMin[0x18]; // 0x198        
+        // m_vecBoneWorldMax has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<Vector> m_vecBoneWorldMax;
+        char m_vecBoneWorldMax[0x18]; // 0x1b0        
+        animationsystem::CAnimSequenceParams m_sequenceParams; // 0x1c8        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimDesc, m_name) == 0x0);
+    static_assert(offsetof(CAnimDesc, m_flags) == 0x10);
+    static_assert(offsetof(CAnimDesc, fps) == 0x18);
+    static_assert(offsetof(CAnimDesc, m_Data) == 0x20);
+    static_assert(offsetof(CAnimDesc, m_movementArray) == 0xf8);
+    static_assert(offsetof(CAnimDesc, m_xInitialOffset) == 0x110);
+    static_assert(offsetof(CAnimDesc, m_eventArray) == 0x130);
+    static_assert(offsetof(CAnimDesc, m_activityArray) == 0x148);
+    static_assert(offsetof(CAnimDesc, m_hierarchyArray) == 0x160);
+    static_assert(offsetof(CAnimDesc, framestalltime) == 0x178);
+    static_assert(offsetof(CAnimDesc, m_vecRootMin) == 0x17c);
+    static_assert(offsetof(CAnimDesc, m_vecRootMax) == 0x188);
+    static_assert(offsetof(CAnimDesc, m_vecBoneWorldMin) == 0x198);
+    static_assert(offsetof(CAnimDesc, m_vecBoneWorldMax) == 0x1b0);
+    static_assert(offsetof(CAnimDesc, m_sequenceParams) == 0x1c8);
+    
+    static_assert(sizeof(CAnimDesc) == 0x1d0);
+};

sdk/include/source2sdk/animationsystem/CAnimDesc_Flag.hpp

@@ -0,0 +1,46 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x1
+    // Alignment: 0x1
+    // Standard-layout class: true
+    // Size: 0x8
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimDesc_Flag
+    {
+    public:
+        bool m_bLooping; // 0x0        
+        bool m_bAllZeros; // 0x1        
+        bool m_bHidden; // 0x2        
+        bool m_bDelta; // 0x3        
+        bool m_bLegacyWorldspace; // 0x4        
+        bool m_bModelDoc; // 0x5        
+        bool m_bImplicitSeqIgnoreDelta; // 0x6        
+        bool m_bAnimGraphAdditive; // 0x7        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimDesc_Flag, m_bLooping) == 0x0);
+    static_assert(offsetof(CAnimDesc_Flag, m_bAllZeros) == 0x1);
+    static_assert(offsetof(CAnimDesc_Flag, m_bHidden) == 0x2);
+    static_assert(offsetof(CAnimDesc_Flag, m_bDelta) == 0x3);
+    static_assert(offsetof(CAnimDesc_Flag, m_bLegacyWorldspace) == 0x4);
+    static_assert(offsetof(CAnimDesc_Flag, m_bModelDoc) == 0x5);
+    static_assert(offsetof(CAnimDesc_Flag, m_bImplicitSeqIgnoreDelta) == 0x6);
+    static_assert(offsetof(CAnimDesc_Flag, m_bAnimGraphAdditive) == 0x7);
+    
+    static_assert(sizeof(CAnimDesc_Flag) == 0x8);
+};

sdk/include/source2sdk/animationsystem/CAnimEncodeDifference.hpp

@@ -0,0 +1,60 @@
+#pragma once
+#include "source2sdk/animationsystem/CAnimBoneDifference.hpp"
+#include "source2sdk/animationsystem/CAnimMorphDifference.hpp"
+#include "source2sdk/animationsystem/CAnimUserDifference.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0xa8
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimEncodeDifference
+    {
+    public:
+        // m_boneArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimBoneDifference> m_boneArray;
+        char m_boneArray[0x18]; // 0x0        
+        // m_morphArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimMorphDifference> m_morphArray;
+        char m_morphArray[0x18]; // 0x18        
+        // m_userArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimUserDifference> m_userArray;
+        char m_userArray[0x18]; // 0x30        
+        // m_bHasRotationBitArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<uint8_t> m_bHasRotationBitArray;
+        char m_bHasRotationBitArray[0x18]; // 0x48        
+        // m_bHasMovementBitArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<uint8_t> m_bHasMovementBitArray;
+        char m_bHasMovementBitArray[0x18]; // 0x60        
+        // m_bHasMorphBitArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<uint8_t> m_bHasMorphBitArray;
+        char m_bHasMorphBitArray[0x18]; // 0x78        
+        // m_bHasUserBitArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<uint8_t> m_bHasUserBitArray;
+        char m_bHasUserBitArray[0x18]; // 0x90        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimEncodeDifference, m_boneArray) == 0x0);
+    static_assert(offsetof(CAnimEncodeDifference, m_morphArray) == 0x18);
+    static_assert(offsetof(CAnimEncodeDifference, m_userArray) == 0x30);
+    static_assert(offsetof(CAnimEncodeDifference, m_bHasRotationBitArray) == 0x48);
+    static_assert(offsetof(CAnimEncodeDifference, m_bHasMovementBitArray) == 0x60);
+    static_assert(offsetof(CAnimEncodeDifference, m_bHasMorphBitArray) == 0x78);
+    static_assert(offsetof(CAnimEncodeDifference, m_bHasUserBitArray) == 0x90);
+    
+    static_assert(sizeof(CAnimEncodeDifference) == 0xa8);
+};

sdk/include/source2sdk/animationsystem/CAnimEncodedFrames.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include "source2sdk/animationsystem/CAnimEncodeDifference.hpp"
+#include "source2sdk/animationsystem/CAnimFrameBlockAnim.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0xd8
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimEncodedFrames
+    {
+    public:
+        CBufferString m_fileName; // 0x0        
+        int32_t m_nFrames; // 0x10        
+        int32_t m_nFramesPerBlock; // 0x14        
+        // m_frameblockArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimFrameBlockAnim> m_frameblockArray;
+        char m_frameblockArray[0x18]; // 0x18        
+        animationsystem::CAnimEncodeDifference m_usageDifferences; // 0x30        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimEncodedFrames, m_fileName) == 0x0);
+    static_assert(offsetof(CAnimEncodedFrames, m_nFrames) == 0x10);
+    static_assert(offsetof(CAnimEncodedFrames, m_nFramesPerBlock) == 0x14);
+    static_assert(offsetof(CAnimEncodedFrames, m_frameblockArray) == 0x18);
+    static_assert(offsetof(CAnimEncodedFrames, m_usageDifferences) == 0x30);
+    
+    static_assert(sizeof(CAnimEncodedFrames) == 0xd8);
+};

sdk/include/source2sdk/animationsystem/CAnimEnum.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: unknown
+    // Alignment: 0x1
+    // Standard-layout class: true
+    // Size: 0x1
+    // Has Trivial Destructor
+    // 
+    // static metadata: MPropertyEditClassAsString
+    #pragma pack(push, 1)
+    class CAnimEnum
+    {
+    public:
+        uint8_t m_value; // 0x0        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimEnum, m_value) == 0x0);
+    
+    static_assert(sizeof(CAnimEnum) == 0x1);
+};

sdk/include/source2sdk/animationsystem/CAnimEventDefinition.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x40
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimEventDefinition
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x8]; // 0x0
+        int32_t m_nFrame; // 0x8        
+        int32_t m_nEndFrame; // 0xc        
+        float m_flCycle; // 0x10        
+        float m_flDuration; // 0x14        
+        KeyValues3 m_EventData; // 0x18        
+        // metadata: MKV3TransferName "m_sOptions"
+        CBufferString m_sLegacyOptions; // 0x28        
+        CGlobalSymbol m_sEventName; // 0x38        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimEventDefinition, m_nFrame) == 0x8);
+    static_assert(offsetof(CAnimEventDefinition, m_nEndFrame) == 0xc);
+    static_assert(offsetof(CAnimEventDefinition, m_flCycle) == 0x10);
+    static_assert(offsetof(CAnimEventDefinition, m_flDuration) == 0x14);
+    static_assert(offsetof(CAnimEventDefinition, m_EventData) == 0x18);
+    static_assert(offsetof(CAnimEventDefinition, m_sLegacyOptions) == 0x28);
+    static_assert(offsetof(CAnimEventDefinition, m_sEventName) == 0x38);
+    
+    static_assert(sizeof(CAnimEventDefinition) == 0x40);
+};

sdk/include/source2sdk/animationsystem/CAnimFrameBlockAnim.hpp

@@ -0,0 +1,37 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x20
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimFrameBlockAnim
+    {
+    public:
+        int32_t m_nStartFrame; // 0x0        
+        int32_t m_nEndFrame; // 0x4        
+        // m_segmentIndexArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<int32_t> m_segmentIndexArray;
+        char m_segmentIndexArray[0x18]; // 0x8        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimFrameBlockAnim, m_nStartFrame) == 0x0);
+    static_assert(offsetof(CAnimFrameBlockAnim, m_nEndFrame) == 0x4);
+    static_assert(offsetof(CAnimFrameBlockAnim, m_segmentIndexArray) == 0x8);
+    
+    static_assert(sizeof(CAnimFrameBlockAnim) == 0x20);
+};

sdk/include/source2sdk/animationsystem/CAnimFrameSegment.hpp

@@ -0,0 +1,38 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x28
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimFrameSegment
+    {
+    public:
+        int32_t m_nUniqueFrameIndex; // 0x0        
+        uint32_t m_nLocalElementMasks; // 0x4        
+        int32_t m_nLocalChannel; // 0x8        
+        [[maybe_unused]] std::uint8_t pad_0x0c[0x4]; // 0xc
+        CUtlBinaryBlock m_container; // 0x10        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimFrameSegment, m_nUniqueFrameIndex) == 0x0);
+    static_assert(offsetof(CAnimFrameSegment, m_nLocalElementMasks) == 0x4);
+    static_assert(offsetof(CAnimFrameSegment, m_nLocalChannel) == 0x8);
+    static_assert(offsetof(CAnimFrameSegment, m_container) == 0x10);
+    
+    static_assert(sizeof(CAnimFrameSegment) == 0x28);
+};

sdk/include/source2sdk/animationsystem/CAnimKeyData.hpp

@@ -0,0 +1,53 @@
+#pragma once
+#include "source2sdk/animationsystem/CAnimBone.hpp"
+#include "source2sdk/animationsystem/CAnimDataChannelDesc.hpp"
+#include "source2sdk/animationsystem/CAnimUser.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x78
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimKeyData
+    {
+    public:
+        CBufferString m_name; // 0x0        
+        // m_boneArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimBone> m_boneArray;
+        char m_boneArray[0x18]; // 0x10        
+        // m_userArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimUser> m_userArray;
+        char m_userArray[0x18]; // 0x28        
+        // m_morphArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CBufferString> m_morphArray;
+        char m_morphArray[0x18]; // 0x40        
+        int32_t m_nChannelElements; // 0x58        
+        [[maybe_unused]] std::uint8_t pad_0x5c[0x4]; // 0x5c
+        // m_dataChannelArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimDataChannelDesc> m_dataChannelArray;
+        char m_dataChannelArray[0x18]; // 0x60        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimKeyData, m_name) == 0x0);
+    static_assert(offsetof(CAnimKeyData, m_boneArray) == 0x10);
+    static_assert(offsetof(CAnimKeyData, m_userArray) == 0x28);
+    static_assert(offsetof(CAnimKeyData, m_morphArray) == 0x40);
+    static_assert(offsetof(CAnimKeyData, m_nChannelElements) == 0x58);
+    static_assert(offsetof(CAnimKeyData, m_dataChannelArray) == 0x60);
+    
+    static_assert(sizeof(CAnimKeyData) == 0x78);
+};

sdk/include/source2sdk/animationsystem/CAnimLocalHierarchy.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x30
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimLocalHierarchy
+    {
+    public:
+        CBufferString m_sBone; // 0x0        
+        CBufferString m_sNewParent; // 0x10        
+        int32_t m_nStartFrame; // 0x20        
+        int32_t m_nPeakFrame; // 0x24        
+        int32_t m_nTailFrame; // 0x28        
+        int32_t m_nEndFrame; // 0x2c        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimLocalHierarchy, m_sBone) == 0x0);
+    static_assert(offsetof(CAnimLocalHierarchy, m_sNewParent) == 0x10);
+    static_assert(offsetof(CAnimLocalHierarchy, m_nStartFrame) == 0x20);
+    static_assert(offsetof(CAnimLocalHierarchy, m_nPeakFrame) == 0x24);
+    static_assert(offsetof(CAnimLocalHierarchy, m_nTailFrame) == 0x28);
+    static_assert(offsetof(CAnimLocalHierarchy, m_nEndFrame) == 0x2c);
+    
+    static_assert(sizeof(CAnimLocalHierarchy) == 0x30);
+};

sdk/include/source2sdk/animationsystem/CAnimMorphDifference.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x10
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimMorphDifference
+    {
+    public:
+        CBufferString m_name; // 0x0        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimMorphDifference, m_name) == 0x0);
+    
+    static_assert(sizeof(CAnimMorphDifference) == 0x10);
+};

sdk/include/source2sdk/animationsystem/CAnimMovement.hpp

@@ -0,0 +1,44 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x4
+    // Alignment: 0x4
+    // Standard-layout class: true
+    // Size: 0x2c
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimMovement
+    {
+    public:
+        int32_t endframe; // 0x0        
+        int32_t motionflags; // 0x4        
+        float v0; // 0x8        
+        float v1; // 0xc        
+        float angle; // 0x10        
+        Vector vector; // 0x14        
+        Vector position; // 0x20        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimMovement, endframe) == 0x0);
+    static_assert(offsetof(CAnimMovement, motionflags) == 0x4);
+    static_assert(offsetof(CAnimMovement, v0) == 0x8);
+    static_assert(offsetof(CAnimMovement, v1) == 0xc);
+    static_assert(offsetof(CAnimMovement, angle) == 0x10);
+    static_assert(offsetof(CAnimMovement, vector) == 0x14);
+    static_assert(offsetof(CAnimMovement, position) == 0x20);
+    
+    static_assert(sizeof(CAnimMovement) == 0x2c);
+};

sdk/include/source2sdk/animationsystem/CAnimSequenceParams.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x4
+    // Alignment: 0x4
+    // Standard-layout class: true
+    // Size: 0x8
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimSequenceParams
+    {
+    public:
+        float m_flFadeInTime; // 0x0        
+        float m_flFadeOutTime; // 0x4        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimSequenceParams, m_flFadeInTime) == 0x0);
+    static_assert(offsetof(CAnimSequenceParams, m_flFadeOutTime) == 0x4);
+    
+    static_assert(sizeof(CAnimSequenceParams) == 0x8);
+};

sdk/include/source2sdk/animationsystem/CAnimUser.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x18
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimUser
+    {
+    public:
+        CBufferString m_name; // 0x0        
+        int32_t m_nType; // 0x10        
+        [[maybe_unused]] std::uint8_t pad_0x14[0x4];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimUser, m_name) == 0x0);
+    static_assert(offsetof(CAnimUser, m_nType) == 0x10);
+    
+    static_assert(sizeof(CAnimUser) == 0x18);
+};

sdk/include/source2sdk/animationsystem/CAnimUserDifference.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x18
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimUserDifference
+    {
+    public:
+        CBufferString m_name; // 0x0        
+        int32_t m_nType; // 0x10        
+        [[maybe_unused]] std::uint8_t pad_0x14[0x4];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimUserDifference, m_name) == 0x0);
+    static_assert(offsetof(CAnimUserDifference, m_nType) == 0x10);
+    
+    static_assert(sizeof(CAnimUserDifference) == 0x18);
+};

sdk/include/source2sdk/animationsystem/CAnimationGroup.hpp

@@ -0,0 +1,63 @@
+#pragma once
+#include "source2sdk/animationsystem/CAnimKeyData.hpp"
+#include "source2sdk/resourcesystem/InfoForResourceTypeCAnimData.hpp"
+#include "source2sdk/resourcesystem/InfoForResourceTypeCAnimationGroup.hpp"
+#include "source2sdk/resourcesystem/InfoForResourceTypeCSequenceGroupData.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x130
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimationGroup
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x10]; // 0x0
+        uint32_t m_nFlags; // 0x10        
+        [[maybe_unused]] std::uint8_t pad_0x14[0x4]; // 0x14
+        CBufferString m_name; // 0x18        
+        [[maybe_unused]] std::uint8_t pad_0x28[0x38]; // 0x28
+        // metadata: MKV3TransferName "m_localHAnimArray"
+        // m_localHAnimArray_Handle has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CStrongHandle<resourcesystem::InfoForResourceTypeCAnimData>> m_localHAnimArray_Handle;
+        char m_localHAnimArray_Handle[0x18]; // 0x60        
+        // metadata: MKV3TransferName "m_includedGroupArray"
+        // m_includedGroupArray_Handle has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CStrongHandle<resourcesystem::InfoForResourceTypeCAnimationGroup>> m_includedGroupArray_Handle;
+        char m_includedGroupArray_Handle[0x18]; // 0x78        
+        // metadata: MKV3TransferName "m_directHSeqGroup"
+        // m_directHSeqGroup_Handle has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CStrongHandle<resourcesystem::InfoForResourceTypeCSequenceGroupData> m_directHSeqGroup_Handle;
+        char m_directHSeqGroup_Handle[0x8]; // 0x90        
+        animationsystem::CAnimKeyData m_decodeKey; // 0x98        
+        // m_szScripts has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CBufferString> m_szScripts;
+        char m_szScripts[0x18]; // 0x110        
+        [[maybe_unused]] std::uint8_t pad_0x128[0x8];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimationGroup, m_nFlags) == 0x10);
+    static_assert(offsetof(CAnimationGroup, m_name) == 0x18);
+    static_assert(offsetof(CAnimationGroup, m_localHAnimArray_Handle) == 0x60);
+    static_assert(offsetof(CAnimationGroup, m_includedGroupArray_Handle) == 0x78);
+    static_assert(offsetof(CAnimationGroup, m_directHSeqGroup_Handle) == 0x90);
+    static_assert(offsetof(CAnimationGroup, m_decodeKey) == 0x98);
+    static_assert(offsetof(CAnimationGroup, m_szScripts) == 0x110);
+    
+    static_assert(sizeof(CAnimationGroup) == 0x130);
+};

sdk/include/source2sdk/animationsystem/CCompressorGroup.hpp

@@ -0,0 +1,95 @@
+#pragma once
+#include "source2sdk/mathlib_extended/fieldtype_t.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: unknown
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x1a0
+    #pragma pack(push, 1)
+    class CCompressorGroup
+    {
+    public:
+        int32_t m_nTotalElementCount; // 0x0        
+        [[maybe_unused]] std::uint8_t pad_0x04[0x4]; // 0x4
+        // m_szChannelClass has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<char*> m_szChannelClass;
+        char m_szChannelClass[0x18]; // 0x8        
+        // m_szVariableName has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<char*> m_szVariableName;
+        char m_szVariableName[0x18]; // 0x20        
+        // m_nType has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<mathlib_extended::fieldtype_t> m_nType;
+        char m_nType[0x18]; // 0x38        
+        // m_nFlags has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<int32_t> m_nFlags;
+        char m_nFlags[0x18]; // 0x50        
+        // m_szGrouping has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CUtlString> m_szGrouping;
+        char m_szGrouping[0x18]; // 0x68        
+        // m_nCompressorIndex has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<int32_t> m_nCompressorIndex;
+        char m_nCompressorIndex[0x18]; // 0x80        
+        // m_szElementNames has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CUtlVector<char*>> m_szElementNames;
+        char m_szElementNames[0x18]; // 0x98        
+        // m_nElementUniqueID has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CUtlVector<int32_t>> m_nElementUniqueID;
+        char m_nElementUniqueID[0x18]; // 0xb0        
+        // m_nElementMask has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<uint32_t> m_nElementMask;
+        char m_nElementMask[0x18]; // 0xc8        
+        [[maybe_unused]] std::uint8_t pad_0xe0[0x18]; // 0xe0
+        // m_vectorCompressor has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CCompressor<Vector>*> m_vectorCompressor;
+        char m_vectorCompressor[0x18]; // 0xf8        
+        // m_quaternionCompressor has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CCompressor<QuaternionStorage>*> m_quaternionCompressor;
+        char m_quaternionCompressor[0x18]; // 0x110        
+        // m_intCompressor has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CCompressor<int32_t>*> m_intCompressor;
+        char m_intCompressor[0x18]; // 0x128        
+        // m_boolCompressor has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CCompressor<bool>*> m_boolCompressor;
+        char m_boolCompressor[0x18]; // 0x140        
+        // m_colorCompressor has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CCompressor<Color>*> m_colorCompressor;
+        char m_colorCompressor[0x18]; // 0x158        
+        // m_vector2DCompressor has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CCompressor<Vector2D>*> m_vector2DCompressor;
+        char m_vector2DCompressor[0x18]; // 0x170        
+        // m_vector4DCompressor has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CCompressor<Vector4D>*> m_vector4DCompressor;
+        char m_vector4DCompressor[0x18]; // 0x188        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CCompressorGroup, m_nTotalElementCount) == 0x0);
+    static_assert(offsetof(CCompressorGroup, m_szChannelClass) == 0x8);
+    static_assert(offsetof(CCompressorGroup, m_szVariableName) == 0x20);
+    static_assert(offsetof(CCompressorGroup, m_nType) == 0x38);
+    static_assert(offsetof(CCompressorGroup, m_nFlags) == 0x50);
+    static_assert(offsetof(CCompressorGroup, m_szGrouping) == 0x68);
+    static_assert(offsetof(CCompressorGroup, m_nCompressorIndex) == 0x80);
+    static_assert(offsetof(CCompressorGroup, m_szElementNames) == 0x98);
+    static_assert(offsetof(CCompressorGroup, m_nElementUniqueID) == 0xb0);
+    static_assert(offsetof(CCompressorGroup, m_nElementMask) == 0xc8);
+    static_assert(offsetof(CCompressorGroup, m_vectorCompressor) == 0xf8);
+    static_assert(offsetof(CCompressorGroup, m_quaternionCompressor) == 0x110);
+    static_assert(offsetof(CCompressorGroup, m_intCompressor) == 0x128);
+    static_assert(offsetof(CCompressorGroup, m_boolCompressor) == 0x140);
+    static_assert(offsetof(CCompressorGroup, m_colorCompressor) == 0x158);
+    static_assert(offsetof(CCompressorGroup, m_vector2DCompressor) == 0x170);
+    static_assert(offsetof(CCompressorGroup, m_vector4DCompressor) == 0x188);
+    
+    static_assert(sizeof(CCompressorGroup) == 0x1a0);
+};

sdk/include/source2sdk/animationsystem/CMoodVData.hpp

@@ -0,0 +1,49 @@
+#pragma once
+#include "source2sdk/animationsystem/MoodAnimationLayer_t.hpp"
+#include "source2sdk/animationsystem/MoodType_t.hpp"
+#include "source2sdk/resourcesystem/InfoForResourceTypeCModel.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x100
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    // static metadata: MVDataRoot
+    // static metadata: MVDataOverlayType "1"
+    #pragma pack(push, 1)
+    class CMoodVData
+    {
+    public:
+        // metadata: MPropertyDescription "Model to get the animation list from"
+        // metadata: MPropertyAutoRebuildOnChange
+        // m_sModelName has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CResourceNameTyped<CWeakHandle<resourcesystem::InfoForResourceTypeCModel>> m_sModelName;
+        char m_sModelName[0xe0]; // 0x0        
+        // metadata: MPropertyDescription "Type of mood"
+        animationsystem::MoodType_t m_nMoodType; // 0xe0        
+        [[maybe_unused]] std::uint8_t pad_0xe4[0x4]; // 0xe4
+        // metadata: MPropertyDescription "Layers for this mood"
+        // m_animationLayers has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::MoodAnimationLayer_t> m_animationLayers;
+        char m_animationLayers[0x18]; // 0xe8        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CMoodVData, m_sModelName) == 0x0);
+    static_assert(offsetof(CMoodVData, m_nMoodType) == 0xe0);
+    static_assert(offsetof(CMoodVData, m_animationLayers) == 0xe8);
+    
+    static_assert(sizeof(CMoodVData) == 0x100);
+};

sdk/include/source2sdk/animationsystem/CSeqAutoLayer.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#include "source2sdk/animationsystem/CSeqAutoLayerFlag.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x4
+    // Alignment: 0x4
+    // Standard-layout class: true
+    // Size: 0x1c
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqAutoLayer
+    {
+    public:
+        int16_t m_nLocalReference; // 0x0        
+        int16_t m_nLocalPose; // 0x2        
+        animationsystem::CSeqAutoLayerFlag m_flags; // 0x4        
+        float m_start; // 0xc        
+        float m_peak; // 0x10        
+        float m_tail; // 0x14        
+        float m_end; // 0x18        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqAutoLayer, m_nLocalReference) == 0x0);
+    static_assert(offsetof(CSeqAutoLayer, m_nLocalPose) == 0x2);
+    static_assert(offsetof(CSeqAutoLayer, m_flags) == 0x4);
+    static_assert(offsetof(CSeqAutoLayer, m_start) == 0xc);
+    static_assert(offsetof(CSeqAutoLayer, m_peak) == 0x10);
+    static_assert(offsetof(CSeqAutoLayer, m_tail) == 0x14);
+    static_assert(offsetof(CSeqAutoLayer, m_end) == 0x18);
+    
+    static_assert(sizeof(CSeqAutoLayer) == 0x1c);
+};

sdk/include/source2sdk/animationsystem/CSeqAutoLayerFlag.hpp

@@ -0,0 +1,46 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x1
+    // Alignment: 0x1
+    // Standard-layout class: true
+    // Size: 0x8
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqAutoLayerFlag
+    {
+    public:
+        bool m_bPost; // 0x0        
+        bool m_bSpline; // 0x1        
+        bool m_bXFade; // 0x2        
+        bool m_bNoBlend; // 0x3        
+        bool m_bLocal; // 0x4        
+        bool m_bPose; // 0x5        
+        bool m_bFetchFrame; // 0x6        
+        bool m_bSubtract; // 0x7        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqAutoLayerFlag, m_bPost) == 0x0);
+    static_assert(offsetof(CSeqAutoLayerFlag, m_bSpline) == 0x1);
+    static_assert(offsetof(CSeqAutoLayerFlag, m_bXFade) == 0x2);
+    static_assert(offsetof(CSeqAutoLayerFlag, m_bNoBlend) == 0x3);
+    static_assert(offsetof(CSeqAutoLayerFlag, m_bLocal) == 0x4);
+    static_assert(offsetof(CSeqAutoLayerFlag, m_bPose) == 0x5);
+    static_assert(offsetof(CSeqAutoLayerFlag, m_bFetchFrame) == 0x6);
+    static_assert(offsetof(CSeqAutoLayerFlag, m_bSubtract) == 0x7);
+    
+    static_assert(sizeof(CSeqAutoLayerFlag) == 0x8);
+};

sdk/include/source2sdk/animationsystem/CSeqBoneMaskList.hpp

@@ -0,0 +1,46 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x60
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqBoneMaskList
+    {
+    public:
+        CBufferString m_sName; // 0x0        
+        // m_nLocalBoneArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<int16_t> m_nLocalBoneArray;
+        char m_nLocalBoneArray[0x18]; // 0x10        
+        // m_flBoneWeightArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<float> m_flBoneWeightArray;
+        char m_flBoneWeightArray[0x18]; // 0x28        
+        float m_flDefaultMorphCtrlWeight; // 0x40        
+        [[maybe_unused]] std::uint8_t pad_0x44[0x4]; // 0x44
+        // m_morphCtrlWeightArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CUtlPair<CBufferString,float>> m_morphCtrlWeightArray;
+        char m_morphCtrlWeightArray[0x18]; // 0x48        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqBoneMaskList, m_sName) == 0x0);
+    static_assert(offsetof(CSeqBoneMaskList, m_nLocalBoneArray) == 0x10);
+    static_assert(offsetof(CSeqBoneMaskList, m_flBoneWeightArray) == 0x28);
+    static_assert(offsetof(CSeqBoneMaskList, m_flDefaultMorphCtrlWeight) == 0x40);
+    static_assert(offsetof(CSeqBoneMaskList, m_morphCtrlWeightArray) == 0x48);
+    
+    static_assert(sizeof(CSeqBoneMaskList) == 0x60);
+};

sdk/include/source2sdk/animationsystem/CSeqCmdLayer.hpp

@@ -0,0 +1,50 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x4
+    // Alignment: 0x4
+    // Standard-layout class: true
+    // Size: 0x18
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqCmdLayer
+    {
+    public:
+        int16_t m_cmd; // 0x0        
+        int16_t m_nLocalReference; // 0x2        
+        int16_t m_nLocalBonemask; // 0x4        
+        int16_t m_nDstResult; // 0x6        
+        int16_t m_nSrcResult; // 0x8        
+        bool m_bSpline; // 0xa        
+        [[maybe_unused]] std::uint8_t pad_0x0b[0x1]; // 0xb
+        float m_flVar1; // 0xc        
+        float m_flVar2; // 0x10        
+        int16_t m_nLineNumber; // 0x14        
+        [[maybe_unused]] std::uint8_t pad_0x16[0x2];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqCmdLayer, m_cmd) == 0x0);
+    static_assert(offsetof(CSeqCmdLayer, m_nLocalReference) == 0x2);
+    static_assert(offsetof(CSeqCmdLayer, m_nLocalBonemask) == 0x4);
+    static_assert(offsetof(CSeqCmdLayer, m_nDstResult) == 0x6);
+    static_assert(offsetof(CSeqCmdLayer, m_nSrcResult) == 0x8);
+    static_assert(offsetof(CSeqCmdLayer, m_bSpline) == 0xa);
+    static_assert(offsetof(CSeqCmdLayer, m_flVar1) == 0xc);
+    static_assert(offsetof(CSeqCmdLayer, m_flVar2) == 0x10);
+    static_assert(offsetof(CSeqCmdLayer, m_nLineNumber) == 0x14);
+    
+    static_assert(sizeof(CSeqCmdLayer) == 0x18);
+};

sdk/include/source2sdk/animationsystem/CSeqCmdSeqDesc.hpp

@@ -0,0 +1,68 @@
+#pragma once
+#include "source2sdk/animationsystem/CAnimActivity.hpp"
+#include "source2sdk/animationsystem/CAnimEventDefinition.hpp"
+#include "source2sdk/animationsystem/CSeqCmdLayer.hpp"
+#include "source2sdk/animationsystem/CSeqPoseSetting.hpp"
+#include "source2sdk/animationsystem/CSeqSeqDescFlag.hpp"
+#include "source2sdk/animationsystem/CSeqTransition.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x90
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqCmdSeqDesc
+    {
+    public:
+        CBufferString m_sName; // 0x0        
+        animationsystem::CSeqSeqDescFlag m_flags; // 0x10        
+        [[maybe_unused]] std::uint8_t pad_0x1b[0x1]; // 0x1b
+        animationsystem::CSeqTransition m_transition; // 0x1c        
+        int16_t m_nFrameRangeSequence; // 0x24        
+        int16_t m_nFrameCount; // 0x26        
+        float m_flFPS; // 0x28        
+        int16_t m_nSubCycles; // 0x2c        
+        int16_t m_numLocalResults; // 0x2e        
+        // m_cmdLayerArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqCmdLayer> m_cmdLayerArray;
+        char m_cmdLayerArray[0x18]; // 0x30        
+        // m_eventArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimEventDefinition> m_eventArray;
+        char m_eventArray[0x18]; // 0x48        
+        // m_activityArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimActivity> m_activityArray;
+        char m_activityArray[0x18]; // 0x60        
+        // m_poseSettingArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqPoseSetting> m_poseSettingArray;
+        char m_poseSettingArray[0x18]; // 0x78        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqCmdSeqDesc, m_sName) == 0x0);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_flags) == 0x10);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_transition) == 0x1c);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_nFrameRangeSequence) == 0x24);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_nFrameCount) == 0x26);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_flFPS) == 0x28);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_nSubCycles) == 0x2c);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_numLocalResults) == 0x2e);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_cmdLayerArray) == 0x30);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_eventArray) == 0x48);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_activityArray) == 0x60);
+    static_assert(offsetof(CSeqCmdSeqDesc, m_poseSettingArray) == 0x78);
+    
+    static_assert(sizeof(CSeqCmdSeqDesc) == 0x90);
+};

sdk/include/source2sdk/animationsystem/CSeqIKLock.hpp

@@ -0,0 +1,39 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x4
+    // Alignment: 0x4
+    // Standard-layout class: true
+    // Size: 0xc
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqIKLock
+    {
+    public:
+        float m_flPosWeight; // 0x0        
+        float m_flAngleWeight; // 0x4        
+        int16_t m_nLocalBone; // 0x8        
+        bool m_bBonesOrientedAlongPositiveX; // 0xa        
+        [[maybe_unused]] std::uint8_t pad_0x0b[0x1];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqIKLock, m_flPosWeight) == 0x0);
+    static_assert(offsetof(CSeqIKLock, m_flAngleWeight) == 0x4);
+    static_assert(offsetof(CSeqIKLock, m_nLocalBone) == 0x8);
+    static_assert(offsetof(CSeqIKLock, m_bBonesOrientedAlongPositiveX) == 0xa);
+    
+    static_assert(sizeof(CSeqIKLock) == 0xc);
+};

sdk/include/source2sdk/animationsystem/CSeqMultiFetch.hpp

@@ -0,0 +1,58 @@
+#pragma once
+#include "source2sdk/animationsystem/CSeqMultiFetchFlag.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x70
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqMultiFetch
+    {
+    public:
+        animationsystem::CSeqMultiFetchFlag m_flags; // 0x0        
+        [[maybe_unused]] std::uint8_t pad_0x06[0x2]; // 0x6
+        // m_localReferenceArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<int16_t> m_localReferenceArray;
+        char m_localReferenceArray[0x18]; // 0x8        
+        int32_t m_nGroupSize[2]; // 0x20        
+        int32_t m_nLocalPose[2]; // 0x28        
+        // m_poseKeyArray0 has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<float> m_poseKeyArray0;
+        char m_poseKeyArray0[0x18]; // 0x30        
+        // m_poseKeyArray1 has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<float> m_poseKeyArray1;
+        char m_poseKeyArray1[0x18]; // 0x48        
+        int32_t m_nLocalCyclePoseParameter; // 0x60        
+        bool m_bCalculatePoseParameters; // 0x64        
+        bool m_bFixedBlendWeight; // 0x65        
+        [[maybe_unused]] std::uint8_t pad_0x66[0x2]; // 0x66
+        float m_flFixedBlendWeightVals[2]; // 0x68        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqMultiFetch, m_flags) == 0x0);
+    static_assert(offsetof(CSeqMultiFetch, m_localReferenceArray) == 0x8);
+    static_assert(offsetof(CSeqMultiFetch, m_nGroupSize) == 0x20);
+    static_assert(offsetof(CSeqMultiFetch, m_nLocalPose) == 0x28);
+    static_assert(offsetof(CSeqMultiFetch, m_poseKeyArray0) == 0x30);
+    static_assert(offsetof(CSeqMultiFetch, m_poseKeyArray1) == 0x48);
+    static_assert(offsetof(CSeqMultiFetch, m_nLocalCyclePoseParameter) == 0x60);
+    static_assert(offsetof(CSeqMultiFetch, m_bCalculatePoseParameters) == 0x64);
+    static_assert(offsetof(CSeqMultiFetch, m_bFixedBlendWeight) == 0x65);
+    static_assert(offsetof(CSeqMultiFetch, m_flFixedBlendWeightVals) == 0x68);
+    
+    static_assert(sizeof(CSeqMultiFetch) == 0x70);
+};

sdk/include/source2sdk/animationsystem/CSeqMultiFetchFlag.hpp

@@ -0,0 +1,42 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x1
+    // Alignment: 0x1
+    // Standard-layout class: true
+    // Size: 0x6
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqMultiFetchFlag
+    {
+    public:
+        bool m_bRealtime; // 0x0        
+        bool m_bCylepose; // 0x1        
+        bool m_b0D; // 0x2        
+        bool m_b1D; // 0x3        
+        bool m_b2D; // 0x4        
+        bool m_b2D_TRI; // 0x5        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqMultiFetchFlag, m_bRealtime) == 0x0);
+    static_assert(offsetof(CSeqMultiFetchFlag, m_bCylepose) == 0x1);
+    static_assert(offsetof(CSeqMultiFetchFlag, m_b0D) == 0x2);
+    static_assert(offsetof(CSeqMultiFetchFlag, m_b1D) == 0x3);
+    static_assert(offsetof(CSeqMultiFetchFlag, m_b2D) == 0x4);
+    static_assert(offsetof(CSeqMultiFetchFlag, m_b2D_TRI) == 0x5);
+    
+    static_assert(sizeof(CSeqMultiFetchFlag) == 0x6);
+};

sdk/include/source2sdk/animationsystem/CSeqPoseParamDesc.hpp

@@ -0,0 +1,40 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x20
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqPoseParamDesc
+    {
+    public:
+        CBufferString m_sName; // 0x0        
+        float m_flStart; // 0x10        
+        float m_flEnd; // 0x14        
+        float m_flLoop; // 0x18        
+        bool m_bLooping; // 0x1c        
+        [[maybe_unused]] std::uint8_t pad_0x1d[0x3];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqPoseParamDesc, m_sName) == 0x0);
+    static_assert(offsetof(CSeqPoseParamDesc, m_flStart) == 0x10);
+    static_assert(offsetof(CSeqPoseParamDesc, m_flEnd) == 0x14);
+    static_assert(offsetof(CSeqPoseParamDesc, m_flLoop) == 0x18);
+    static_assert(offsetof(CSeqPoseParamDesc, m_bLooping) == 0x1c);
+    
+    static_assert(sizeof(CSeqPoseParamDesc) == 0x20);
+};

sdk/include/source2sdk/animationsystem/CSeqPoseSetting.hpp

@@ -0,0 +1,47 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x40
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqPoseSetting
+    {
+    public:
+        CBufferString m_sPoseParameter; // 0x0        
+        CBufferString m_sAttachment; // 0x10        
+        CBufferString m_sReferenceSequence; // 0x20        
+        float m_flValue; // 0x30        
+        bool m_bX; // 0x34        
+        bool m_bY; // 0x35        
+        bool m_bZ; // 0x36        
+        [[maybe_unused]] std::uint8_t pad_0x37[0x1]; // 0x37
+        int32_t m_eType; // 0x38        
+        [[maybe_unused]] std::uint8_t pad_0x3c[0x4];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqPoseSetting, m_sPoseParameter) == 0x0);
+    static_assert(offsetof(CSeqPoseSetting, m_sAttachment) == 0x10);
+    static_assert(offsetof(CSeqPoseSetting, m_sReferenceSequence) == 0x20);
+    static_assert(offsetof(CSeqPoseSetting, m_flValue) == 0x30);
+    static_assert(offsetof(CSeqPoseSetting, m_bX) == 0x34);
+    static_assert(offsetof(CSeqPoseSetting, m_bY) == 0x35);
+    static_assert(offsetof(CSeqPoseSetting, m_bZ) == 0x36);
+    static_assert(offsetof(CSeqPoseSetting, m_eType) == 0x38);
+    
+    static_assert(sizeof(CSeqPoseSetting) == 0x40);
+};

sdk/include/source2sdk/animationsystem/CSeqS1SeqDesc.hpp

@@ -0,0 +1,69 @@
+#pragma once
+#include "source2sdk/animationsystem/CAnimActivity.hpp"
+#include "source2sdk/animationsystem/CSeqAutoLayer.hpp"
+#include "source2sdk/animationsystem/CSeqIKLock.hpp"
+#include "source2sdk/animationsystem/CSeqMultiFetch.hpp"
+#include "source2sdk/animationsystem/CSeqSeqDescFlag.hpp"
+#include "source2sdk/animationsystem/CSeqTransition.hpp"
+#include "source2sdk/modellib/CFootMotion.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x120
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqS1SeqDesc
+    {
+    public:
+        CBufferString m_sName; // 0x0        
+        animationsystem::CSeqSeqDescFlag m_flags; // 0x10        
+        [[maybe_unused]] std::uint8_t pad_0x1b[0x5]; // 0x1b
+        animationsystem::CSeqMultiFetch m_fetch; // 0x20        
+        int32_t m_nLocalWeightlist; // 0x90        
+        [[maybe_unused]] std::uint8_t pad_0x94[0x4]; // 0x94
+        // m_autoLayerArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqAutoLayer> m_autoLayerArray;
+        char m_autoLayerArray[0x18]; // 0x98        
+        // m_IKLockArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqIKLock> m_IKLockArray;
+        char m_IKLockArray[0x18]; // 0xb0        
+        animationsystem::CSeqTransition m_transition; // 0xc8        
+        KeyValues3 m_SequenceKeys; // 0xd0        
+        // metadata: MKV3TransferName "m_keyValueText"
+        CBufferString m_LegacyKeyValueText; // 0xe0        
+        // m_activityArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimActivity> m_activityArray;
+        char m_activityArray[0x18]; // 0xf0        
+        // m_footMotion has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<modellib::CFootMotion> m_footMotion;
+        char m_footMotion[0x18]; // 0x108        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqS1SeqDesc, m_sName) == 0x0);
+    static_assert(offsetof(CSeqS1SeqDesc, m_flags) == 0x10);
+    static_assert(offsetof(CSeqS1SeqDesc, m_fetch) == 0x20);
+    static_assert(offsetof(CSeqS1SeqDesc, m_nLocalWeightlist) == 0x90);
+    static_assert(offsetof(CSeqS1SeqDesc, m_autoLayerArray) == 0x98);
+    static_assert(offsetof(CSeqS1SeqDesc, m_IKLockArray) == 0xb0);
+    static_assert(offsetof(CSeqS1SeqDesc, m_transition) == 0xc8);
+    static_assert(offsetof(CSeqS1SeqDesc, m_SequenceKeys) == 0xd0);
+    static_assert(offsetof(CSeqS1SeqDesc, m_LegacyKeyValueText) == 0xe0);
+    static_assert(offsetof(CSeqS1SeqDesc, m_activityArray) == 0xf0);
+    static_assert(offsetof(CSeqS1SeqDesc, m_footMotion) == 0x108);
+    
+    static_assert(sizeof(CSeqS1SeqDesc) == 0x120);
+};

sdk/include/source2sdk/animationsystem/CSeqScaleSet.hpp

@@ -0,0 +1,44 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x50
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqScaleSet
+    {
+    public:
+        CBufferString m_sName; // 0x0        
+        bool m_bRootOffset; // 0x10        
+        [[maybe_unused]] std::uint8_t pad_0x11[0x3]; // 0x11
+        Vector m_vRootOffset; // 0x14        
+        // m_nLocalBoneArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<int16_t> m_nLocalBoneArray;
+        char m_nLocalBoneArray[0x18]; // 0x20        
+        // m_flBoneScaleArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<float> m_flBoneScaleArray;
+        char m_flBoneScaleArray[0x18]; // 0x38        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqScaleSet, m_sName) == 0x0);
+    static_assert(offsetof(CSeqScaleSet, m_bRootOffset) == 0x10);
+    static_assert(offsetof(CSeqScaleSet, m_vRootOffset) == 0x14);
+    static_assert(offsetof(CSeqScaleSet, m_nLocalBoneArray) == 0x20);
+    static_assert(offsetof(CSeqScaleSet, m_flBoneScaleArray) == 0x38);
+    
+    static_assert(sizeof(CSeqScaleSet) == 0x50);
+};

sdk/include/source2sdk/animationsystem/CSeqSeqDescFlag.hpp

@@ -0,0 +1,52 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x1
+    // Alignment: 0x1
+    // Standard-layout class: true
+    // Size: 0xb
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqSeqDescFlag
+    {
+    public:
+        bool m_bLooping; // 0x0        
+        bool m_bSnap; // 0x1        
+        bool m_bAutoplay; // 0x2        
+        bool m_bPost; // 0x3        
+        bool m_bHidden; // 0x4        
+        bool m_bMulti; // 0x5        
+        bool m_bLegacyDelta; // 0x6        
+        bool m_bLegacyWorldspace; // 0x7        
+        bool m_bLegacyCyclepose; // 0x8        
+        bool m_bLegacyRealtime; // 0x9        
+        bool m_bModelDoc; // 0xa        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqSeqDescFlag, m_bLooping) == 0x0);
+    static_assert(offsetof(CSeqSeqDescFlag, m_bSnap) == 0x1);
+    static_assert(offsetof(CSeqSeqDescFlag, m_bAutoplay) == 0x2);
+    static_assert(offsetof(CSeqSeqDescFlag, m_bPost) == 0x3);
+    static_assert(offsetof(CSeqSeqDescFlag, m_bHidden) == 0x4);
+    static_assert(offsetof(CSeqSeqDescFlag, m_bMulti) == 0x5);
+    static_assert(offsetof(CSeqSeqDescFlag, m_bLegacyDelta) == 0x6);
+    static_assert(offsetof(CSeqSeqDescFlag, m_bLegacyWorldspace) == 0x7);
+    static_assert(offsetof(CSeqSeqDescFlag, m_bLegacyCyclepose) == 0x8);
+    static_assert(offsetof(CSeqSeqDescFlag, m_bLegacyRealtime) == 0x9);
+    static_assert(offsetof(CSeqSeqDescFlag, m_bModelDoc) == 0xa);
+    
+    static_assert(sizeof(CSeqSeqDescFlag) == 0xb);
+};

sdk/include/source2sdk/animationsystem/CSeqSynthAnimDesc.hpp

@@ -0,0 +1,47 @@
+#pragma once
+#include "source2sdk/animationsystem/CAnimActivity.hpp"
+#include "source2sdk/animationsystem/CSeqSeqDescFlag.hpp"
+#include "source2sdk/animationsystem/CSeqTransition.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x40
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqSynthAnimDesc
+    {
+    public:
+        CBufferString m_sName; // 0x0        
+        animationsystem::CSeqSeqDescFlag m_flags; // 0x10        
+        [[maybe_unused]] std::uint8_t pad_0x1b[0x1]; // 0x1b
+        animationsystem::CSeqTransition m_transition; // 0x1c        
+        int16_t m_nLocalBaseReference; // 0x24        
+        int16_t m_nLocalBoneMask; // 0x26        
+        // m_activityArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CAnimActivity> m_activityArray;
+        char m_activityArray[0x18]; // 0x28        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqSynthAnimDesc, m_sName) == 0x0);
+    static_assert(offsetof(CSeqSynthAnimDesc, m_flags) == 0x10);
+    static_assert(offsetof(CSeqSynthAnimDesc, m_transition) == 0x1c);
+    static_assert(offsetof(CSeqSynthAnimDesc, m_nLocalBaseReference) == 0x24);
+    static_assert(offsetof(CSeqSynthAnimDesc, m_nLocalBoneMask) == 0x26);
+    static_assert(offsetof(CSeqSynthAnimDesc, m_activityArray) == 0x28);
+    
+    static_assert(sizeof(CSeqSynthAnimDesc) == 0x40);
+};

sdk/include/source2sdk/animationsystem/CSeqTransition.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x4
+    // Alignment: 0x4
+    // Standard-layout class: true
+    // Size: 0x8
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSeqTransition
+    {
+    public:
+        float m_flFadeInTime; // 0x0        
+        float m_flFadeOutTime; // 0x4        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSeqTransition, m_flFadeInTime) == 0x0);
+    static_assert(offsetof(CSeqTransition, m_flFadeOutTime) == 0x4);
+    
+    static_assert(sizeof(CSeqTransition) == 0x8);
+};

sdk/include/source2sdk/animationsystem/CSequenceGroupData.hpp

@@ -0,0 +1,87 @@
+#pragma once
+#include "source2sdk/animationsystem/CSeqBoneMaskList.hpp"
+#include "source2sdk/animationsystem/CSeqCmdSeqDesc.hpp"
+#include "source2sdk/animationsystem/CSeqIKLock.hpp"
+#include "source2sdk/animationsystem/CSeqPoseParamDesc.hpp"
+#include "source2sdk/animationsystem/CSeqS1SeqDesc.hpp"
+#include "source2sdk/animationsystem/CSeqScaleSet.hpp"
+#include "source2sdk/animationsystem/CSeqSynthAnimDesc.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x138
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CSequenceGroupData
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x10]; // 0x0
+        CBufferString m_sName; // 0x10        
+        uint32_t m_nFlags; // 0x20        
+        [[maybe_unused]] std::uint8_t pad_0x24[0x4]; // 0x24
+        // m_localSequenceNameArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CBufferString> m_localSequenceNameArray;
+        char m_localSequenceNameArray[0x18]; // 0x28        
+        // m_localS1SeqDescArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqS1SeqDesc> m_localS1SeqDescArray;
+        char m_localS1SeqDescArray[0x18]; // 0x40        
+        // m_localMultiSeqDescArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqS1SeqDesc> m_localMultiSeqDescArray;
+        char m_localMultiSeqDescArray[0x18]; // 0x58        
+        // m_localSynthAnimDescArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqSynthAnimDesc> m_localSynthAnimDescArray;
+        char m_localSynthAnimDescArray[0x18]; // 0x70        
+        // m_localCmdSeqDescArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqCmdSeqDesc> m_localCmdSeqDescArray;
+        char m_localCmdSeqDescArray[0x18]; // 0x88        
+        // m_localBoneMaskArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqBoneMaskList> m_localBoneMaskArray;
+        char m_localBoneMaskArray[0x18]; // 0xa0        
+        // m_localScaleSetArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqScaleSet> m_localScaleSetArray;
+        char m_localScaleSetArray[0x18]; // 0xb8        
+        // m_localBoneNameArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CBufferString> m_localBoneNameArray;
+        char m_localBoneNameArray[0x18]; // 0xd0        
+        CBufferString m_localNodeName; // 0xe8        
+        // m_localPoseParamArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqPoseParamDesc> m_localPoseParamArray;
+        char m_localPoseParamArray[0x18]; // 0xf8        
+        KeyValues3 m_keyValues; // 0x110        
+        // m_localIKAutoplayLockArray has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::CSeqIKLock> m_localIKAutoplayLockArray;
+        char m_localIKAutoplayLockArray[0x18]; // 0x120        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CSequenceGroupData, m_sName) == 0x10);
+    static_assert(offsetof(CSequenceGroupData, m_nFlags) == 0x20);
+    static_assert(offsetof(CSequenceGroupData, m_localSequenceNameArray) == 0x28);
+    static_assert(offsetof(CSequenceGroupData, m_localS1SeqDescArray) == 0x40);
+    static_assert(offsetof(CSequenceGroupData, m_localMultiSeqDescArray) == 0x58);
+    static_assert(offsetof(CSequenceGroupData, m_localSynthAnimDescArray) == 0x70);
+    static_assert(offsetof(CSequenceGroupData, m_localCmdSeqDescArray) == 0x88);
+    static_assert(offsetof(CSequenceGroupData, m_localBoneMaskArray) == 0xa0);
+    static_assert(offsetof(CSequenceGroupData, m_localScaleSetArray) == 0xb8);
+    static_assert(offsetof(CSequenceGroupData, m_localBoneNameArray) == 0xd0);
+    static_assert(offsetof(CSequenceGroupData, m_localNodeName) == 0xe8);
+    static_assert(offsetof(CSequenceGroupData, m_localPoseParamArray) == 0xf8);
+    static_assert(offsetof(CSequenceGroupData, m_keyValues) == 0x110);
+    static_assert(offsetof(CSequenceGroupData, m_localIKAutoplayLockArray) == 0x120);
+    
+    static_assert(sizeof(CSequenceGroupData) == 0x138);
+};

sdk/include/source2sdk/animationsystem/FootstepLandedFootSoundType_t.hpp

@@ -0,0 +1,20 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 3
+    // Alignment: 4
+    // Size: 0x4
+    enum class FootstepLandedFootSoundType_t : std::uint32_t
+    {
+        FOOTSOUND_Left = 0x0,
+        FOOTSOUND_Right = 0x1,
+        FOOTSOUND_UseOverrideSound = 0x2,
+    };
+};

sdk/include/source2sdk/animationsystem/HSequence.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: unknown
+    // Alignment: 0x4
+    // Standard-layout class: true
+    // Size: 0x4
+    // Has Trivial Destructor
+    // 
+    // static metadata: MIsBoxedIntegerType
+    #pragma pack(push, 1)
+    class HSequence
+    {
+    public:
+        int32_t m_Value; // 0x0        
+        
+        // Static fields:
+        static bool &Get_IS_TYPESAFE_INTEGER() {return *reinterpret_cast<bool*>(interfaces::g_schema->FindTypeScopeForModule("!GlobalTypes")->FindDeclaredClass("HSequence")->GetStaticFields()[0]->m_pInstance);};
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(HSequence, m_Value) == 0x0);
+    
+    static_assert(sizeof(HSequence) == 0x4);
+};

sdk/include/source2sdk/animationsystem/MoodAnimationLayer_t.hpp

@@ -0,0 +1,77 @@
+#pragma once
+#include "source2sdk/animationsystem/MoodAnimation_t.hpp"
+#include "source2sdk/tier2/CRangeFloat.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x60
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    // static metadata: MPropertyArrayElementNameKey "m_sName"
+    #pragma pack(push, 1)
+    struct MoodAnimationLayer_t
+    {
+    public:
+        // metadata: MPropertyFriendlyName "Name"
+        // metadata: MPropertyDescription "Name of the layer"
+        CUtlString m_sName; // 0x0        
+        // metadata: MPropertyFriendlyName "Active When Listening"
+        // metadata: MPropertyDescription "Sets the mood's animation buckets to be active when the character is listening"
+        bool m_bActiveListening; // 0x8        
+        // metadata: MPropertyFriendlyName "Active When Talking"
+        // metadata: MPropertyDescription "Sets the mood's animation buckets to be active when the character is talking"
+        bool m_bActiveTalking; // 0x9        
+        [[maybe_unused]] std::uint8_t pad_0x0a[0x6]; // 0xa
+        // metadata: MPropertyDescription "List of animations to choose from"
+        // m_layerAnimations has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animationsystem::MoodAnimation_t> m_layerAnimations;
+        char m_layerAnimations[0x18]; // 0x10        
+        // metadata: MPropertyDescription "Intensity of the animation"
+        // metadata: MPropertyAttributeRange "0 1"
+        tier2::CRangeFloat m_flIntensity; // 0x28        
+        // metadata: MPropertyDescription "Multiplier of the animation duration"
+        tier2::CRangeFloat m_flDurationScale; // 0x30        
+        // metadata: MPropertyDescription "When scaling an animation, grab the scale value as in int. Used for gestures/postures to control number of looping sections"
+        bool m_bScaleWithInts; // 0x38        
+        [[maybe_unused]] std::uint8_t pad_0x39[0x3]; // 0x39
+        // metadata: MPropertyDescription "Time before the next animation can start"
+        tier2::CRangeFloat m_flNextStart; // 0x3c        
+        // metadata: MPropertyDescription "Time from the start of the mood before an animation can start"
+        tier2::CRangeFloat m_flStartOffset; // 0x44        
+        // metadata: MPropertyDescription "Time from the end of the mood when an animation cannot play"
+        tier2::CRangeFloat m_flEndOffset; // 0x4c        
+        // metadata: MPropertyDescription "Fade in time of the animation"
+        float m_flFadeIn; // 0x54        
+        // metadata: MPropertyDescription "Fade out time of the animation"
+        float m_flFadeOut; // 0x58        
+        [[maybe_unused]] std::uint8_t pad_0x5c[0x4];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(MoodAnimationLayer_t, m_sName) == 0x0);
+    static_assert(offsetof(MoodAnimationLayer_t, m_bActiveListening) == 0x8);
+    static_assert(offsetof(MoodAnimationLayer_t, m_bActiveTalking) == 0x9);
+    static_assert(offsetof(MoodAnimationLayer_t, m_layerAnimations) == 0x10);
+    static_assert(offsetof(MoodAnimationLayer_t, m_flIntensity) == 0x28);
+    static_assert(offsetof(MoodAnimationLayer_t, m_flDurationScale) == 0x30);
+    static_assert(offsetof(MoodAnimationLayer_t, m_bScaleWithInts) == 0x38);
+    static_assert(offsetof(MoodAnimationLayer_t, m_flNextStart) == 0x3c);
+    static_assert(offsetof(MoodAnimationLayer_t, m_flStartOffset) == 0x44);
+    static_assert(offsetof(MoodAnimationLayer_t, m_flEndOffset) == 0x4c);
+    static_assert(offsetof(MoodAnimationLayer_t, m_flFadeIn) == 0x54);
+    static_assert(offsetof(MoodAnimationLayer_t, m_flFadeOut) == 0x58);
+    
+    static_assert(sizeof(MoodAnimationLayer_t) == 0x60);
+};

sdk/include/source2sdk/animationsystem/MoodAnimation_t.hpp

@@ -0,0 +1,38 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x10
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    // static metadata: MPropertyArrayElementNameKey "m_sName"
+    #pragma pack(push, 1)
+    struct MoodAnimation_t
+    {
+    public:
+        // metadata: MPropertyDescription "Name of the animation"
+        // metadata: MPropertyAttributeEditor "VDataModelAnim( m_sModelName; include_deltas )"
+        CUtlString m_sName; // 0x0        
+        // metadata: MPropertyDescription "Weight of the animation, higher numbers get picked more"
+        float m_flWeight; // 0x8        
+        [[maybe_unused]] std::uint8_t pad_0x0c[0x4];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(MoodAnimation_t, m_sName) == 0x0);
+    static_assert(offsetof(MoodAnimation_t, m_flWeight) == 0x8);
+    
+    static_assert(sizeof(MoodAnimation_t) == 0x10);
+};

sdk/include/source2sdk/animationsystem/MoodType_t.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 2
+    // Alignment: 4
+    // Size: 0x4
+    enum class MoodType_t : std::uint32_t
+    {
+        // MPropertyFriendlyName "Head"
+        eMoodType_Head = 0x0,
+        // MPropertyFriendlyName "Body"
+        eMoodType_Body = 0x1,
+    };
+};

sdk/include/source2sdk/animationsystem/ParticleAttachment_t.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 18
+    // Alignment: 4
+    // Size: 0x4
+    enum class ParticleAttachment_t : std::uint32_t
+    {
+        PATTACH_INVALID = 0xffffffff,
+        PATTACH_ABSORIGIN = 0x0,
+        PATTACH_ABSORIGIN_FOLLOW = 0x1,
+        PATTACH_CUSTOMORIGIN = 0x2,
+        PATTACH_CUSTOMORIGIN_FOLLOW = 0x3,
+        PATTACH_POINT = 0x4,
+        PATTACH_POINT_FOLLOW = 0x5,
+        PATTACH_EYES_FOLLOW = 0x6,
+        PATTACH_OVERHEAD_FOLLOW = 0x7,
+        PATTACH_WORLDORIGIN = 0x8,
+        PATTACH_ROOTBONE_FOLLOW = 0x9,
+        PATTACH_RENDERORIGIN_FOLLOW = 0xa,
+        PATTACH_MAIN_VIEW = 0xb,
+        PATTACH_WATERWAKE = 0xc,
+        PATTACH_CENTER_FOLLOW = 0xd,
+        PATTACH_CUSTOM_GAME_STATE_1 = 0xe,
+        PATTACH_HEALTHBAR = 0xf,
+        MAX_PATTACH_TYPES = 0x10,
+    };
+};

sdk/include/source2sdk/animationsystem/RagdollPoseControl.hpp

@@ -0,0 +1,19 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 2
+    // Alignment: 4
+    // Size: 0x4
+    enum class RagdollPoseControl : std::uint32_t
+    {
+        Absolute = 0x0,
+        Relative = 0x1,
+    };
+};

sdk/include/source2sdk/animationsystem/SeqCmd_t.hpp

@@ -0,0 +1,34 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 17
+    // Alignment: 4
+    // Size: 0x4
+    enum class SeqCmd_t : std::uint32_t
+    {
+        SeqCmd_Nop = 0x0,
+        SeqCmd_LinearDelta = 0x1,
+        SeqCmd_FetchFrameRange = 0x2,
+        SeqCmd_Slerp = 0x3,
+        SeqCmd_Add = 0x4,
+        SeqCmd_Subtract = 0x5,
+        SeqCmd_Scale = 0x6,
+        SeqCmd_Copy = 0x7,
+        SeqCmd_Blend = 0x8,
+        SeqCmd_Worldspace = 0x9,
+        SeqCmd_Sequence = 0xa,
+        SeqCmd_FetchCycle = 0xb,
+        SeqCmd_FetchFrame = 0xc,
+        SeqCmd_IKLockInPlace = 0xd,
+        SeqCmd_IKRestoreAll = 0xe,
+        SeqCmd_ReverseSequence = 0xf,
+        SeqCmd_Transform = 0x10,
+    };
+};

sdk/include/source2sdk/animationsystem/SeqPoseSetting_t.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animationsystem
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animationsystem
+{
+    // Enumerator count: 4
+    // Alignment: 4
+    // Size: 0x4
+    enum class SeqPoseSetting_t : std::uint32_t
+    {
+        SEQ_POSE_SETTING_CONSTANT = 0x0,
+        SEQ_POSE_SETTING_ROTATION = 0x1,
+        SEQ_POSE_SETTING_POSITION = 0x2,
+        SEQ_POSE_SETTING_VELOCITY = 0x3,
+    };
+};

sdk/include/source2sdk/animgraphlib/AimCameraOpFixedSettings_t.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x30
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    struct AimCameraOpFixedSettings_t
+    {
+    public:
+        int32_t m_nChainIndex; // 0x0        
+        int32_t m_nCameraJointIndex; // 0x4        
+        int32_t m_nPelvisJointIndex; // 0x8        
+        int32_t m_nClavicleLeftJointIndex; // 0xc        
+        int32_t m_nClavicleRightJointIndex; // 0x10        
+        int32_t m_nDepenetrationJointIndex; // 0x14        
+        // m_propJoints has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<int32_t> m_propJoints;
+        char m_propJoints[0x18]; // 0x18        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(AimCameraOpFixedSettings_t, m_nChainIndex) == 0x0);
+    static_assert(offsetof(AimCameraOpFixedSettings_t, m_nCameraJointIndex) == 0x4);
+    static_assert(offsetof(AimCameraOpFixedSettings_t, m_nPelvisJointIndex) == 0x8);
+    static_assert(offsetof(AimCameraOpFixedSettings_t, m_nClavicleLeftJointIndex) == 0xc);
+    static_assert(offsetof(AimCameraOpFixedSettings_t, m_nClavicleRightJointIndex) == 0x10);
+    static_assert(offsetof(AimCameraOpFixedSettings_t, m_nDepenetrationJointIndex) == 0x14);
+    static_assert(offsetof(AimCameraOpFixedSettings_t, m_propJoints) == 0x18);
+    
+    static_assert(sizeof(AimCameraOpFixedSettings_t) == 0x30);
+};

sdk/include/source2sdk/animgraphlib/AimMatrixBlendMode.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Enumerator count: 4
+    // Alignment: 4
+    // Size: 0x4
+    enum class AimMatrixBlendMode : std::uint32_t
+    {
+        // MPropertyFriendlyName "None"
+        AimMatrixBlendMode_None = 0x0,
+        // MPropertyFriendlyName "Additive"
+        AimMatrixBlendMode_Additive = 0x1,
+        // MPropertyFriendlyName "Model-Space Additive"
+        AimMatrixBlendMode_ModelSpaceAdditive = 0x2,
+        // MPropertyFriendlyName "Bone Mask"
+        AimMatrixBlendMode_BoneMask = 0x3,
+    };
+};

sdk/include/source2sdk/animgraphlib/AimMatrixOpFixedSettings_t.hpp

@@ -0,0 +1,62 @@
+#pragma once
+#include "source2sdk/animgraphlib/AimMatrixBlendMode.hpp"
+#include "source2sdk/animgraphlib/CAnimInputDamping.hpp"
+#include "source2sdk/animgraphlib/CBlendCurve.hpp"
+#include "source2sdk/animgraphlib/CPoseHandle.hpp"
+#include "source2sdk/modellib/CAnimAttachment.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x10
+    // Alignment: 0x10
+    // Standard-layout class: true
+    // Size: 0xe0
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    struct AimMatrixOpFixedSettings_t
+    {
+    public:
+        modellib::CAnimAttachment m_attachment; // 0x0        
+        animgraphlib::CAnimInputDamping m_damping; // 0x80        
+        animgraphlib::CPoseHandle m_poseCacheHandles[10]; // 0x90        
+        animgraphlib::AimMatrixBlendMode m_eBlendMode; // 0xb8        
+        float m_flMaxYawAngle; // 0xbc        
+        float m_flMaxPitchAngle; // 0xc0        
+        int32_t m_nSequenceMaxFrame; // 0xc4        
+        int32_t m_nBoneMaskIndex; // 0xc8        
+        bool m_bTargetIsPosition; // 0xcc        
+        bool m_bUseBiasAndClamp; // 0xcd        
+        [[maybe_unused]] std::uint8_t pad_0xce[0x2]; // 0xce
+        float m_flBiasAndClampYawOffset; // 0xd0        
+        float m_flBiasAndClampPitchOffset; // 0xd4        
+        animgraphlib::CBlendCurve m_biasAndClampBlendCurve; // 0xd8        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_attachment) == 0x0);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_damping) == 0x80);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_poseCacheHandles) == 0x90);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_eBlendMode) == 0xb8);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_flMaxYawAngle) == 0xbc);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_flMaxPitchAngle) == 0xc0);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_nSequenceMaxFrame) == 0xc4);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_nBoneMaskIndex) == 0xc8);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_bTargetIsPosition) == 0xcc);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_bUseBiasAndClamp) == 0xcd);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_flBiasAndClampYawOffset) == 0xd0);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_flBiasAndClampPitchOffset) == 0xd4);
+    static_assert(offsetof(AimMatrixOpFixedSettings_t, m_biasAndClampBlendCurve) == 0xd8);
+    
+    static_assert(sizeof(AimMatrixOpFixedSettings_t) == 0xe0);
+};

sdk/include/source2sdk/animgraphlib/AnimNodeNetworkMode.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Enumerator count: 2
+    // Alignment: 4
+    // Size: 0x4
+    enum class AnimNodeNetworkMode : std::uint32_t
+    {
+        // MPropertyFriendlyName "Server Authoritative"
+        ServerAuthoritative = 0x0,
+        // MPropertyFriendlyName "Client Simulate"
+        ClientSimulate = 0x1,
+    };
+};

sdk/include/source2sdk/animgraphlib/AnimScriptType.hpp

@@ -0,0 +1,20 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Enumerator count: 3
+    // Alignment: 2
+    // Size: 0x2
+    enum class AnimScriptType : std::uint16_t
+    {
+        ANIMSCRIPT_TYPE_INVALID = 0xffff,
+        ANIMSCRIPT_FUSE_GENERAL = 0x0,
+        ANIMSCRIPT_FUSE_STATEMACHINE = 0x1,
+    };
+};

sdk/include/source2sdk/animgraphlib/AnimValueSource.hpp

@@ -0,0 +1,89 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Enumerator count: 36
+    // Alignment: 4
+    // Size: 0x4
+    enum class AnimValueSource : std::uint32_t
+    {
+        // MPropertyFriendlyName "Move Heading"
+        MoveHeading = 0x0,
+        // MPropertyFriendlyName "Move Speed"
+        MoveSpeed = 0x1,
+        // MPropertyFriendlyName "Forward Speed"
+        ForwardSpeed = 0x2,
+        // MPropertyFriendlyName "Strafe Speed"
+        StrafeSpeed = 0x3,
+        // MPropertyFriendlyName "Facing Heading"
+        FacingHeading = 0x4,
+        // MPropertyFriendlyName "Look Heading"
+        LookHeading = 0x5,
+        // MPropertyFriendlyName "Look Pitch"
+        LookPitch = 0x6,
+        // MPropertyFriendlyName "Look Distance"
+        LookDistance = 0x7,
+        // MPropertyFriendlyName "Parameter"
+        Parameter = 0x8,
+        // MPropertyFriendlyName "Waypoint Heading"
+        WayPointHeading = 0x9,
+        // MPropertyFriendlyName "Waypoint Distance"
+        WayPointDistance = 0xa,
+        // MPropertyFriendlyName "Boundary Radius"
+        BoundaryRadius = 0xb,
+        // MPropertyFriendlyName "Target Move Heading"
+        TargetMoveHeading = 0xc,
+        // MPropertyFriendlyName "Target Move Speed"
+        TargetMoveSpeed = 0xd,
+        // MPropertyFriendlyName "Acceleration Heading"
+        AccelerationHeading = 0xe,
+        // MPropertyFriendlyName "Acceleration Speed"
+        AccelerationSpeed = 0xf,
+        // MPropertyFriendlyName "Slope Heading"
+        SlopeHeading = 0x10,
+        // MPropertyFriendlyName "Slope Angle"
+        SlopeAngle = 0x11,
+        // MPropertyFriendlyName "Slope Pitch"
+        SlopePitch = 0x12,
+        // MPropertyFriendlyName "Slope Yaw"
+        SlopeYaw = 0x13,
+        // MPropertyFriendlyName "Goal Distance"
+        GoalDistance = 0x14,
+        // MPropertyFriendlyName "Acceleration Left-Right"
+        AccelerationLeftRight = 0x15,
+        // MPropertyFriendlyName "Acceleration Forward-Back"
+        AccelerationFrontBack = 0x16,
+        // MPropertyFriendlyName "Root Motion Speed"
+        RootMotionSpeed = 0x17,
+        // MPropertyFriendlyName "Root Motion Turn Speed"
+        RootMotionTurnSpeed = 0x18,
+        // MPropertyFriendlyName "Move Heading Relative to Look Heading"
+        MoveHeadingRelativeToLookHeading = 0x19,
+        // MPropertyFriendlyName "Max Move Speed"
+        MaxMoveSpeed = 0x1a,
+        // MPropertyFriendlyName "Finger Curl - Thumb"
+        FingerCurl_Thumb = 0x1b,
+        // MPropertyFriendlyName "Finger Curl - Index"
+        FingerCurl_Index = 0x1c,
+        // MPropertyFriendlyName "Finger Curl - Middle"
+        FingerCurl_Middle = 0x1d,
+        // MPropertyFriendlyName "Finger Curl - Ring"
+        FingerCurl_Ring = 0x1e,
+        // MPropertyFriendlyName "Finger Curl - Pinky"
+        FingerCurl_Pinky = 0x1f,
+        // MPropertyFriendlyName "Finger Splay - Thumb:Index"
+        FingerSplay_Thumb_Index = 0x20,
+        // MPropertyFriendlyName "Finger Splay - Index:Middle"
+        FingerSplay_Index_Middle = 0x21,
+        // MPropertyFriendlyName "Finger Splay - Middle:Ring"
+        FingerSplay_Middle_Ring = 0x22,
+        // MPropertyFriendlyName "Finger Splay - Ring:Pinky"
+        FingerSplay_Ring_Pinky = 0x23,
+    };
+};

sdk/include/source2sdk/animgraphlib/AnimVectorSource.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Enumerator count: 14
+    // Alignment: 4
+    // Size: 0x4
+    enum class AnimVectorSource : std::uint32_t
+    {
+        // MPropertyFriendlyName "Move Direction"
+        MoveDirection = 0x0,
+        // MPropertyFriendlyName "Facing Position"
+        FacingPosition = 0x1,
+        // MPropertyFriendlyName "Look Direction"
+        LookDirection = 0x2,
+        // MPropertyFriendlyName "Parameter"
+        VectorParameter = 0x3,
+        // MPropertyFriendlyName "Waypoint Direction"
+        WayPointDirection = 0x4,
+        // MPropertyFriendlyName "Acceleration"
+        Acceleration = 0x5,
+        // MPropertyFriendlyName "Slope Normal"
+        SlopeNormal = 0x6,
+        // MPropertyFriendlyName "Slope Normal World Space"
+        SlopeNormal_WorldSpace = 0x7,
+        // MPropertyFriendlyName "Look Target"
+        LookTarget = 0x8,
+        // MPropertyFriendlyName "Look Target World Space"
+        LookTarget_WorldSpace = 0x9,
+        // MPropertyFriendlyName "Waypoint Position"
+        WayPointPosition = 0xa,
+        // MPropertyFriendlyName "Goal Position"
+        GoalPosition = 0xb,
+        // MPropertyFriendlyName "Root Motion Velocity"
+        RootMotionVelocity = 0xc,
+        // MPropertyFriendlyName "Manual Target World Space"
+        ManualTarget_WorldSpace = 0xd,
+    };
+};

sdk/include/source2sdk/animgraphlib/BinaryNodeChildOption.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Enumerator count: 2
+    // Alignment: 4
+    // Size: 0x4
+    enum class BinaryNodeChildOption : std::uint32_t
+    {
+        // MPropertyFriendlyName "Child 1"
+        Child1 = 0x0,
+        // MPropertyFriendlyName "Child 2"
+        Child2 = 0x1,
+    };
+};

sdk/include/source2sdk/animgraphlib/BinaryNodeTiming.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Enumerator count: 3
+    // Alignment: 4
+    // Size: 0x4
+    enum class BinaryNodeTiming : std::uint32_t
+    {
+        // MPropertyFriendlyName "Use Child1"
+        UseChild1 = 0x0,
+        // MPropertyFriendlyName "Use Child2"
+        UseChild2 = 0x1,
+        // MPropertyFriendlyName "Synchronize Children"
+        SyncChildren = 0x2,
+    };
+};

sdk/include/source2sdk/animgraphlib/Blend2DMode.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Enumerator count: 2
+    // Alignment: 4
+    // Size: 0x4
+    enum class Blend2DMode : std::uint32_t
+    {
+        // MPropertyFriendlyName "General"
+        Blend2DMode_General = 0x0,
+        // MPropertyFriendlyName "Directional"
+        Blend2DMode_Directional = 0x1,
+    };
+};

sdk/include/source2sdk/animgraphlib/BlendItem_t.hpp

@@ -0,0 +1,47 @@
+#pragma once
+#include "source2sdk/animationsystem/HSequence.hpp"
+#include "source2sdk/animgraphlib/CAnimUpdateNodeRef.hpp"
+#include "source2sdk/animgraphlib/TagSpan_t.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x40
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    struct BlendItem_t
+    {
+    public:
+        // m_tags has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animgraphlib::TagSpan_t> m_tags;
+        char m_tags[0x18]; // 0x0        
+        animgraphlib::CAnimUpdateNodeRef m_pChild; // 0x18        
+        animationsystem::HSequence m_hSequence; // 0x28        
+        Vector2D m_vPos; // 0x2c        
+        float m_flDuration; // 0x34        
+        bool m_bUseCustomDuration; // 0x38        
+        [[maybe_unused]] std::uint8_t pad_0x39[0x7];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(BlendItem_t, m_tags) == 0x0);
+    static_assert(offsetof(BlendItem_t, m_pChild) == 0x18);
+    static_assert(offsetof(BlendItem_t, m_hSequence) == 0x28);
+    static_assert(offsetof(BlendItem_t, m_vPos) == 0x2c);
+    static_assert(offsetof(BlendItem_t, m_flDuration) == 0x34);
+    static_assert(offsetof(BlendItem_t, m_bUseCustomDuration) == 0x38);
+    
+    static_assert(sizeof(BlendItem_t) == 0x40);
+};

sdk/include/source2sdk/animgraphlib/BlendKeyType.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Enumerator count: 4
+    // Alignment: 4
+    // Size: 0x4
+    enum class BlendKeyType : std::uint32_t
+    {
+        // MPropertyFriendlyName "User Defined Values"
+        BlendKey_UserValue = 0x0,
+        // MPropertyFriendlyName "Velocity"
+        BlendKey_Velocity = 0x1,
+        // MPropertyFriendlyName "Distance"
+        BlendKey_Distance = 0x2,
+        // MPropertyFriendlyName "Remaining Distance"
+        BlendKey_RemainingDistance = 0x3,
+    };
+};

sdk/include/source2sdk/animgraphlib/BoneDemoCaptureSettings_t.hpp

@@ -0,0 +1,51 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x20
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    struct BoneDemoCaptureSettings_t
+    {
+    public:
+        // metadata: MPropertyFriendlyName "Bone"
+        // metadata: MPropertyAttributeChoiceName "Bone"
+        CUtlString m_boneName; // 0x0        
+        // metadata: MPropertySuppressField
+        float m_flErrorSplineRotationMax; // 0x8        
+        // metadata: MPropertySuppressField
+        float m_flErrorSplineTranslationMax; // 0xc        
+        // metadata: MPropertySuppressField
+        float m_flErrorSplineScaleMax; // 0x10        
+        // metadata: MPropertySuppressField
+        float m_flErrorQuantizationRotationMax; // 0x14        
+        // metadata: MPropertySuppressField
+        float m_flErrorQuantizationTranslationMax; // 0x18        
+        // metadata: MPropertySuppressField
+        float m_flErrorQuantizationScaleMax; // 0x1c        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(BoneDemoCaptureSettings_t, m_boneName) == 0x0);
+    static_assert(offsetof(BoneDemoCaptureSettings_t, m_flErrorSplineRotationMax) == 0x8);
+    static_assert(offsetof(BoneDemoCaptureSettings_t, m_flErrorSplineTranslationMax) == 0xc);
+    static_assert(offsetof(BoneDemoCaptureSettings_t, m_flErrorSplineScaleMax) == 0x10);
+    static_assert(offsetof(BoneDemoCaptureSettings_t, m_flErrorQuantizationRotationMax) == 0x14);
+    static_assert(offsetof(BoneDemoCaptureSettings_t, m_flErrorQuantizationTranslationMax) == 0x18);
+    static_assert(offsetof(BoneDemoCaptureSettings_t, m_flErrorQuantizationScaleMax) == 0x1c);
+    
+    static_assert(sizeof(BoneDemoCaptureSettings_t) == 0x20);
+};

sdk/include/source2sdk/animgraphlib/BoneMaskBlendSpace.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Enumerator count: 4
+    // Alignment: 4
+    // Size: 0x4
+    enum class BoneMaskBlendSpace : std::uint32_t
+    {
+        // MPropertyFriendlyName "Parent Space"
+        BlendSpace_Parent = 0x0,
+        // MPropertyFriendlyName "Model Space"
+        BlendSpace_Model = 0x1,
+        // MPropertyFriendlyName "Model Space, Rotation Only"
+        BlendSpace_Model_RotationOnly = 0x2,
+        // MPropertyFriendlyName "Model Space, Translation Only"
+        BlendSpace_Model_TranslationOnly = 0x3,
+    };
+};

sdk/include/source2sdk/animgraphlib/CActionComponentUpdater.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include "source2sdk/animgraphlib/CAnimActionUpdater.hpp"
+#include "source2sdk/animgraphlib/CAnimComponentUpdater.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: false
+    // Size: 0x48
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CActionComponentUpdater : public animgraphlib::CAnimComponentUpdater
+    {
+    public:
+        // m_actions has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CSmartPtr<animgraphlib::CAnimActionUpdater>> m_actions;
+        char m_actions[0x18]; // 0x30        
+    };
+    #pragma pack(pop)
+    
+    // Cannot assert offsets of fields in CActionComponentUpdater because it is not a standard-layout class
+    static_assert(sizeof(CActionComponentUpdater) == 0x48);
+};

sdk/include/source2sdk/animgraphlib/CAddUpdateNode.hpp

@@ -0,0 +1,39 @@
+#pragma once
+#include "source2sdk/animgraphlib/BinaryNodeChildOption.hpp"
+#include "source2sdk/animgraphlib/CBinaryUpdateNode.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: false
+    // Size: 0x98
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAddUpdateNode : public animgraphlib::CBinaryUpdateNode
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x88[0x4]; // 0x88
+        animgraphlib::BinaryNodeChildOption m_footMotionTiming; // 0x8c        
+        bool m_bApplyToFootMotion; // 0x90        
+        bool m_bApplyChannelsSeparately; // 0x91        
+        bool m_bUseModelSpace; // 0x92        
+        bool m_bApplyScale; // 0x93        
+        [[maybe_unused]] std::uint8_t pad_0x94[0x4];
+    };
+    #pragma pack(pop)
+    
+    // Cannot assert offsets of fields in CAddUpdateNode because it is not a standard-layout class
+    static_assert(sizeof(CAddUpdateNode) == 0x98);
+};

sdk/include/source2sdk/animgraphlib/CAimCameraUpdateNode.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#include "source2sdk/animgraphlib/AimCameraOpFixedSettings_t.hpp"
+#include "source2sdk/animgraphlib/CAnimParamHandle.hpp"
+#include "source2sdk/animgraphlib/CUnaryUpdateNode.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: false
+    // Size: 0xb8
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAimCameraUpdateNode : public animgraphlib::CUnaryUpdateNode
+    {
+    public:
+        animgraphlib::CAnimParamHandle m_hParameterPosition; // 0x68        
+        animgraphlib::CAnimParamHandle m_hParameterOrientation; // 0x6a        
+        animgraphlib::CAnimParamHandle m_hParameterSpineRotationWeight; // 0x6c        
+        animgraphlib::CAnimParamHandle m_hParameterPelvisOffset; // 0x6e        
+        animgraphlib::CAnimParamHandle m_hParameterUseIK; // 0x70        
+        animgraphlib::CAnimParamHandle m_hParameterCameraOnly; // 0x72        
+        animgraphlib::CAnimParamHandle m_hParameterWeaponDepenetrationDistance; // 0x74        
+        animgraphlib::CAnimParamHandle m_hParameterWeaponDepenetrationDelta; // 0x76        
+        animgraphlib::CAnimParamHandle m_hParameterCameraClearanceDistance; // 0x78        
+        [[maybe_unused]] std::uint8_t pad_0x7a[0x6]; // 0x7a
+        animgraphlib::AimCameraOpFixedSettings_t m_opFixedSettings; // 0x80        
+        [[maybe_unused]] std::uint8_t pad_0xb0[0x8];
+    };
+    #pragma pack(pop)
+    
+    // Cannot assert offsets of fields in CAimCameraUpdateNode because it is not a standard-layout class
+    static_assert(sizeof(CAimCameraUpdateNode) == 0xb8);
+};

sdk/include/source2sdk/animgraphlib/CAimMatrixUpdateNode.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#include "source2sdk/animationsystem/HSequence.hpp"
+#include "source2sdk/animgraphlib/AimMatrixOpFixedSettings_t.hpp"
+#include "source2sdk/animgraphlib/AnimVectorSource.hpp"
+#include "source2sdk/animgraphlib/CAnimParamHandle.hpp"
+#include "source2sdk/animgraphlib/CUnaryUpdateNode.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x10
+    // Alignment: 0x10
+    // Standard-layout class: false
+    // Size: 0x170
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAimMatrixUpdateNode : public animgraphlib::CUnaryUpdateNode
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x68[0x8]; // 0x68
+        animgraphlib::AimMatrixOpFixedSettings_t m_opFixedSettings; // 0x70        
+        [[maybe_unused]] std::uint8_t pad_0x150[0x8]; // 0x150
+        animgraphlib::AnimVectorSource m_target; // 0x158        
+        animgraphlib::CAnimParamHandle m_paramIndex; // 0x15c        
+        [[maybe_unused]] std::uint8_t pad_0x15e[0x2]; // 0x15e
+        animationsystem::HSequence m_hSequence; // 0x160        
+        bool m_bResetChild; // 0x164        
+        bool m_bLockWhenWaning; // 0x165        
+        [[maybe_unused]] std::uint8_t pad_0x166[0xa];
+    };
+    #pragma pack(pop)
+    
+    // Cannot assert offsets of fields in CAimMatrixUpdateNode because it is not a standard-layout class
+    static_assert(sizeof(CAimMatrixUpdateNode) == 0x170);
+};

sdk/include/source2sdk/animgraphlib/CAnimActionUpdater.hpp

@@ -0,0 +1,31 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: unknown
+    // Alignment: 0x1
+    // Standard-layout class: true
+    // Size: 0x18
+    // Has VTable
+    // Is Abstract
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimActionUpdater
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x18];
+    };
+    #pragma pack(pop)
+    
+    static_assert(sizeof(CAnimActionUpdater) == 0x18);
+};

sdk/include/source2sdk/animgraphlib/CAnimComponentUpdater.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include "source2sdk/animgraphlib/AnimNodeNetworkMode.hpp"
+#include "source2sdk/modellib/AnimComponentID.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: unknown
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x30
+    // Has VTable
+    // Is Abstract
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimComponentUpdater
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x18]; // 0x0
+        CUtlString m_name; // 0x18        
+        modellib::AnimComponentID m_id; // 0x20        
+        animgraphlib::AnimNodeNetworkMode m_networkMode; // 0x24        
+        bool m_bStartEnabled; // 0x28        
+        [[maybe_unused]] std::uint8_t pad_0x29[0x7];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimComponentUpdater, m_name) == 0x18);
+    static_assert(offsetof(CAnimComponentUpdater, m_id) == 0x20);
+    static_assert(offsetof(CAnimComponentUpdater, m_networkMode) == 0x24);
+    static_assert(offsetof(CAnimComponentUpdater, m_bStartEnabled) == 0x28);
+    
+    static_assert(sizeof(CAnimComponentUpdater) == 0x30);
+};

sdk/include/source2sdk/animgraphlib/CAnimDemoCaptureSettings.hpp

@@ -0,0 +1,98 @@
+#pragma once
+#include "source2sdk/animgraphlib/BoneDemoCaptureSettings_t.hpp"
+#include "source2sdk/animgraphlib/EDemoBoneSelectionMode.hpp"
+#include "source2sdk/animgraphlib/IKDemoCaptureSettings_t.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x80
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimDemoCaptureSettings
+    {
+    public:
+        // metadata: MPropertyFriendlyName "Rotation Error Range"
+        // metadata: MPropertyGroupName "+Spline Settings"
+        Vector2D m_vecErrorRangeSplineRotation; // 0x0        
+        // metadata: MPropertyFriendlyName "Translation Error Range"
+        // metadata: MPropertyGroupName "+Spline Settings"
+        Vector2D m_vecErrorRangeSplineTranslation; // 0x8        
+        // metadata: MPropertyFriendlyName "Scale Error Range"
+        // metadata: MPropertyGroupName "+Spline Settings"
+        Vector2D m_vecErrorRangeSplineScale; // 0x10        
+        // metadata: MPropertyFriendlyName "Max IK Rotation Error"
+        // metadata: MPropertyGroupName "+Spline Settings"
+        float m_flIkRotation_MaxSplineError; // 0x18        
+        // metadata: MPropertyFriendlyName "Max IK Translation Error"
+        // metadata: MPropertyGroupName "+Spline Settings"
+        float m_flIkTranslation_MaxSplineError; // 0x1c        
+        // metadata: MPropertyFriendlyName "Rotation Error Range"
+        // metadata: MPropertyGroupName "+Quantization Settings"
+        Vector2D m_vecErrorRangeQuantizationRotation; // 0x20        
+        // metadata: MPropertyFriendlyName "Translation Error Range"
+        // metadata: MPropertyGroupName "+Quantization Settings"
+        Vector2D m_vecErrorRangeQuantizationTranslation; // 0x28        
+        // metadata: MPropertyFriendlyName "Scale Error Range"
+        // metadata: MPropertyGroupName "+Quantization Settings"
+        Vector2D m_vecErrorRangeQuantizationScale; // 0x30        
+        // metadata: MPropertyFriendlyName "Max IK Rotation Error"
+        // metadata: MPropertyGroupName "+Quantization Settings"
+        float m_flIkRotation_MaxQuantizationError; // 0x38        
+        // metadata: MPropertyFriendlyName "Max IK Translation Error"
+        // metadata: MPropertyGroupName "+Quantization Settings"
+        float m_flIkTranslation_MaxQuantizationError; // 0x3c        
+        // metadata: MPropertyFriendlyName "Base Sequence"
+        // metadata: MPropertyGroupName "+Base Pose"
+        // metadata: MPropertyAttributeChoiceName "Sequence"
+        CUtlString m_baseSequence; // 0x40        
+        // metadata: MPropertyFriendlyName "Base Sequence Frame"
+        // metadata: MPropertyGroupName "+Base Pose"
+        int32_t m_nBaseSequenceFrame; // 0x48        
+        // metadata: MPropertyFriendlyName "Bone Selection Mode"
+        // metadata: MPropertyGroupName "+Bones"
+        // metadata: MPropertyAttrChangeCallback
+        animgraphlib::EDemoBoneSelectionMode m_boneSelectionMode; // 0x4c        
+        // metadata: MPropertyFriendlyName "Bones"
+        // metadata: MPropertyGroupName "+Bones"
+        // metadata: MPropertyAttrStateCallback
+        // m_bones has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animgraphlib::BoneDemoCaptureSettings_t> m_bones;
+        char m_bones[0x18]; // 0x50        
+        // metadata: MPropertyFriendlyName "IK Chains"
+        // m_ikChains has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animgraphlib::IKDemoCaptureSettings_t> m_ikChains;
+        char m_ikChains[0x18]; // 0x68        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_vecErrorRangeSplineRotation) == 0x0);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_vecErrorRangeSplineTranslation) == 0x8);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_vecErrorRangeSplineScale) == 0x10);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_flIkRotation_MaxSplineError) == 0x18);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_flIkTranslation_MaxSplineError) == 0x1c);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_vecErrorRangeQuantizationRotation) == 0x20);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_vecErrorRangeQuantizationTranslation) == 0x28);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_vecErrorRangeQuantizationScale) == 0x30);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_flIkRotation_MaxQuantizationError) == 0x38);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_flIkTranslation_MaxQuantizationError) == 0x3c);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_baseSequence) == 0x40);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_nBaseSequenceFrame) == 0x48);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_boneSelectionMode) == 0x4c);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_bones) == 0x50);
+    static_assert(offsetof(CAnimDemoCaptureSettings, m_ikChains) == 0x68);
+    
+    static_assert(sizeof(CAnimDemoCaptureSettings) == 0x80);
+};

sdk/include/source2sdk/animgraphlib/CAnimGraphDebugReplay.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#include "source2sdk/animgraphlib/CAnimReplayFrame.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x70
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimGraphDebugReplay
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x40]; // 0x0
+        CUtlString m_animGraphFileName; // 0x40        
+        // m_frameList has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CSmartPtr<animgraphlib::CAnimReplayFrame>> m_frameList;
+        char m_frameList[0x18]; // 0x48        
+        int32_t m_startIndex; // 0x60        
+        int32_t m_writeIndex; // 0x64        
+        int32_t m_frameCount; // 0x68        
+        [[maybe_unused]] std::uint8_t pad_0x6c[0x4];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimGraphDebugReplay, m_animGraphFileName) == 0x40);
+    static_assert(offsetof(CAnimGraphDebugReplay, m_frameList) == 0x48);
+    static_assert(offsetof(CAnimGraphDebugReplay, m_startIndex) == 0x60);
+    static_assert(offsetof(CAnimGraphDebugReplay, m_writeIndex) == 0x64);
+    static_assert(offsetof(CAnimGraphDebugReplay, m_frameCount) == 0x68);
+    
+    static_assert(sizeof(CAnimGraphDebugReplay) == 0x70);
+};

sdk/include/source2sdk/animgraphlib/CAnimGraphModelBinding.hpp

@@ -0,0 +1,39 @@
+#pragma once
+#include "source2sdk/animgraphlib/CAnimUpdateSharedData.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x28
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimGraphModelBinding
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x8]; // 0x0
+        CUtlString m_modelName; // 0x8        
+        // m_pSharedData has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CSmartPtr<animgraphlib::CAnimUpdateSharedData> m_pSharedData;
+        char m_pSharedData[0x8]; // 0x10        
+        [[maybe_unused]] std::uint8_t pad_0x18[0x10];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimGraphModelBinding, m_modelName) == 0x8);
+    static_assert(offsetof(CAnimGraphModelBinding, m_pSharedData) == 0x10);
+    
+    static_assert(sizeof(CAnimGraphModelBinding) == 0x28);
+};

sdk/include/source2sdk/animgraphlib/CAnimGraphNetworkSettings.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include "source2sdk/animgraphlib/CAnimGraphSettingsGroup.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: false
+    // Size: 0x28
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    // static metadata: MPropertyFriendlyName "Networking"
+    #pragma pack(push, 1)
+    class CAnimGraphNetworkSettings : public animgraphlib::CAnimGraphSettingsGroup
+    {
+    public:
+        // metadata: MPropertyFriendlyName "Enable Networking"
+        bool m_bNetworkingEnabled; // 0x20        
+        [[maybe_unused]] std::uint8_t pad_0x21[0x7];
+    };
+    #pragma pack(pop)
+    
+    // Cannot assert offsets of fields in CAnimGraphNetworkSettings because it is not a standard-layout class
+    static_assert(sizeof(CAnimGraphNetworkSettings) == 0x28);
+};

sdk/include/source2sdk/animgraphlib/CAnimGraphSettingsGroup.hpp

@@ -0,0 +1,30 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x20
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimGraphSettingsGroup
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x20];
+    };
+    #pragma pack(pop)
+    
+    static_assert(sizeof(CAnimGraphSettingsGroup) == 0x20);
+};

sdk/include/source2sdk/animgraphlib/CAnimGraphSettingsManager.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include "source2sdk/animgraphlib/CAnimGraphSettingsGroup.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x30
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimGraphSettingsManager
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x18]; // 0x0
+        // m_settingsGroups has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CSmartPtr<animgraphlib::CAnimGraphSettingsGroup>> m_settingsGroups;
+        char m_settingsGroups[0x18]; // 0x18        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimGraphSettingsManager, m_settingsGroups) == 0x18);
+    
+    static_assert(sizeof(CAnimGraphSettingsManager) == 0x30);
+};

sdk/include/source2sdk/animgraphlib/CAnimInputDamping.hpp

@@ -0,0 +1,40 @@
+#pragma once
+#include "source2sdk/animgraphlib/DampingSpeedFunction.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x10
+    // Has VTable
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    // static metadata: MPropertyFriendlyName "Damping"
+    #pragma pack(push, 1)
+    class CAnimInputDamping
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x8]; // 0x0
+        // metadata: MPropertyFriendlyName "Speed Function"
+        animgraphlib::DampingSpeedFunction m_speedFunction; // 0x8        
+        // metadata: MPropertyFriendlyName "Speed Scale"
+        float m_fSpeedScale; // 0xc        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimInputDamping, m_speedFunction) == 0x8);
+    static_assert(offsetof(CAnimInputDamping, m_fSpeedScale) == 0xc);
+    
+    static_assert(sizeof(CAnimInputDamping) == 0x10);
+};

sdk/include/source2sdk/animgraphlib/CAnimMotorUpdaterBase.hpp

@@ -0,0 +1,37 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: unknown
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x20
+    // Has VTable
+    // Is Abstract
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimMotorUpdaterBase
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x10]; // 0x0
+        CUtlString m_name; // 0x10        
+        bool m_bDefault; // 0x18        
+        [[maybe_unused]] std::uint8_t pad_0x19[0x7];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimMotorUpdaterBase, m_name) == 0x10);
+    static_assert(offsetof(CAnimMotorUpdaterBase, m_bDefault) == 0x18);
+    
+    static_assert(sizeof(CAnimMotorUpdaterBase) == 0x20);
+};

sdk/include/source2sdk/animgraphlib/CAnimNodePath.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include "source2sdk/modellib/AnimNodeID.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x4
+    // Alignment: 0x4
+    // Standard-layout class: true
+    // Size: 0x30
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimNodePath
+    {
+    public:
+        modellib::AnimNodeID m_path[11]; // 0x0        
+        int32_t m_nCount; // 0x2c        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimNodePath, m_path) == 0x0);
+    static_assert(offsetof(CAnimNodePath, m_nCount) == 0x2c);
+    
+    static_assert(sizeof(CAnimNodePath) == 0x30);
+};

sdk/include/source2sdk/animgraphlib/CAnimParamHandle.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include "source2sdk/animationsystem/AnimParamType_t.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x1
+    // Alignment: 0x1
+    // Standard-layout class: true
+    // Size: 0x2
+    // Has Trivial Destructor
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimParamHandle
+    {
+    public:
+        animationsystem::AnimParamType_t m_type; // 0x0        
+        uint8_t m_index; // 0x1        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimParamHandle, m_type) == 0x0);
+    static_assert(offsetof(CAnimParamHandle, m_index) == 0x1);
+    
+    static_assert(sizeof(CAnimParamHandle) == 0x2);
+};

sdk/include/source2sdk/animgraphlib/CAnimParamHandleMap.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x20
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimParamHandleMap
+    {
+    public:
+        // m_list has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlHashtable<uint16_t,int16_t> m_list;
+        char m_list[0x20]; // 0x0        
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimParamHandleMap, m_list) == 0x0);
+    
+    static_assert(sizeof(CAnimParamHandleMap) == 0x20);
+};

sdk/include/source2sdk/animgraphlib/CAnimParameterBase.hpp

@@ -0,0 +1,61 @@
+#pragma once
+#include "source2sdk/modellib/AnimParamID.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: unknown
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x70
+    // Has VTable
+    // Is Abstract
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimParameterBase
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x18]; // 0x0
+        // metadata: MPropertyFriendlyName "Name"
+        // metadata: MPropertySortPriority "100"
+        CGlobalSymbol m_name; // 0x18        
+        // metadata: MPropertyFriendlyName "Comment"
+        // metadata: MPropertyAttributeEditor "TextBlock()"
+        // metadata: MPropertySortPriority "-100"
+        CUtlString m_sComment; // 0x20        
+        // metadata: MPropertyReadOnly
+        CUtlString m_group; // 0x28        
+        // metadata: MPropertyReadOnly
+        modellib::AnimParamID m_id; // 0x30        
+        [[maybe_unused]] std::uint8_t pad_0x34[0x14]; // 0x34
+        // metadata: MPropertyHideField
+        // metadata: MPropertyAttrChangeCallback
+        CUtlString m_componentName; // 0x48        
+        [[maybe_unused]] std::uint8_t pad_0x50[0x18]; // 0x50
+        // metadata: MPropertyHideField
+        bool m_bNetworkingRequested; // 0x68        
+        // metadata: MPropertyHideField
+        bool m_bIsReferenced; // 0x69        
+        [[maybe_unused]] std::uint8_t pad_0x6a[0x6];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimParameterBase, m_name) == 0x18);
+    static_assert(offsetof(CAnimParameterBase, m_sComment) == 0x20);
+    static_assert(offsetof(CAnimParameterBase, m_group) == 0x28);
+    static_assert(offsetof(CAnimParameterBase, m_id) == 0x30);
+    static_assert(offsetof(CAnimParameterBase, m_componentName) == 0x48);
+    static_assert(offsetof(CAnimParameterBase, m_bNetworkingRequested) == 0x68);
+    static_assert(offsetof(CAnimParameterBase, m_bIsReferenced) == 0x69);
+    
+    static_assert(sizeof(CAnimParameterBase) == 0x70);
+};

sdk/include/source2sdk/animgraphlib/CAnimParameterManagerUpdater.hpp

@@ -0,0 +1,59 @@
+#pragma once
+#include "source2sdk/animgraphlib/CAnimParamHandle.hpp"
+#include "source2sdk/animgraphlib/CAnimParameterBase.hpp"
+#include "source2sdk/modellib/AnimParamID.hpp"
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x8
+    // Alignment: 0x8
+    // Standard-layout class: true
+    // Size: 0x100
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimParameterManagerUpdater
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x18]; // 0x0
+        // m_parameters has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CSmartPtr<animgraphlib::CAnimParameterBase>> m_parameters;
+        char m_parameters[0x18]; // 0x18        
+        // m_idToIndexMap has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlHashtable<modellib::AnimParamID,int32_t> m_idToIndexMap;
+        char m_idToIndexMap[0x20]; // 0x30        
+        // m_nameToIndexMap has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlHashtable<CUtlString,int32_t> m_nameToIndexMap;
+        char m_nameToIndexMap[0x20]; // 0x50        
+        // m_indexToHandle has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<animgraphlib::CAnimParamHandle> m_indexToHandle;
+        char m_indexToHandle[0x18]; // 0x70        
+        // m_autoResetParams has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CUtlPair<animgraphlib::CAnimParamHandle,CAnimVariant>> m_autoResetParams;
+        char m_autoResetParams[0x18]; // 0x88        
+        // m_autoResetMap has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlHashtable<animgraphlib::CAnimParamHandle,int16_t> m_autoResetMap;
+        char m_autoResetMap[0x20]; // 0xa0        
+        [[maybe_unused]] std::uint8_t pad_0xc0[0x40];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimParameterManagerUpdater, m_parameters) == 0x18);
+    static_assert(offsetof(CAnimParameterManagerUpdater, m_idToIndexMap) == 0x30);
+    static_assert(offsetof(CAnimParameterManagerUpdater, m_nameToIndexMap) == 0x50);
+    static_assert(offsetof(CAnimParameterManagerUpdater, m_indexToHandle) == 0x70);
+    static_assert(offsetof(CAnimParameterManagerUpdater, m_autoResetParams) == 0x88);
+    static_assert(offsetof(CAnimParameterManagerUpdater, m_autoResetMap) == 0xa0);
+    
+    static_assert(sizeof(CAnimParameterManagerUpdater) == 0x100);
+};

sdk/include/source2sdk/animgraphlib/CAnimReplayFrame.hpp

@@ -0,0 +1,44 @@
+#pragma once
+#include "source2sdk/source2gen.hpp"
+#include <cstddef>
+#include <cstdint>
+
+// /////////////////////////////////////////////////////////////
+// Module: animgraphlib
+// Created using source2gen - github.com/neverlosecc/source2gen
+// /////////////////////////////////////////////////////////////
+
+namespace source2sdk::animgraphlib
+{
+    // Registered alignment: 0x10
+    // Alignment: 0x10
+    // Standard-layout class: true
+    // Size: 0x90
+    // Has VTable
+    // Construct allowed
+    // 
+    // static metadata: MGetKV3ClassDefaults
+    #pragma pack(push, 1)
+    class CAnimReplayFrame
+    {
+    public:
+        [[maybe_unused]] std::uint8_t pad_0x00[0x10]; // 0x0
+        // m_inputDataBlocks has a template type with potentially unknown template parameters. You can try uncommenting the field below.
+        // CUtlVector<CUtlBinaryBlock> m_inputDataBlocks;
+        char m_inputDataBlocks[0x18]; // 0x10        
+        CUtlBinaryBlock m_instanceData; // 0x28        
+        CTransform m_startingLocalToWorldTransform; // 0x40        
+        CTransform m_localToWorldTransform; // 0x60        
+        float m_timeStamp; // 0x80        
+        [[maybe_unused]] std::uint8_t pad_0x84[0xc];
+    };
+    #pragma pack(pop)
+    
+    static_assert(offsetof(CAnimReplayFrame, m_inputDataBlocks) == 0x10);
+    static_assert(offsetof(CAnimReplayFrame, m_instanceData) == 0x28);
+    static_assert(offsetof(CAnimReplayFrame, m_startingLocalToWorldTransform) == 0x40);
+    static_assert(offsetof(CAnimReplayFrame, m_localToWorldTransform) == 0x60);
+    static_assert(offsetof(CAnimReplayFrame, m_timeStamp) == 0x80);
+    
+    static_assert(sizeof(CAnimReplayFrame) == 0x90);
+};