GooberDev/source2sdk
2
0
Fork 0
mirror of https://github.com/neverlosecc/source2sdk.git synced 2025-01-23 05:45:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

11.09.2024

Browse Source 
compile-ready SDK
This commit is contained in:
Konstantin 'cpz' L. 2024-09-11 01:34:46 +03:00
parent 537ee7a9f8
commit f5f376802c
15993 changed files with 566531 additions and 113226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39069
sdk/!GlobalTypes.hpp
View File

File diff suppressed because it is too large Load Diff

8838
sdk/animationsystem.hpp
View File

File diff suppressed because it is too large Load Diff

2504
sdk/assetpreview.hpp
View File

File diff suppressed because it is too large Load Diff

20975
sdk/client.hpp
View File

File diff suppressed because it is too large Load Diff

140
sdk/engine2.hpp
View File

@ -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
};

34
sdk/host.hpp
View File

@ -1,34 +0,0 @@
#pragma once
#include <cstdint>
#include "!GlobalTypes.hpp"
// /////////////////////////////////////////////////////////////
// Binary: host.dll
// Classes count: 0 (Allocated) | 2 (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
};
// Registered binary: host.dll (project 'host')
// Alignment: 8
// Size: 0x20
// Has VTable
class EmptyTestScript : public CAnimScriptBase
{
public:
CAnimScriptParam< float32 > m_hTest; // 0x10
};

43
sdk/include/source2sdk/animationsystem/AnimParamButton_t.hpp Normal file
View File

@ -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,
};
};

23
sdk/include/source2sdk/animationsystem/AnimParamNetworkSetting.hpp Normal file
View File

@ -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,
};
};

26
sdk/include/source2sdk/animationsystem/AnimParamType_t.hpp Normal file
View File

@ -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,
};
};

23
sdk/include/source2sdk/animationsystem/AnimPoseControl.hpp Normal file
View File

@ -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,
};
};

50
sdk/include/source2sdk/animationsystem/AnimationDecodeDebugDumpElement_t.hpp Normal file
View File

@ -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);
};

38
sdk/include/source2sdk/animationsystem/AnimationDecodeDebugDump_t.hpp Normal file
View File

@ -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);
};

23
sdk/include/source2sdk/animationsystem/AnimationProcessingType_t.hpp Normal file
View File

@ -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,
};
};

59
sdk/include/source2sdk/animationsystem/AnimationSnapshotBase_t.hpp Normal file
View File

@ -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);
};

24
sdk/include/source2sdk/animationsystem/AnimationSnapshotType_t.hpp Normal file
View File

@ -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,
};
};

33
sdk/include/source2sdk/animationsystem/AnimationSnapshot_t.hpp Normal file
View File

@ -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);
};

25
sdk/include/source2sdk/animationsystem/BoneTransformSpace_t.hpp Normal file
View File

@ -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,
};
};

38
sdk/include/source2sdk/animationsystem/CAnimActivity.hpp Normal file
View File

@ -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);
};

43
sdk/include/source2sdk/animationsystem/CAnimBone.hpp Normal file
View File

@ -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);
};

40
sdk/include/source2sdk/animationsystem/CAnimBoneDifference.hpp Normal file
View File

@ -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);
};

51
sdk/include/source2sdk/animationsystem/CAnimData.hpp Normal file
View File

@ -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);
};

53
sdk/include/source2sdk/animationsystem/CAnimDataChannelDesc.hpp Normal file
View File

@ -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);
};

35
sdk/include/source2sdk/animationsystem/CAnimDecoder.hpp Normal file
View File

@ -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);
};

81
sdk/include/source2sdk/animationsystem/CAnimDesc.hpp Normal file
View File

@ -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);
};

46
sdk/include/source2sdk/animationsystem/CAnimDesc_Flag.hpp Normal file
View File

@ -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);
};

60
sdk/include/source2sdk/animationsystem/CAnimEncodeDifference.hpp Normal file
View File

@ -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);
};

43
sdk/include/source2sdk/animationsystem/CAnimEncodedFrames.hpp Normal file
View File

@ -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);
};

31
sdk/include/source2sdk/animationsystem/CAnimEnum.hpp Normal file
View File

@ -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);
};

45
sdk/include/source2sdk/animationsystem/CAnimEventDefinition.hpp Normal file
View File

@ -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);
};

37
sdk/include/source2sdk/animationsystem/CAnimFrameBlockAnim.hpp Normal file
View File

@ -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);
};

38
sdk/include/source2sdk/animationsystem/CAnimFrameSegment.hpp Normal file
View File

@ -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);
};

53
sdk/include/source2sdk/animationsystem/CAnimKeyData.hpp Normal file
View File

@ -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);
};

41
sdk/include/source2sdk/animationsystem/CAnimLocalHierarchy.hpp Normal file
View File

@ -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);
};

31
sdk/include/source2sdk/animationsystem/CAnimMorphDifference.hpp Normal file
View File

@ -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);
};

44
sdk/include/source2sdk/animationsystem/CAnimMovement.hpp Normal file
View File

@ -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);
};

34
sdk/include/source2sdk/animationsystem/CAnimSequenceParams.hpp Normal file
View File

@ -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);
};

34
sdk/include/source2sdk/animationsystem/CAnimUser.hpp Normal file
View File

@ -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);
};

34
sdk/include/source2sdk/animationsystem/CAnimUserDifference.hpp Normal file
View File

@ -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);
};

63
sdk/include/source2sdk/animationsystem/CAnimationGroup.hpp Normal file
View File

@ -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);
};

95
sdk/include/source2sdk/animationsystem/CCompressorGroup.hpp Normal file
View File

@ -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);
};

49
sdk/include/source2sdk/animationsystem/CMoodVData.hpp Normal file
View File

@ -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);
};

45
sdk/include/source2sdk/animationsystem/CSeqAutoLayer.hpp Normal file
View File

@ -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);
};

46
sdk/include/source2sdk/animationsystem/CSeqAutoLayerFlag.hpp Normal file
View File

@ -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);
};

46
sdk/include/source2sdk/animationsystem/CSeqBoneMaskList.hpp Normal file
View File

@ -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);
};

50
sdk/include/source2sdk/animationsystem/CSeqCmdLayer.hpp Normal file
View File

@ -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);
};

68
sdk/include/source2sdk/animationsystem/CSeqCmdSeqDesc.hpp Normal file
View File

@ -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);
};

39
sdk/include/source2sdk/animationsystem/CSeqIKLock.hpp Normal file
View File

@ -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);
};

58
sdk/include/source2sdk/animationsystem/CSeqMultiFetch.hpp Normal file
View File

@ -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);
};

42
sdk/include/source2sdk/animationsystem/CSeqMultiFetchFlag.hpp Normal file
View File

@ -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);
};

40
sdk/include/source2sdk/animationsystem/CSeqPoseParamDesc.hpp Normal file
View File

@ -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);
};

47
sdk/include/source2sdk/animationsystem/CSeqPoseSetting.hpp Normal file
View File

@ -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);
};

69
sdk/include/source2sdk/animationsystem/CSeqS1SeqDesc.hpp Normal file
View File

@ -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);
};

44
sdk/include/source2sdk/animationsystem/CSeqScaleSet.hpp Normal file
View File

@ -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);
};

52
sdk/include/source2sdk/animationsystem/CSeqSeqDescFlag.hpp Normal file
View File

@ -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);
};

47
sdk/include/source2sdk/animationsystem/CSeqSynthAnimDesc.hpp Normal file
View File

@ -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);
};

34
sdk/include/source2sdk/animationsystem/CSeqTransition.hpp Normal file
View File

@ -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);
};

87
sdk/include/source2sdk/animationsystem/CSequenceGroupData.hpp Normal file
View File

@ -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);
};

20
sdk/include/source2sdk/animationsystem/FootstepLandedFootSoundType_t.hpp Normal file
View File

@ -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,
};
};

34
sdk/include/source2sdk/animationsystem/HSequence.hpp Normal file
View File

@ -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);
};

77
sdk/include/source2sdk/animationsystem/MoodAnimationLayer_t.hpp Normal file
View File

@ -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);
};

38
sdk/include/source2sdk/animationsystem/MoodAnimation_t.hpp Normal file
View File

@ -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);
};

21
sdk/include/source2sdk/animationsystem/MoodType_t.hpp Normal file
View File

@ -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,
};
};

35
sdk/include/source2sdk/animationsystem/ParticleAttachment_t.hpp Normal file
View File

@ -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,
};
};

19
sdk/include/source2sdk/animationsystem/RagdollPoseControl.hpp Normal file
View File

@ -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,
};
};

34
sdk/include/source2sdk/animationsystem/SeqCmd_t.hpp Normal file
View File

@ -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,
};
};

21
sdk/include/source2sdk/animationsystem/SeqPoseSetting_t.hpp Normal file
View File

@ -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,
};
};

45
sdk/include/source2sdk/animgraphlib/AimCameraOpFixedSettings_t.hpp Normal file
View File

@ -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);
};

25
sdk/include/source2sdk/animgraphlib/AimMatrixBlendMode.hpp Normal file
View File

@ -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,
};
};

62
sdk/include/source2sdk/animgraphlib/AimMatrixOpFixedSettings_t.hpp Normal file
View File

@ -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);
};

21
sdk/include/source2sdk/animgraphlib/AnimNodeNetworkMode.hpp Normal file
View File

@ -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,
};
};

20
sdk/include/source2sdk/animgraphlib/AnimScriptType.hpp Normal file
View File

@ -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,
};
};

89
sdk/include/source2sdk/animgraphlib/AnimValueSource.hpp Normal file
View File

@ -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,
};
};

45
sdk/include/source2sdk/animgraphlib/AnimVectorSource.hpp Normal file
View File

@ -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,
};
};

21
sdk/include/source2sdk/animgraphlib/BinaryNodeChildOption.hpp Normal file
View File

@ -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,
};
};

23
sdk/include/source2sdk/animgraphlib/BinaryNodeTiming.hpp Normal file
View File

@ -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,
};
};

21
sdk/include/source2sdk/animgraphlib/Blend2DMode.hpp Normal file
View File

@ -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,
};
};

47
sdk/include/source2sdk/animgraphlib/BlendItem_t.hpp Normal file
View File

@ -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);
};

25
sdk/include/source2sdk/animgraphlib/BlendKeyType.hpp Normal file
View File

@ -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,
};
};

51
sdk/include/source2sdk/animgraphlib/BoneDemoCaptureSettings_t.hpp Normal file
View File

@ -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);
};

25
sdk/include/source2sdk/animgraphlib/BoneMaskBlendSpace.hpp Normal file
View File

@ -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,
};
};

35
sdk/include/source2sdk/animgraphlib/CActionComponentUpdater.hpp Normal file
View File

@ -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);
};

39
sdk/include/source2sdk/animgraphlib/CAddUpdateNode.hpp Normal file
View File

@ -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);
};

45
sdk/include/source2sdk/animgraphlib/CAimCameraUpdateNode.hpp Normal file
View File

@ -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);
};

45
sdk/include/source2sdk/animgraphlib/CAimMatrixUpdateNode.hpp Normal file
View File

@ -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);
};

31
sdk/include/source2sdk/animgraphlib/CAnimActionUpdater.hpp Normal file
View File

@ -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);
};

43
sdk/include/source2sdk/animgraphlib/CAnimComponentUpdater.hpp Normal file
View File

@ -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);
};

98
sdk/include/source2sdk/animgraphlib/CAnimDemoCaptureSettings.hpp Normal file
View File

@ -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);
};

45
sdk/include/source2sdk/animgraphlib/CAnimGraphDebugReplay.hpp Normal file
View File

@ -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);
};

39
sdk/include/source2sdk/animgraphlib/CAnimGraphModelBinding.hpp Normal file
View File

@ -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);
};

35
sdk/include/source2sdk/animgraphlib/CAnimGraphNetworkSettings.hpp Normal file
View File

@ -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);
};

30
sdk/include/source2sdk/animgraphlib/CAnimGraphSettingsGroup.hpp Normal file
View File

@ -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);
};

36
sdk/include/source2sdk/animgraphlib/CAnimGraphSettingsManager.hpp Normal file
View File

@ -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);
};

40
sdk/include/source2sdk/animgraphlib/CAnimInputDamping.hpp Normal file
View File

@ -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);
};

37
sdk/include/source2sdk/animgraphlib/CAnimMotorUpdaterBase.hpp Normal file
View File

@ -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);
};

35
sdk/include/source2sdk/animgraphlib/CAnimNodePath.hpp Normal file
View File

@ -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);
};

35
sdk/include/source2sdk/animgraphlib/CAnimParamHandle.hpp Normal file
View File

@ -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);
};

33
sdk/include/source2sdk/animgraphlib/CAnimParamHandleMap.hpp Normal file
View File

@ -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);
};

61
sdk/include/source2sdk/animgraphlib/CAnimParameterBase.hpp Normal file
View File

@ -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);
};

59
sdk/include/source2sdk/animgraphlib/CAnimParameterManagerUpdater.hpp Normal file
View File

@ -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);
};

44
sdk/include/source2sdk/animgraphlib/CAnimReplayFrame.hpp Normal file
View File

@ -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);
};

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