From 0a86db6b40ef6e7f8e82490ac66acfa9ff8ba203 Mon Sep 17 00:00:00 2001 From: a2x <45197573+a2x@users.noreply.github.com> Date: Tue, 17 Oct 2023 12:06:23 +1000 Subject: [PATCH] Add python file builder --- Cargo.toml | 3 +- generated/animationsystem.dll.cs | 2 +- generated/animationsystem.dll.hpp | 10 +- generated/animationsystem.dll.py | 2189 ++++++++++ generated/animationsystem.dll.rs | 6 +- generated/client.dll.cs | 2 +- generated/client.dll.hpp | 10 +- generated/client.dll.py | 3439 ++++++++++++++++ generated/client.dll.rs | 6 +- generated/engine2.dll.cs | 2 +- generated/engine2.dll.hpp | 10 +- generated/engine2.dll.py | 149 + generated/engine2.dll.rs | 6 +- generated/host.dll.cs | 2 +- generated/host.dll.hpp | 10 +- generated/host.dll.py | 10 + generated/host.dll.rs | 6 +- generated/interfaces.cs | 72 +- generated/interfaces.hpp | 80 +- generated/interfaces.json | 70 +- generated/interfaces.py | 205 + generated/interfaces.rs | 76 +- generated/materialsystem2.dll.cs | 2 +- generated/materialsystem2.dll.hpp | 10 +- generated/materialsystem2.dll.py | 98 + generated/materialsystem2.dll.rs | 6 +- generated/networksystem.dll.cs | 2 +- generated/networksystem.dll.hpp | 10 +- generated/networksystem.dll.py | 7 + generated/networksystem.dll.rs | 6 +- generated/offsets.cs | 6 +- generated/offsets.hpp | 14 +- generated/offsets.json | 4 +- generated/offsets.py | 34 + generated/offsets.rs | 10 +- generated/particles.dll.cs | 2 +- generated/particles.dll.hpp | 10 +- generated/particles.dll.py | 3506 ++++++++++++++++ generated/particles.dll.rs | 6 +- generated/pulse_system.dll.cs | 2 +- generated/pulse_system.dll.hpp | 10 +- generated/pulse_system.dll.py | 233 ++ generated/pulse_system.dll.rs | 6 +- generated/rendersystemdx11.dll.cs | 2 +- generated/rendersystemdx11.dll.hpp | 10 +- generated/rendersystemdx11.dll.py | 22 + generated/rendersystemdx11.dll.rs | 6 +- generated/resourcesystem.dll.cs | 2 +- generated/resourcesystem.dll.hpp | 10 +- generated/resourcesystem.dll.py | 65 + generated/resourcesystem.dll.rs | 6 +- generated/scenesystem.dll.cs | 2 +- generated/scenesystem.dll.hpp | 10 +- generated/scenesystem.dll.py | 44 + generated/scenesystem.dll.rs | 6 +- generated/schemasystem.dll.cs | 2 +- generated/schemasystem.dll.hpp | 10 +- generated/schemasystem.dll.py | 44 + generated/schemasystem.dll.rs | 6 +- generated/server.dll.cs | 2 +- generated/server.dll.hpp | 10 +- generated/server.dll.py | 5979 ++++++++++++++++++++++++++++ generated/server.dll.rs | 6 +- generated/soundsystem.dll.cs | 2 +- generated/soundsystem.dll.hpp | 10 +- generated/soundsystem.dll.py | 272 ++ generated/soundsystem.dll.rs | 6 +- generated/vphysics2.dll.cs | 2 +- generated/vphysics2.dll.hpp | 10 +- generated/vphysics2.dll.py | 657 +++ generated/vphysics2.dll.rs | 6 +- generated/worldrenderer.dll.cs | 2 +- generated/worldrenderer.dll.hpp | 10 +- generated/worldrenderer.dll.py | 197 + generated/worldrenderer.dll.rs | 6 +- src/builder/json_file_builder.rs | 10 +- src/builder/mod.rs | 4 + src/builder/python_file_builder.rs | 43 + src/dumpers/interfaces.rs | 51 +- src/dumpers/mod.rs | 40 +- src/dumpers/offsets.rs | 129 +- src/error.rs | 14 +- src/main.rs | 1 + src/remote/process.rs | 6 +- src/sdk/interface.rs | 33 + src/sdk/mod.rs | 2 + 86 files changed, 17670 insertions(+), 436 deletions(-) create mode 100644 generated/animationsystem.dll.py create mode 100644 generated/client.dll.py create mode 100644 generated/engine2.dll.py create mode 100644 generated/host.dll.py create mode 100644 generated/interfaces.py create mode 100644 generated/materialsystem2.dll.py create mode 100644 generated/networksystem.dll.py create mode 100644 generated/offsets.py create mode 100644 generated/particles.dll.py create mode 100644 generated/pulse_system.dll.py create mode 100644 generated/rendersystemdx11.dll.py create mode 100644 generated/resourcesystem.dll.py create mode 100644 generated/scenesystem.dll.py create mode 100644 generated/schemasystem.dll.py create mode 100644 generated/server.dll.py create mode 100644 generated/soundsystem.dll.py create mode 100644 generated/vphysics2.dll.py create mode 100644 generated/worldrenderer.dll.py create mode 100644 src/builder/python_file_builder.rs create mode 100644 src/sdk/interface.rs diff --git a/Cargo.toml b/Cargo.toml index 58c791f..2493317 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "cs2-dumper" -version = "1.1.1" +version = "1.1.2" authors = ["a2x"] edition = "2021" readme = "README.md" @@ -10,6 +10,7 @@ license = "MIT" [dependencies] chrono = "0.4" clap = { version = "4.4", features = ["derive"] } +convert_case = "0.6" lazy_static = "1.4" log = "0.4" regex = "1.9" diff --git a/generated/animationsystem.dll.cs b/generated/animationsystem.dll.cs index ec5c947..9663da5 100644 --- a/generated/animationsystem.dll.cs +++ b/generated/animationsystem.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.539445700 UTC + * 2023-10-17 02:04:49.867815600 UTC */ public static class AimMatrixOpFixedSettings_t { diff --git a/generated/animationsystem.dll.hpp b/generated/animationsystem.dll.hpp index d31708c..f7fa593 100644 --- a/generated/animationsystem.dll.hpp +++ b/generated/animationsystem.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:49.844204800 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.515770200 UTC - */ - namespace AimMatrixOpFixedSettings_t { constexpr std::ptrdiff_t m_attachment = 0x0; // CAnimAttachment constexpr std::ptrdiff_t m_damping = 0x80; // CAnimInputDamping diff --git a/generated/animationsystem.dll.py b/generated/animationsystem.dll.py new file mode 100644 index 0000000..bac348b --- /dev/null +++ b/generated/animationsystem.dll.py @@ -0,0 +1,2189 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:49.892082200 UTC +''' + +class AimMatrixOpFixedSettings_t: + m_attachment = 0x0 # CAnimAttachment + m_damping = 0x80 # CAnimInputDamping + m_poseCacheHandles = 0x90 # CPoseHandle[10] + m_eBlendMode = 0xB8 # AimMatrixBlendMode + m_fAngleIncrement = 0xBC # float + m_nSequenceMaxFrame = 0xC0 # int32_t + m_nBoneMaskIndex = 0xC4 # int32_t + m_bTargetIsPosition = 0xC8 # bool + +class AnimComponentID: + m_id = 0x0 # uint32_t + +class AnimNodeID: + m_id = 0x0 # uint32_t + +class AnimNodeOutputID: + m_id = 0x0 # uint32_t + +class AnimParamID: + m_id = 0x0 # uint32_t + +class AnimScriptHandle: + m_id = 0x0 # uint32_t + +class AnimStateID: + m_id = 0x0 # uint32_t + +class AnimTagID: + m_id = 0x0 # uint32_t + +class AnimationDecodeDebugDumpElement_t: + m_nEntityIndex = 0x0 # int32_t + m_modelName = 0x8 # CUtlString + m_poseParams = 0x10 # CUtlVector + m_decodeOps = 0x28 # CUtlVector + m_internalOps = 0x40 # CUtlVector + m_decodedAnims = 0x58 # CUtlVector + +class AnimationDecodeDebugDump_t: + m_processingType = 0x0 # AnimationProcessingType_t + m_elems = 0x8 # CUtlVector + +class AnimationSnapshotBase_t: + m_flRealTime = 0x0 # float + m_rootToWorld = 0x10 # matrix3x4a_t + m_bBonesInWorldSpace = 0x40 # bool + m_boneSetupMask = 0x48 # CUtlVector + m_boneTransforms = 0x60 # CUtlVector + m_flexControllers = 0x78 # CUtlVector + m_SnapshotType = 0x90 # AnimationSnapshotType_t + m_bHasDecodeDump = 0x94 # bool + m_DecodeDump = 0x98 # AnimationDecodeDebugDumpElement_t + +class AnimationSnapshot_t: + m_nEntIndex = 0x110 # int32_t + m_modelName = 0x118 # CUtlString + +class AttachmentHandle_t: + m_Value = 0x0 # uint8_t + +class BlendItem_t: + m_tags = 0x0 # CUtlVector + m_pChild = 0x18 # CAnimUpdateNodeRef + m_hSequence = 0x28 # HSequence + m_vPos = 0x2C # Vector2D + m_flDuration = 0x34 # float + m_bUseCustomDuration = 0x38 # bool + +class BoneDemoCaptureSettings_t: + m_boneName = 0x0 # CUtlString + m_flChainLength = 0x8 # float + +class CActionComponentUpdater: + m_actions = 0x30 # CUtlVector> + +class CAddUpdateNode: + m_footMotionTiming = 0x8C # BinaryNodeChildOption + m_bApplyToFootMotion = 0x90 # bool + m_bApplyChannelsSeparately = 0x91 # bool + m_bUseModelSpace = 0x92 # bool + +class CAimConstraint: + m_qAimOffset = 0x70 # Quaternion + m_nUpType = 0x80 # uint32_t + +class CAimMatrixUpdateNode: + m_opFixedSettings = 0x70 # AimMatrixOpFixedSettings_t + m_target = 0x148 # AnimVectorSource + m_paramIndex = 0x14C # CAnimParamHandle + m_hSequence = 0x150 # HSequence + m_bResetChild = 0x154 # bool + m_bLockWhenWaning = 0x155 # bool + +class CAnimActivity: + m_name = 0x0 # CBufferString + m_nActivity = 0x10 # int32_t + m_nFlags = 0x14 # int32_t + m_nWeight = 0x18 # int32_t + +class CAnimAttachment: + m_influenceRotations = 0x0 # Quaternion[3] + m_influenceOffsets = 0x30 # VectorAligned[3] + m_influenceIndices = 0x60 # int32_t[3] + m_influenceWeights = 0x6C # float[3] + m_numInfluences = 0x78 # uint8_t + +class CAnimBone: + m_name = 0x0 # CBufferString + m_parent = 0x10 # int32_t + m_pos = 0x14 # Vector + m_quat = 0x20 # QuaternionStorage + m_scale = 0x30 # float + m_qAlignment = 0x34 # QuaternionStorage + m_flags = 0x44 # int32_t + +class CAnimBoneDifference: + m_name = 0x0 # CBufferString + m_parent = 0x10 # CBufferString + m_posError = 0x20 # Vector + m_bHasRotation = 0x2C # bool + m_bHasMovement = 0x2D # bool + +class CAnimComponentUpdater: + m_name = 0x18 # CUtlString + m_id = 0x20 # AnimComponentID + m_networkMode = 0x24 # AnimNodeNetworkMode + m_bStartEnabled = 0x28 # bool + +class CAnimData: + m_name = 0x10 # CBufferString + m_animArray = 0x20 # CUtlVector + m_decoderArray = 0x38 # CUtlVector + m_nMaxUniqueFrameIndex = 0x50 # int32_t + m_segmentArray = 0x58 # CUtlVector + +class CAnimDataChannelDesc: + m_szChannelClass = 0x0 # CBufferString + m_szVariableName = 0x10 # CBufferString + m_nFlags = 0x20 # int32_t + m_nType = 0x24 # int32_t + m_szGrouping = 0x28 # CBufferString + m_szDescription = 0x38 # CBufferString + m_szElementNameArray = 0x48 # CUtlVector + m_nElementIndexArray = 0x60 # CUtlVector + m_nElementMaskArray = 0x78 # CUtlVector + +class CAnimDecoder: + m_szName = 0x0 # CBufferString + m_nVersion = 0x10 # int32_t + m_nType = 0x14 # int32_t + +class CAnimDemoCaptureSettings: + m_rangeBoneChainLength = 0x0 # Vector2D + m_rangeMaxSplineErrorRotation = 0x8 # Vector2D + m_flMaxSplineErrorTranslation = 0x10 # float + m_flMaxSplineErrorScale = 0x14 # float + m_flIkRotation_MaxSplineError = 0x18 # float + m_flIkTranslation_MaxSplineError = 0x1C # float + m_flMaxQuantizationErrorRotation = 0x20 # float + m_flMaxQuantizationErrorTranslation = 0x24 # float + m_flMaxQuantizationErrorScale = 0x28 # float + m_flIkRotation_MaxQuantizationError = 0x2C # float + m_flIkTranslation_MaxQuantizationError = 0x30 # float + m_baseSequence = 0x38 # CUtlString + m_nBaseSequenceFrame = 0x40 # int32_t + m_boneSelectionMode = 0x44 # EDemoBoneSelectionMode + m_bones = 0x48 # CUtlVector + m_ikChains = 0x60 # CUtlVector + +class CAnimDesc: + m_name = 0x0 # CBufferString + m_flags = 0x10 # CAnimDesc_Flag + fps = 0x18 # float + m_Data = 0x20 # CAnimEncodedFrames + m_movementArray = 0xF8 # CUtlVector + m_eventArray = 0x110 # CUtlVector + m_activityArray = 0x128 # CUtlVector + m_hierarchyArray = 0x140 # CUtlVector + framestalltime = 0x158 # float + m_vecRootMin = 0x15C # Vector + m_vecRootMax = 0x168 # Vector + m_vecBoneWorldMin = 0x178 # CUtlVector + m_vecBoneWorldMax = 0x190 # CUtlVector + m_sequenceParams = 0x1A8 # CAnimSequenceParams + +class CAnimDesc_Flag: + 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 # bool + +class CAnimEncodeDifference: + m_boneArray = 0x0 # CUtlVector + m_morphArray = 0x18 # CUtlVector + m_userArray = 0x30 # CUtlVector + m_bHasRotationBitArray = 0x48 # CUtlVector + m_bHasMovementBitArray = 0x60 # CUtlVector + m_bHasMorphBitArray = 0x78 # CUtlVector + m_bHasUserBitArray = 0x90 # CUtlVector + +class CAnimEncodedFrames: + m_fileName = 0x0 # CBufferString + m_nFrames = 0x10 # int32_t + m_nFramesPerBlock = 0x14 # int32_t + m_frameblockArray = 0x18 # CUtlVector + m_usageDifferences = 0x30 # CAnimEncodeDifference + +class CAnimEnum: + m_value = 0x0 # uint8_t + +class CAnimEventDefinition: + m_nFrame = 0x8 # int32_t + m_flCycle = 0xC # float + m_EventData = 0x10 # KeyValues3 + m_sLegacyOptions = 0x20 # CBufferString + m_sEventName = 0x30 # CGlobalSymbol + +class CAnimFoot: + m_name = 0x0 # CUtlString + m_vBallOffset = 0x8 # Vector + m_vHeelOffset = 0x14 # Vector + m_ankleBoneIndex = 0x20 # int32_t + m_toeBoneIndex = 0x24 # int32_t + +class CAnimFrameBlockAnim: + m_nStartFrame = 0x0 # int32_t + m_nEndFrame = 0x4 # int32_t + m_segmentIndexArray = 0x8 # CUtlVector + +class CAnimFrameSegment: + m_nUniqueFrameIndex = 0x0 # int32_t + m_nLocalElementMasks = 0x4 # uint32_t + m_nLocalChannel = 0x8 # int32_t + m_container = 0x10 # CUtlBinaryBlock + +class CAnimGraphDebugReplay: + m_animGraphFileName = 0x40 # CUtlString + m_frameList = 0x48 # CUtlVector> + m_startIndex = 0x60 # int32_t + m_writeIndex = 0x64 # int32_t + m_frameCount = 0x68 # int32_t + +class CAnimGraphModelBinding: + m_modelName = 0x8 # CUtlString + m_pSharedData = 0x10 # CSmartPtr + +class CAnimGraphNetworkSettings: + m_bNetworkingEnabled = 0x20 # bool + +class CAnimGraphSettingsManager: + m_settingsGroups = 0x18 # CUtlVector> + +class CAnimInputDamping: + m_speedFunction = 0x8 # DampingSpeedFunction + m_fSpeedScale = 0xC # float + +class CAnimKeyData: + m_name = 0x0 # CBufferString + m_boneArray = 0x10 # CUtlVector + m_userArray = 0x28 # CUtlVector + m_morphArray = 0x40 # CUtlVector + m_nChannelElements = 0x58 # int32_t + m_dataChannelArray = 0x60 # CUtlVector + +class CAnimLocalHierarchy: + m_sBone = 0x0 # CBufferString + m_sNewParent = 0x10 # CBufferString + m_nStartFrame = 0x20 # int32_t + m_nPeakFrame = 0x24 # int32_t + m_nTailFrame = 0x28 # int32_t + m_nEndFrame = 0x2C # int32_t + +class CAnimMorphDifference: + m_name = 0x0 # CBufferString + +class CAnimMotorUpdaterBase: + m_name = 0x10 # CUtlString + m_bDefault = 0x18 # bool + +class CAnimMovement: + endframe = 0x0 # int32_t + motionflags = 0x4 # int32_t + v0 = 0x8 # float + v1 = 0xC # float + angle = 0x10 # float + vector = 0x14 # Vector + position = 0x20 # Vector + +class CAnimNodePath: + m_path = 0x0 # AnimNodeID[11] + m_nCount = 0x2C # int32_t + +class CAnimParamHandle: + m_type = 0x0 # AnimParamType_t + m_index = 0x1 # uint8_t + +class CAnimParamHandleMap: + m_list = 0x0 # CUtlHashtable + +class CAnimParameterBase: + m_name = 0x18 # CGlobalSymbol + m_group = 0x20 # CUtlString + m_id = 0x28 # AnimParamID + m_componentName = 0x40 # CUtlString + m_bNetworkingRequested = 0x4C # bool + m_bIsReferenced = 0x4D # bool + +class CAnimParameterManagerUpdater: + m_parameters = 0x18 # CUtlVector> + m_idToIndexMap = 0x30 # CUtlHashtable + m_nameToIndexMap = 0x50 # CUtlHashtable + m_indexToHandle = 0x70 # CUtlVector + m_autoResetParams = 0x88 # CUtlVector> + m_autoResetMap = 0xA0 # CUtlHashtable + +class CAnimReplayFrame: + m_inputDataBlocks = 0x10 # CUtlVector + m_instanceData = 0x28 # CUtlBinaryBlock + m_startingLocalToWorldTransform = 0x40 # CTransform + m_localToWorldTransform = 0x60 # CTransform + m_timeStamp = 0x80 # float + +class CAnimScriptComponentUpdater: + m_hScript = 0x30 # AnimScriptHandle + +class CAnimScriptManager: + m_scriptInfo = 0x10 # CUtlVector + +class CAnimSequenceParams: + m_flFadeInTime = 0x0 # float + m_flFadeOutTime = 0x4 # float + +class CAnimSkeleton: + m_localSpaceTransforms = 0x10 # CUtlVector + m_modelSpaceTransforms = 0x28 # CUtlVector + m_boneNames = 0x40 # CUtlVector + m_children = 0x58 # CUtlVector> + m_parents = 0x70 # CUtlVector + m_feet = 0x88 # CUtlVector + m_morphNames = 0xA0 # CUtlVector + m_lodBoneCounts = 0xB8 # CUtlVector + +class CAnimStateMachineUpdater: + m_states = 0x8 # CUtlVector + m_transitions = 0x20 # CUtlVector + m_startStateIndex = 0x50 # int32_t + +class CAnimTagBase: + m_name = 0x18 # CGlobalSymbol + m_group = 0x20 # CGlobalSymbol + m_tagID = 0x28 # AnimTagID + m_bIsReferenced = 0x2C # bool + +class CAnimTagManagerUpdater: + m_tags = 0x18 # CUtlVector> + +class CAnimUpdateNodeBase: + m_nodePath = 0x18 # CAnimNodePath + m_networkMode = 0x48 # AnimNodeNetworkMode + m_name = 0x50 # CUtlString + +class CAnimUpdateNodeRef: + m_nodeIndex = 0x8 # int32_t + +class CAnimUpdateSharedData: + m_nodes = 0x10 # CUtlVector> + m_nodeIndexMap = 0x28 # CUtlHashtable + m_components = 0x48 # CUtlVector> + m_pParamListUpdater = 0x60 # CSmartPtr + m_pTagManagerUpdater = 0x68 # CSmartPtr + m_scriptManager = 0x70 # CSmartPtr + m_settings = 0x78 # CAnimGraphSettingsManager + m_pStaticPoseCache = 0xA8 # CSmartPtr + m_pSkeleton = 0xB0 # CSmartPtr + m_rootNodePath = 0xB8 # CAnimNodePath + +class CAnimUser: + m_name = 0x0 # CBufferString + m_nType = 0x10 # int32_t + +class CAnimUserDifference: + m_name = 0x0 # CBufferString + m_nType = 0x10 # int32_t + +class CAnimationGraphVisualizerAxis: + m_xWsTransform = 0x40 # CTransform + m_flAxisSize = 0x60 # float + +class CAnimationGraphVisualizerLine: + m_vWsPositionStart = 0x40 # VectorAligned + m_vWsPositionEnd = 0x50 # VectorAligned + m_Color = 0x60 # Color + +class CAnimationGraphVisualizerPie: + m_vWsCenter = 0x40 # VectorAligned + m_vWsStart = 0x50 # VectorAligned + m_vWsEnd = 0x60 # VectorAligned + m_Color = 0x70 # Color + +class CAnimationGraphVisualizerPrimitiveBase: + m_Type = 0x8 # CAnimationGraphVisualizerPrimitiveType + m_OwningAnimNodePaths = 0xC # AnimNodeID[11] + m_nOwningAnimNodePathCount = 0x38 # int32_t + +class CAnimationGraphVisualizerSphere: + m_vWsPosition = 0x40 # VectorAligned + m_flRadius = 0x50 # float + m_Color = 0x54 # Color + +class CAnimationGraphVisualizerText: + m_vWsPosition = 0x40 # VectorAligned + m_Color = 0x50 # Color + m_Text = 0x58 # CUtlString + +class CAnimationGroup: + m_nFlags = 0x10 # uint32_t + m_name = 0x18 # CBufferString + m_localHAnimArray_Handle = 0x60 # CUtlVector> + m_includedGroupArray_Handle = 0x78 # CUtlVector> + m_directHSeqGroup_Handle = 0x90 # CStrongHandle + m_decodeKey = 0x98 # CAnimKeyData + m_szScripts = 0x110 # CUtlVector + +class CAttachment: + m_name = 0x0 # CUtlString + m_influenceNames = 0x8 # CUtlString[3] + m_vInfluenceRotations = 0x20 # Quaternion[3] + m_vInfluenceOffsets = 0x50 # Vector[3] + m_influenceWeights = 0x74 # float[3] + m_bInfluenceRootTransform = 0x80 # bool[3] + m_nInfluences = 0x83 # uint8_t + m_bIgnoreRotation = 0x84 # bool + +class CAudioAnimTag: + m_clipName = 0x38 # CUtlString + m_attachmentName = 0x40 # CUtlString + m_flVolume = 0x48 # float + m_bStopWhenTagEnds = 0x4C # bool + m_bStopWhenGraphEnds = 0x4D # bool + m_bPlayOnServer = 0x4E # bool + m_bPlayOnClient = 0x4F # bool + +class CBaseConstraint: + m_name = 0x28 # CUtlString + m_vUpVector = 0x30 # Vector + m_slaves = 0x40 # CUtlVector + m_targets = 0x58 # CUtlVector + +class CBinaryUpdateNode: + m_pChild1 = 0x58 # CAnimUpdateNodeRef + m_pChild2 = 0x68 # CAnimUpdateNodeRef + m_timingBehavior = 0x78 # BinaryNodeTiming + m_flTimingBlend = 0x7C # float + m_bResetChild1 = 0x80 # bool + m_bResetChild2 = 0x81 # bool + +class CBlend2DUpdateNode: + m_items = 0x60 # CUtlVector + m_tags = 0x78 # CUtlVector + m_paramSpans = 0x90 # CParamSpanUpdater + m_nodeItemIndices = 0xA8 # CUtlVector + m_damping = 0xC0 # CAnimInputDamping + m_blendSourceX = 0xD0 # AnimValueSource + m_paramX = 0xD4 # CAnimParamHandle + m_blendSourceY = 0xD8 # AnimValueSource + m_paramY = 0xDC # CAnimParamHandle + m_eBlendMode = 0xE0 # Blend2DMode + m_playbackSpeed = 0xE4 # float + m_bLoop = 0xE8 # bool + m_bLockBlendOnReset = 0xE9 # bool + m_bLockWhenWaning = 0xEA # bool + m_bAnimEventsAndTagsOnMostWeightedOnly = 0xEB # bool + +class CBlendCurve: + m_flControlPoint1 = 0x0 # float + m_flControlPoint2 = 0x4 # float + +class CBlendUpdateNode: + m_children = 0x60 # CUtlVector + m_sortedOrder = 0x78 # CUtlVector + m_targetValues = 0x90 # CUtlVector + m_blendValueSource = 0xAC # AnimValueSource + m_paramIndex = 0xB0 # CAnimParamHandle + m_damping = 0xB8 # CAnimInputDamping + m_blendKeyType = 0xC8 # BlendKeyType + m_bLockBlendOnReset = 0xCC # bool + m_bSyncCycles = 0xCD # bool + m_bLoop = 0xCE # bool + m_bLockWhenWaning = 0xCF # bool + +class CBodyGroupAnimTag: + m_nPriority = 0x38 # int32_t + m_bodyGroupSettings = 0x40 # CUtlVector + +class CBodyGroupSetting: + m_BodyGroupName = 0x0 # CUtlString + m_nBodyGroupOption = 0x8 # int32_t + +class CBoneConstraintDotToMorph: + m_sBoneName = 0x28 # CUtlString + m_sTargetBoneName = 0x30 # CUtlString + m_sMorphChannelName = 0x38 # CUtlString + m_flRemap = 0x40 # float[4] + +class CBoneConstraintPoseSpaceBone: + m_inputList = 0x70 # CUtlVector + +class CBoneConstraintPoseSpaceBone_Input_t: + m_inputValue = 0x0 # Vector + m_outputTransformList = 0x10 # CUtlVector + +class CBoneConstraintPoseSpaceMorph: + m_sBoneName = 0x28 # CUtlString + m_sAttachmentName = 0x30 # CUtlString + m_outputMorph = 0x38 # CUtlVector + m_inputList = 0x50 # CUtlVector + m_bClamp = 0x68 # bool + +class CBoneConstraintPoseSpaceMorph_Input_t: + m_inputValue = 0x0 # Vector + m_outputWeightList = 0x10 # CUtlVector + +class CBoneMaskUpdateNode: + m_nWeightListIndex = 0x8C # int32_t + m_flRootMotionBlend = 0x90 # float + m_blendSpace = 0x94 # BoneMaskBlendSpace + m_footMotionTiming = 0x98 # BinaryNodeChildOption + m_bUseBlendScale = 0x9C # bool + m_blendValueSource = 0xA0 # AnimValueSource + m_hBlendParameter = 0xA4 # CAnimParamHandle + +class CBonePositionMetricEvaluator: + m_nBoneIndex = 0x50 # int32_t + +class CBoneVelocityMetricEvaluator: + m_nBoneIndex = 0x50 # int32_t + +class CBoolAnimParameter: + m_bDefaultValue = 0x60 # bool + +class CCPPScriptComponentUpdater: + m_scriptsToRun = 0x30 # CUtlVector + +class CCachedPose: + m_transforms = 0x8 # CUtlVector + m_morphWeights = 0x20 # CUtlVector + m_hSequence = 0x38 # HSequence + m_flCycle = 0x3C # float + +class CChoiceUpdateNode: + m_children = 0x58 # CUtlVector + m_weights = 0x70 # CUtlVector + m_blendTimes = 0x88 # CUtlVector + m_choiceMethod = 0xA0 # ChoiceMethod + m_choiceChangeMethod = 0xA4 # ChoiceChangeMethod + m_blendMethod = 0xA8 # ChoiceBlendMethod + m_blendTime = 0xAC # float + m_bCrossFade = 0xB0 # bool + m_bResetChosen = 0xB1 # bool + m_bDontResetSameSelection = 0xB2 # bool + +class CClothSettingsAnimTag: + m_flStiffness = 0x38 # float + m_flEaseIn = 0x3C # float + m_flEaseOut = 0x40 # float + m_nVertexSet = 0x48 # CUtlString + +class CCompressorGroup: + m_nTotalElementCount = 0x0 # int32_t + m_szChannelClass = 0x8 # CUtlVector + m_szVariableName = 0x20 # CUtlVector + m_nType = 0x38 # CUtlVector + m_nFlags = 0x50 # CUtlVector + m_szGrouping = 0x68 # CUtlVector + m_nCompressorIndex = 0x80 # CUtlVector + m_szElementNames = 0x98 # CUtlVector> + m_nElementUniqueID = 0xB0 # CUtlVector> + m_nElementMask = 0xC8 # CUtlVector + m_vectorCompressor = 0xF8 # CUtlVector*> + m_quaternionCompressor = 0x110 # CUtlVector*> + m_intCompressor = 0x128 # CUtlVector*> + m_boolCompressor = 0x140 # CUtlVector*> + m_colorCompressor = 0x158 # CUtlVector*> + m_vector2DCompressor = 0x170 # CUtlVector*> + m_vector4DCompressor = 0x188 # CUtlVector*> + +class CConcreteAnimParameter: + m_previewButton = 0x50 # AnimParamButton_t + m_eNetworkSetting = 0x54 # AnimParamNetworkSetting + m_bUseMostRecentValue = 0x58 # bool + m_bAutoReset = 0x59 # bool + m_bGameWritable = 0x5A # bool + m_bGraphWritable = 0x5B # bool + +class CConstraintSlave: + m_qBaseOrientation = 0x0 # Quaternion + m_vBasePosition = 0x10 # Vector + m_nBoneHash = 0x1C # uint32_t + m_flWeight = 0x20 # float + m_sName = 0x28 # CUtlString + +class CConstraintTarget: + m_qOffset = 0x20 # Quaternion + m_vOffset = 0x30 # Vector + m_nBoneHash = 0x3C # uint32_t + m_sName = 0x40 # CUtlString + m_flWeight = 0x48 # float + m_bIsAttachment = 0x59 # bool + +class CCycleBase: + m_flCycle = 0x0 # float + +class CCycleControlClipUpdateNode: + m_tags = 0x60 # CUtlVector + m_hSequence = 0x7C # HSequence + m_duration = 0x80 # float + m_valueSource = 0x84 # AnimValueSource + m_paramIndex = 0x88 # CAnimParamHandle + +class CCycleControlUpdateNode: + m_valueSource = 0x68 # AnimValueSource + m_paramIndex = 0x6C # CAnimParamHandle + +class CDampedPathAnimMotorUpdater: + m_flAnticipationTime = 0x2C # float + m_flMinSpeedScale = 0x30 # float + m_hAnticipationPosParam = 0x34 # CAnimParamHandle + m_hAnticipationHeadingParam = 0x36 # CAnimParamHandle + m_flSpringConstant = 0x38 # float + m_flMinSpringTension = 0x3C # float + m_flMaxSpringTension = 0x40 # float + +class CDampedValueComponentUpdater: + m_items = 0x30 # CUtlVector + +class CDampedValueUpdateItem: + m_damping = 0x0 # CAnimInputDamping + m_hParamIn = 0x18 # CAnimParamHandle + m_hParamOut = 0x1A # CAnimParamHandle + +class CDemoSettingsComponentUpdater: + m_settings = 0x30 # CAnimDemoCaptureSettings + +class CDirectPlaybackTagData: + m_sequenceName = 0x0 # CUtlString + m_tags = 0x8 # CUtlVector + +class CDirectPlaybackUpdateNode: + m_bFinishEarly = 0x6C # bool + m_bResetOnFinish = 0x6D # bool + m_allTags = 0x70 # CUtlVector + +class CDirectionalBlendUpdateNode: + m_hSequences = 0x5C # HSequence[8] + m_damping = 0x80 # CAnimInputDamping + m_blendValueSource = 0x90 # AnimValueSource + m_paramIndex = 0x94 # CAnimParamHandle + m_playbackSpeed = 0x98 # float + m_duration = 0x9C # float + m_bLoop = 0xA0 # bool + m_bLockBlendOnReset = 0xA1 # bool + +class CDistanceRemainingMetricEvaluator: + m_flMaxDistance = 0x50 # float + m_flMinDistance = 0x54 # float + m_flStartGoalFilterDistance = 0x58 # float + m_flMaxGoalOvershootScale = 0x5C # float + m_bFilterFixedMinDistance = 0x60 # bool + m_bFilterGoalDistance = 0x61 # bool + m_bFilterGoalOvershoot = 0x62 # bool + +class CDrawCullingData: + m_vConeApex = 0x0 # Vector + m_ConeAxis = 0xC # int8_t[3] + m_ConeCutoff = 0xF # int8_t + +class CEmitTagActionUpdater: + m_nTagIndex = 0x18 # int32_t + m_bIsZeroDuration = 0x1C # bool + +class CEnumAnimParameter: + m_defaultValue = 0x68 # uint8_t + m_enumOptions = 0x70 # CUtlVector + +class CExpressionActionUpdater: + m_hParam = 0x18 # CAnimParamHandle + m_eParamType = 0x1A # AnimParamType_t + m_hScript = 0x1C # AnimScriptHandle + +class CFingerBone: + m_boneName = 0x0 # CUtlString + m_hingeAxis = 0x8 # Vector + m_vCapsulePos1 = 0x14 # Vector + m_vCapsulePos2 = 0x20 # Vector + m_flMinAngle = 0x2C # float + m_flMaxAngle = 0x30 # float + m_flRadius = 0x34 # float + +class CFingerChain: + m_targets = 0x0 # CUtlVector + m_bones = 0x18 # CUtlVector + m_name = 0x30 # CUtlString + m_tipParentBoneName = 0x38 # CUtlString + m_vTipOffset = 0x40 # Vector + m_metacarpalBoneName = 0x50 # CUtlString + m_vSplayHingeAxis = 0x58 # Vector + m_flSplayMinAngle = 0x64 # float + m_flSplayMaxAngle = 0x68 # float + m_flFingerScaleRatio = 0x6C # float + +class CFingerSource: + m_nFingerIndex = 0x0 # AnimVRFinger_t + m_flFingerWeight = 0x4 # float + +class CFlexController: + m_szName = 0x0 # CUtlString + m_szType = 0x8 # CUtlString + min = 0x10 # float + max = 0x14 # float + +class CFlexDesc: + m_szFacs = 0x0 # CUtlString + +class CFlexOp: + m_OpCode = 0x0 # FlexOpCode_t + m_Data = 0x4 # int32_t + +class CFlexRule: + m_nFlex = 0x0 # int32_t + m_FlexOps = 0x8 # CUtlVector + +class CFloatAnimParameter: + m_fDefaultValue = 0x60 # float + m_fMinValue = 0x64 # float + m_fMaxValue = 0x68 # float + m_bInterpolate = 0x6C # bool + +class CFollowAttachmentUpdateNode: + m_opFixedData = 0x70 # FollowAttachmentSettings_t + +class CFollowPathUpdateNode: + m_flBlendOutTime = 0x6C # float + m_bBlockNonPathMovement = 0x70 # bool + m_bStopFeetAtGoal = 0x71 # bool + m_bScaleSpeed = 0x72 # bool + m_flScale = 0x74 # float + m_flMinAngle = 0x78 # float + m_flMaxAngle = 0x7C # float + m_flSpeedScaleBlending = 0x80 # float + m_turnDamping = 0x88 # CAnimInputDamping + m_facingTarget = 0x98 # AnimValueSource + m_hParam = 0x9C # CAnimParamHandle + m_flTurnToFaceOffset = 0xA0 # float + m_bTurnToFace = 0xA4 # bool + +class CFootAdjustmentUpdateNode: + m_clips = 0x70 # CUtlVector + m_hBasePoseCacheHandle = 0x88 # CPoseHandle + m_facingTarget = 0x8C # CAnimParamHandle + m_flTurnTimeMin = 0x90 # float + m_flTurnTimeMax = 0x94 # float + m_flStepHeightMax = 0x98 # float + m_flStepHeightMaxAngle = 0x9C # float + m_bResetChild = 0xA0 # bool + m_bAnimationDriven = 0xA1 # bool + +class CFootCycleDefinition: + m_vStancePositionMS = 0x0 # Vector + m_vMidpointPositionMS = 0xC # Vector + m_flStanceDirectionMS = 0x18 # float + m_vToStrideStartPos = 0x1C # Vector + m_stanceCycle = 0x28 # CAnimCycle + m_footLiftCycle = 0x2C # CFootCycle + m_footOffCycle = 0x30 # CFootCycle + m_footStrikeCycle = 0x34 # CFootCycle + m_footLandCycle = 0x38 # CFootCycle + +class CFootCycleMetricEvaluator: + m_footIndices = 0x50 # CUtlVector + +class CFootDefinition: + m_name = 0x0 # CUtlString + m_ankleBoneName = 0x8 # CUtlString + m_toeBoneName = 0x10 # CUtlString + m_vBallOffset = 0x18 # Vector + m_vHeelOffset = 0x24 # Vector + m_flFootLength = 0x30 # float + m_flBindPoseDirectionMS = 0x34 # float + m_flTraceHeight = 0x38 # float + m_flTraceRadius = 0x3C # float + +class CFootFallAnimTag: + m_foot = 0x38 # FootFallTagFoot_t + +class CFootLockUpdateNode: + m_opFixedSettings = 0x68 # FootLockPoseOpFixedSettings + m_footSettings = 0xD0 # CUtlVector + m_hipShiftDamping = 0xE8 # CAnimInputDamping + m_rootHeightDamping = 0xF8 # CAnimInputDamping + m_flStrideCurveScale = 0x108 # float + m_flStrideCurveLimitScale = 0x10C # float + m_flStepHeightIncreaseScale = 0x110 # float + m_flStepHeightDecreaseScale = 0x114 # float + m_flHipShiftScale = 0x118 # float + m_flBlendTime = 0x11C # float + m_flMaxRootHeightOffset = 0x120 # float + m_flMinRootHeightOffset = 0x124 # float + m_flTiltPlanePitchSpringStrength = 0x128 # float + m_flTiltPlaneRollSpringStrength = 0x12C # float + m_bApplyFootRotationLimits = 0x130 # bool + m_bApplyHipShift = 0x131 # bool + m_bModulateStepHeight = 0x132 # bool + m_bResetChild = 0x133 # bool + m_bEnableVerticalCurvedPaths = 0x134 # bool + m_bEnableRootHeightDamping = 0x135 # bool + +class CFootMotion: + m_strides = 0x0 # CUtlVector + m_name = 0x18 # CUtlString + m_bAdditive = 0x20 # bool + +class CFootPinningUpdateNode: + m_poseOpFixedData = 0x70 # FootPinningPoseOpFixedData_t + m_eTimingSource = 0xA0 # FootPinningTimingSource + m_params = 0xA8 # CUtlVector + m_bResetChild = 0xC0 # bool + +class CFootPositionMetricEvaluator: + m_footIndices = 0x50 # CUtlVector + m_bIgnoreSlope = 0x68 # bool + +class CFootStepTriggerUpdateNode: + m_triggers = 0x68 # CUtlVector + m_flTolerance = 0x84 # float + +class CFootStride: + m_definition = 0x0 # CFootCycleDefinition + m_trajectories = 0x40 # CFootTrajectories + +class CFootTrajectories: + m_trajectories = 0x0 # CUtlVector + +class CFootTrajectory: + m_vOffset = 0x0 # Vector + m_flRotationOffset = 0xC # float + m_flProgression = 0x10 # float + +class CFootstepLandedAnimTag: + m_FootstepType = 0x38 # FootstepLandedFootSoundType_t + m_OverrideSoundName = 0x40 # CUtlString + m_DebugAnimSourceString = 0x48 # CUtlString + m_BoneName = 0x50 # CUtlString + +class CFutureFacingMetricEvaluator: + m_flDistance = 0x50 # float + m_flTime = 0x54 # float + +class CFutureVelocityMetricEvaluator: + m_flDistance = 0x50 # float + m_flStoppingDistance = 0x54 # float + m_flTargetSpeed = 0x58 # float + m_eMode = 0x5C # VelocityMetricMode + +class CHitBox: + m_name = 0x0 # CUtlString + m_sSurfaceProperty = 0x8 # CUtlString + m_sBoneName = 0x10 # CUtlString + m_vMinBounds = 0x18 # Vector + m_vMaxBounds = 0x24 # Vector + m_flShapeRadius = 0x30 # float + m_nBoneNameHash = 0x34 # uint32_t + m_nGroupId = 0x38 # int32_t + m_nShapeType = 0x3C # uint8_t + m_bTranslationOnly = 0x3D # bool + m_CRC = 0x40 # uint32_t + m_cRenderColor = 0x44 # Color + m_nHitBoxIndex = 0x48 # uint16_t + +class CHitBoxSet: + m_name = 0x0 # CUtlString + m_nNameHash = 0x8 # uint32_t + m_HitBoxes = 0x10 # CUtlVector + m_SourceFilename = 0x28 # CUtlString + +class CHitBoxSetList: + m_HitBoxSets = 0x0 # CUtlVector + +class CHitReactUpdateNode: + m_opFixedSettings = 0x68 # HitReactFixedSettings_t + m_triggerParam = 0xB4 # CAnimParamHandle + m_hitBoneParam = 0xB6 # CAnimParamHandle + m_hitOffsetParam = 0xB8 # CAnimParamHandle + m_hitDirectionParam = 0xBA # CAnimParamHandle + m_hitStrengthParam = 0xBC # CAnimParamHandle + m_flMinDelayBetweenHits = 0xC0 # float + m_bResetChild = 0xC4 # bool + +class CIntAnimParameter: + m_defaultValue = 0x60 # int32_t + m_minValue = 0x64 # int32_t + m_maxValue = 0x68 # int32_t + +class CJiggleBoneUpdateNode: + m_opFixedData = 0x68 # JiggleBoneSettingsList_t + +class CJumpHelperUpdateNode: + m_hTargetParam = 0xA8 # CAnimParamHandle + m_flOriginalJumpMovement = 0xAC # Vector + m_flOriginalJumpDuration = 0xB8 # float + m_flJumpStartCycle = 0xBC # float + m_flJumpEndCycle = 0xC0 # float + m_eCorrectionMethod = 0xC4 # JumpCorrectionMethod + m_bTranslationAxis = 0xC8 # bool[3] + m_bScaleSpeed = 0xCB # bool + +class CLODComponentUpdater: + m_nServerLOD = 0x30 # int32_t + +class CLeanMatrixUpdateNode: + m_frameCorners = 0x5C # int32_t[3][3] + m_poses = 0x80 # CPoseHandle[9] + m_damping = 0xA8 # CAnimInputDamping + m_blendSource = 0xB8 # AnimVectorSource + m_paramIndex = 0xBC # CAnimParamHandle + m_verticalAxis = 0xC0 # Vector + m_horizontalAxis = 0xCC # Vector + m_hSequence = 0xD8 # HSequence + m_flMaxValue = 0xDC # float + m_nSequenceMaxFrame = 0xE0 # int32_t + +class CLookAtUpdateNode: + m_opFixedSettings = 0x70 # LookAtOpFixedSettings_t + m_target = 0x138 # AnimVectorSource + m_paramIndex = 0x13C # CAnimParamHandle + m_weightParamIndex = 0x13E # CAnimParamHandle + m_bResetChild = 0x140 # bool + m_bLockWhenWaning = 0x141 # bool + +class CLookComponentUpdater: + m_hLookHeading = 0x34 # CAnimParamHandle + m_hLookHeadingVelocity = 0x36 # CAnimParamHandle + m_hLookPitch = 0x38 # CAnimParamHandle + m_hLookDistance = 0x3A # CAnimParamHandle + m_hLookDirection = 0x3C # CAnimParamHandle + m_hLookTarget = 0x3E # CAnimParamHandle + m_hLookTargetWorldSpace = 0x40 # CAnimParamHandle + m_bNetworkLookTarget = 0x42 # bool + +class CMaterialAttributeAnimTag: + m_AttributeName = 0x38 # CUtlString + m_AttributeType = 0x40 # MatterialAttributeTagType_t + m_flValue = 0x44 # float + m_Color = 0x48 # Color + +class CMaterialDrawDescriptor: + m_nPrimitiveType = 0x0 # RenderPrimitiveType_t + m_nBaseVertex = 0x4 # int32_t + m_nVertexCount = 0x8 # int32_t + m_nStartIndex = 0xC # int32_t + m_nIndexCount = 0x10 # int32_t + m_flUvDensity = 0x14 # float + m_vTintColor = 0x18 # Vector + m_flAlpha = 0x24 # float + m_nFirstMeshlet = 0x2C # uint32_t + m_nNumMeshlets = 0x30 # uint16_t + m_indexBuffer = 0xB8 # CRenderBufferBinding + m_material = 0xE0 # CStrongHandle + +class CMeshletDescriptor: + m_PackedAABB = 0x0 # PackedAABB_t + m_CullingData = 0x8 # CDrawCullingData + +class CModelConfig: + m_ConfigName = 0x0 # CUtlString + m_Elements = 0x8 # CUtlVector + m_bTopLevel = 0x20 # bool + +class CModelConfigElement: + m_ElementName = 0x8 # CUtlString + m_NestedElements = 0x10 # CUtlVector + +class CModelConfigElement_AttachedModel: + m_InstanceName = 0x48 # CUtlString + m_EntityClass = 0x50 # CUtlString + m_hModel = 0x58 # CStrongHandle + m_vOffset = 0x60 # Vector + m_aAngOffset = 0x6C # QAngle + m_AttachmentName = 0x78 # CUtlString + m_LocalAttachmentOffsetName = 0x80 # CUtlString + m_AttachmentType = 0x88 # ModelConfigAttachmentType_t + m_bBoneMergeFlex = 0x8C # bool + m_bUserSpecifiedColor = 0x8D # bool + m_bUserSpecifiedMaterialGroup = 0x8E # bool + m_bAcceptParentMaterialDrivenDecals = 0x8F # bool + m_BodygroupOnOtherModels = 0x90 # CUtlString + m_MaterialGroupOnOtherModels = 0x98 # CUtlString + +class CModelConfigElement_Command: + m_Command = 0x48 # CUtlString + m_Args = 0x50 # KeyValues3 + +class CModelConfigElement_RandomColor: + m_Gradient = 0x48 # CColorGradient + +class CModelConfigElement_RandomPick: + m_Choices = 0x48 # CUtlVector + m_ChoiceWeights = 0x60 # CUtlVector + +class CModelConfigElement_SetBodygroup: + m_GroupName = 0x48 # CUtlString + m_nChoice = 0x50 # int32_t + +class CModelConfigElement_SetBodygroupOnAttachedModels: + m_GroupName = 0x48 # CUtlString + m_nChoice = 0x50 # int32_t + +class CModelConfigElement_SetMaterialGroup: + m_MaterialGroupName = 0x48 # CUtlString + +class CModelConfigElement_SetMaterialGroupOnAttachedModels: + m_MaterialGroupName = 0x48 # CUtlString + +class CModelConfigElement_SetRenderColor: + m_Color = 0x48 # Color + +class CModelConfigElement_UserPick: + m_Choices = 0x48 # CUtlVector + +class CModelConfigList: + m_bHideMaterialGroupInTools = 0x0 # bool + m_bHideRenderColorInTools = 0x1 # bool + m_Configs = 0x8 # CUtlVector + +class CMoodVData: + m_sModelName = 0x0 # CResourceNameTyped> + m_nMoodType = 0xE0 # MoodType_t + m_animationLayers = 0xE8 # CUtlVector + +class CMorphBundleData: + m_flULeftSrc = 0x0 # float + m_flVTopSrc = 0x4 # float + m_offsets = 0x8 # CUtlVector + m_ranges = 0x20 # CUtlVector + +class CMorphConstraint: + m_sTargetMorph = 0x70 # CUtlString + m_nSlaveChannel = 0x78 # int32_t + m_flMin = 0x7C # float + m_flMax = 0x80 # float + +class CMorphData: + m_name = 0x0 # CUtlString + m_morphRectDatas = 0x8 # CUtlVector + +class CMorphRectData: + m_nXLeftDst = 0x0 # int16_t + m_nYTopDst = 0x2 # int16_t + m_flUWidthSrc = 0x4 # float + m_flVHeightSrc = 0x8 # float + m_bundleDatas = 0x10 # CUtlVector + +class CMorphSetData: + m_nWidth = 0x10 # int32_t + m_nHeight = 0x14 # int32_t + m_bundleTypes = 0x18 # CUtlVector + m_morphDatas = 0x30 # CUtlVector + m_pTextureAtlas = 0x48 # CStrongHandle + m_FlexDesc = 0x50 # CUtlVector + m_FlexControllers = 0x68 # CUtlVector + m_FlexRules = 0x80 # CUtlVector + +class CMotionDataSet: + m_groups = 0x0 # CUtlVector + m_nDimensionCount = 0x18 # int32_t + +class CMotionGraph: + m_paramSpans = 0x10 # CParamSpanUpdater + m_tags = 0x28 # CUtlVector + m_pRootNode = 0x40 # CSmartPtr + m_nParameterCount = 0x48 # int32_t + m_nConfigStartIndex = 0x4C # int32_t + m_nConfigCount = 0x50 # int32_t + m_bLoop = 0x54 # bool + +class CMotionGraphConfig: + m_paramValues = 0x0 # float[4] + m_flDuration = 0x10 # float + m_nMotionIndex = 0x14 # MotionIndex + m_nSampleStart = 0x18 # int32_t + m_nSampleCount = 0x1C # int32_t + +class CMotionGraphGroup: + m_searchDB = 0x0 # CMotionSearchDB + m_motionGraphs = 0xB8 # CUtlVector> + m_motionGraphConfigs = 0xD0 # CUtlVector + m_sampleToConfig = 0xE8 # CUtlVector + m_hIsActiveScript = 0x100 # AnimScriptHandle + +class CMotionGraphUpdateNode: + m_pMotionGraph = 0x58 # CSmartPtr + +class CMotionMatchingUpdateNode: + m_dataSet = 0x58 # CMotionDataSet + m_metrics = 0x78 # CUtlVector> + m_weights = 0x90 # CUtlVector + m_bSearchEveryTick = 0xE0 # bool + m_flSearchInterval = 0xE4 # float + m_bSearchWhenClipEnds = 0xE8 # bool + m_bSearchWhenGoalChanges = 0xE9 # bool + m_blendCurve = 0xEC # CBlendCurve + m_flSampleRate = 0xF4 # float + m_flBlendTime = 0xF8 # float + m_bLockClipWhenWaning = 0xFC # bool + m_flSelectionThreshold = 0x100 # float + m_flReselectionTimeWindow = 0x104 # float + m_bEnableRotationCorrection = 0x108 # bool + m_bGoalAssist = 0x109 # bool + m_flGoalAssistDistance = 0x10C # float + m_flGoalAssistTolerance = 0x110 # float + m_distanceScale_Damping = 0x118 # CAnimInputDamping + m_flDistanceScale_OuterRadius = 0x128 # float + m_flDistanceScale_InnerRadius = 0x12C # float + m_flDistanceScale_MaxScale = 0x130 # float + m_flDistanceScale_MinScale = 0x134 # float + m_bEnableDistanceScaling = 0x138 # bool + +class CMotionMetricEvaluator: + m_means = 0x18 # CUtlVector + m_standardDeviations = 0x30 # CUtlVector + m_flWeight = 0x48 # float + m_nDimensionStartIndex = 0x4C # int32_t + +class CMotionNode: + m_name = 0x18 # CUtlString + m_id = 0x20 # AnimNodeID + +class CMotionNodeBlend1D: + m_blendItems = 0x28 # CUtlVector + m_nParamIndex = 0x40 # int32_t + +class CMotionNodeSequence: + m_tags = 0x28 # CUtlVector + m_hSequence = 0x40 # HSequence + m_flPlaybackSpeed = 0x44 # float + +class CMotionSearchDB: + m_rootNode = 0x0 # CMotionSearchNode + m_residualQuantizer = 0x80 # CProductQuantizer + m_codeIndices = 0xA0 # CUtlVector + +class CMotionSearchNode: + m_children = 0x0 # CUtlVector + m_quantizer = 0x18 # CVectorQuantizer + m_sampleCodes = 0x38 # CUtlVector> + m_sampleIndices = 0x50 # CUtlVector> + m_selectableSamples = 0x68 # CUtlVector + +class CMovementComponentUpdater: + m_movementModes = 0x30 # CUtlVector + m_motors = 0x48 # CUtlVector> + m_facingDamping = 0x60 # CAnimInputDamping + m_eDefaultFacingMode = 0x70 # FacingMode + m_nDefaultMotorIndex = 0x7C # int32_t + m_bMoveVarsDisabled = 0x80 # bool + m_bNetworkPath = 0x81 # bool + m_bNetworkFacing = 0x82 # bool + m_paramHandles = 0x83 # CAnimParamHandle[30] + +class CMovementMode: + m_name = 0x0 # CUtlString + m_flSpeed = 0x8 # float + +class CMoverUpdateNode: + m_damping = 0x70 # CAnimInputDamping + m_facingTarget = 0x80 # AnimValueSource + m_hMoveVecParam = 0x84 # CAnimParamHandle + m_hMoveHeadingParam = 0x86 # CAnimParamHandle + m_hTurnToFaceParam = 0x88 # CAnimParamHandle + m_flTurnToFaceOffset = 0x8C # float + m_flTurnToFaceLimit = 0x90 # float + m_bAdditive = 0x94 # bool + m_bApplyMovement = 0x95 # bool + m_bOrientMovement = 0x96 # bool + m_bApplyRotation = 0x97 # bool + m_bLimitOnly = 0x98 # bool + +class CParamSpanUpdater: + m_spans = 0x0 # CUtlVector + +class CParticleAnimTag: + m_hParticleSystem = 0x38 # CStrongHandle + m_particleSystemName = 0x40 # CUtlString + m_configName = 0x48 # CUtlString + m_bDetachFromOwner = 0x50 # bool + m_bStopWhenTagEnds = 0x51 # bool + m_bTagEndStopIsInstant = 0x52 # bool + m_attachmentName = 0x58 # CUtlString + m_attachmentType = 0x60 # ParticleAttachment_t + m_attachmentCP1Name = 0x68 # CUtlString + m_attachmentCP1Type = 0x70 # ParticleAttachment_t + +class CPathAnimMotorUpdaterBase: + m_bLockToPath = 0x20 # bool + +class CPathHelperUpdateNode: + m_flStoppingRadius = 0x68 # float + m_flStoppingSpeedScale = 0x6C # float + +class CPathMetricEvaluator: + m_pathTimeSamples = 0x50 # CUtlVector + m_flDistance = 0x68 # float + m_bExtrapolateMovement = 0x6C # bool + m_flMinExtrapolationSpeed = 0x70 # float + +class CPhysSurfaceProperties: + m_name = 0x0 # CUtlString + m_nameHash = 0x8 # uint32_t + m_baseNameHash = 0xC # uint32_t + m_bHidden = 0x18 # bool + m_description = 0x20 # CUtlString + m_physics = 0x28 # CPhysSurfacePropertiesPhysics + m_audioSounds = 0x48 # CPhysSurfacePropertiesSoundNames + m_audioParams = 0x88 # CPhysSurfacePropertiesAudio + +class CPhysSurfacePropertiesAudio: + m_reflectivity = 0x0 # float + m_hardnessFactor = 0x4 # float + m_roughnessFactor = 0x8 # float + m_roughThreshold = 0xC # float + m_hardThreshold = 0x10 # float + m_hardVelocityThreshold = 0x14 # float + m_flStaticImpactVolume = 0x18 # float + m_flOcclusionFactor = 0x1C # float + +class CPhysSurfacePropertiesPhysics: + m_friction = 0x0 # float + m_elasticity = 0x4 # float + m_density = 0x8 # float + m_thickness = 0xC # float + m_softContactFrequency = 0x10 # float + m_softContactDampingRatio = 0x14 # float + m_wheelDrag = 0x18 # float + +class CPhysSurfacePropertiesSoundNames: + m_impactSoft = 0x0 # CUtlString + m_impactHard = 0x8 # CUtlString + m_scrapeSmooth = 0x10 # CUtlString + m_scrapeRough = 0x18 # CUtlString + m_bulletImpact = 0x20 # CUtlString + m_rolling = 0x28 # CUtlString + m_break = 0x30 # CUtlString + m_strain = 0x38 # CUtlString + +class CPlayerInputAnimMotorUpdater: + m_sampleTimes = 0x20 # CUtlVector + m_flSpringConstant = 0x3C # float + m_flAnticipationDistance = 0x40 # float + m_hAnticipationPosParam = 0x44 # CAnimParamHandle + m_hAnticipationHeadingParam = 0x46 # CAnimParamHandle + m_bUseAcceleration = 0x48 # bool + +class CPoseHandle: + m_nIndex = 0x0 # uint16_t + m_eType = 0x2 # PoseType_t + +class CProductQuantizer: + m_subQuantizers = 0x0 # CUtlVector + m_nDimensions = 0x18 # int32_t + +class CQuaternionAnimParameter: + m_defaultValue = 0x60 # Quaternion + m_bInterpolate = 0x70 # bool + +class CRagdollAnimTag: + m_nPoseControl = 0x38 # AnimPoseControl + m_flFrequency = 0x3C # float + m_flDampingRatio = 0x40 # float + m_flDecayDuration = 0x44 # float + m_flDecayBias = 0x48 # float + m_bDestroy = 0x4C # bool + +class CRagdollComponentUpdater: + m_ragdollNodePaths = 0x30 # CUtlVector + m_boneIndices = 0x48 # CUtlVector + m_boneNames = 0x60 # CUtlVector + m_weightLists = 0x78 # CUtlVector + m_flSpringFrequencyMin = 0x90 # float + m_flSpringFrequencyMax = 0x94 # float + m_flMaxStretch = 0x98 # float + +class CRagdollUpdateNode: + m_nWeightListIndex = 0x68 # int32_t + m_poseControlMethod = 0x6C # RagdollPoseControl + +class CRenderBufferBinding: + m_hBuffer = 0x0 # uint64_t + m_nBindOffsetBytes = 0x10 # uint32_t + +class CRenderMesh: + m_sceneObjects = 0x10 # CUtlVectorFixedGrowable + m_constraints = 0xA0 # CUtlVector + m_skeleton = 0xB8 # CRenderSkeleton + +class CRenderSkeleton: + m_bones = 0x0 # CUtlVector + m_boneParents = 0x30 # CUtlVector + m_nBoneWeightCount = 0x48 # int32_t + +class CSceneObjectData: + m_vMinBounds = 0x0 # Vector + m_vMaxBounds = 0xC # Vector + m_drawCalls = 0x18 # CUtlVector + m_drawBounds = 0x30 # CUtlVector + m_meshlets = 0x48 # CUtlVector + m_vTintColor = 0x60 # Vector4D + +class CSelectorUpdateNode: + m_children = 0x58 # CUtlVector + m_tags = 0x70 # CUtlVector + m_blendCurve = 0x8C # CBlendCurve + m_flBlendTime = 0x94 # CAnimValue + m_hParameter = 0x9C # CAnimParamHandle + m_eTagBehavior = 0xA0 # SelectorTagBehavior_t + m_bResetOnChange = 0xA4 # bool + m_bSyncCyclesOnChange = 0xA5 # bool + +class CSeqAutoLayer: + m_nLocalReference = 0x0 # int16_t + m_nLocalPose = 0x2 # int16_t + m_flags = 0x4 # CSeqAutoLayerFlag + m_start = 0xC # float + m_peak = 0x10 # float + m_tail = 0x14 # float + m_end = 0x18 # float + +class CSeqAutoLayerFlag: + 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 # bool + +class CSeqBoneMaskList: + m_sName = 0x0 # CBufferString + m_nLocalBoneArray = 0x10 # CUtlVector + m_flBoneWeightArray = 0x28 # CUtlVector + m_flDefaultMorphCtrlWeight = 0x40 # float + m_morphCtrlWeightArray = 0x48 # CUtlVector> + +class CSeqCmdLayer: + m_cmd = 0x0 # int16_t + m_nLocalReference = 0x2 # int16_t + m_nLocalBonemask = 0x4 # int16_t + m_nDstResult = 0x6 # int16_t + m_nSrcResult = 0x8 # int16_t + m_bSpline = 0xA # bool + m_flVar1 = 0xC # float + m_flVar2 = 0x10 # float + m_nLineNumber = 0x14 # int16_t + +class CSeqCmdSeqDesc: + m_sName = 0x0 # CBufferString + m_flags = 0x10 # CSeqSeqDescFlag + m_transition = 0x1C # CSeqTransition + m_nFrameRangeSequence = 0x24 # int16_t + m_nFrameCount = 0x26 # int16_t + m_flFPS = 0x28 # float + m_nSubCycles = 0x2C # int16_t + m_numLocalResults = 0x2E # int16_t + m_cmdLayerArray = 0x30 # CUtlVector + m_eventArray = 0x48 # CUtlVector + m_activityArray = 0x60 # CUtlVector + m_poseSettingArray = 0x78 # CUtlVector + +class CSeqIKLock: + m_flPosWeight = 0x0 # float + m_flAngleWeight = 0x4 # float + m_nLocalBone = 0x8 # int16_t + m_bBonesOrientedAlongPositiveX = 0xA # bool + +class CSeqMultiFetch: + m_flags = 0x0 # CSeqMultiFetchFlag + m_localReferenceArray = 0x8 # CUtlVector + m_nGroupSize = 0x20 # int32_t[2] + m_nLocalPose = 0x28 # int32_t[2] + m_poseKeyArray0 = 0x30 # CUtlVector + m_poseKeyArray1 = 0x48 # CUtlVector + m_nLocalCyclePoseParameter = 0x60 # int32_t + m_bCalculatePoseParameters = 0x64 # bool + +class CSeqMultiFetchFlag: + m_bRealtime = 0x0 # bool + m_bCylepose = 0x1 # bool + m_b0D = 0x2 # bool + m_b1D = 0x3 # bool + m_b2D = 0x4 # bool + m_b2D_TRI = 0x5 # bool + +class CSeqPoseParamDesc: + m_sName = 0x0 # CBufferString + m_flStart = 0x10 # float + m_flEnd = 0x14 # float + m_flLoop = 0x18 # float + m_bLooping = 0x1C # bool + +class CSeqPoseSetting: + m_sPoseParameter = 0x0 # CBufferString + m_sAttachment = 0x10 # CBufferString + m_sReferenceSequence = 0x20 # CBufferString + m_flValue = 0x30 # float + m_bX = 0x34 # bool + m_bY = 0x35 # bool + m_bZ = 0x36 # bool + m_eType = 0x38 # int32_t + +class CSeqS1SeqDesc: + m_sName = 0x0 # CBufferString + m_flags = 0x10 # CSeqSeqDescFlag + m_fetch = 0x20 # CSeqMultiFetch + m_nLocalWeightlist = 0x88 # int32_t + m_autoLayerArray = 0x90 # CUtlVector + m_IKLockArray = 0xA8 # CUtlVector + m_transition = 0xC0 # CSeqTransition + m_SequenceKeys = 0xC8 # KeyValues3 + m_LegacyKeyValueText = 0xD8 # CBufferString + m_activityArray = 0xE8 # CUtlVector + m_footMotion = 0x100 # CUtlVector + +class CSeqScaleSet: + m_sName = 0x0 # CBufferString + m_bRootOffset = 0x10 # bool + m_vRootOffset = 0x14 # Vector + m_nLocalBoneArray = 0x20 # CUtlVector + m_flBoneScaleArray = 0x38 # CUtlVector + +class CSeqSeqDescFlag: + 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 # bool + +class CSeqSynthAnimDesc: + m_sName = 0x0 # CBufferString + m_flags = 0x10 # CSeqSeqDescFlag + m_transition = 0x1C # CSeqTransition + m_nLocalBaseReference = 0x24 # int16_t + m_nLocalBoneMask = 0x26 # int16_t + m_activityArray = 0x28 # CUtlVector + +class CSeqTransition: + m_flFadeInTime = 0x0 # float + m_flFadeOutTime = 0x4 # float + +class CSequenceFinishedAnimTag: + m_sequenceName = 0x38 # CUtlString + +class CSequenceGroupData: + m_sName = 0x10 # CBufferString + m_nFlags = 0x20 # uint32_t + m_localSequenceNameArray = 0x28 # CUtlVector + m_localS1SeqDescArray = 0x40 # CUtlVector + m_localMultiSeqDescArray = 0x58 # CUtlVector + m_localSynthAnimDescArray = 0x70 # CUtlVector + m_localCmdSeqDescArray = 0x88 # CUtlVector + m_localBoneMaskArray = 0xA0 # CUtlVector + m_localScaleSetArray = 0xB8 # CUtlVector + m_localBoneNameArray = 0xD0 # CUtlVector + m_localNodeName = 0xE8 # CBufferString + m_localPoseParamArray = 0xF8 # CUtlVector + m_keyValues = 0x110 # KeyValues3 + m_localIKAutoplayLockArray = 0x120 # CUtlVector + +class CSequenceUpdateNode: + m_paramSpans = 0x60 # CParamSpanUpdater + m_tags = 0x78 # CUtlVector + m_hSequence = 0x94 # HSequence + m_playbackSpeed = 0x98 # float + m_duration = 0x9C # float + m_bLoop = 0xA0 # bool + +class CSetFacingUpdateNode: + m_facingMode = 0x68 # FacingMode + m_bResetChild = 0x6C # bool + +class CSetParameterActionUpdater: + m_hParam = 0x18 # CAnimParamHandle + m_value = 0x1A # CAnimVariant + +class CSingleFrameUpdateNode: + m_actions = 0x58 # CUtlVector> + m_hPoseCacheHandle = 0x70 # CPoseHandle + m_hSequence = 0x74 # HSequence + m_flCycle = 0x78 # float + +class CSkeletalInputUpdateNode: + m_fixedOpData = 0x58 # SkeletalInputOpFixedSettings_t + +class CSlopeComponentUpdater: + m_flTraceDistance = 0x34 # float + m_hSlopeAngle = 0x38 # CAnimParamHandle + m_hSlopeAngleFront = 0x3A # CAnimParamHandle + m_hSlopeAngleSide = 0x3C # CAnimParamHandle + m_hSlopeHeading = 0x3E # CAnimParamHandle + m_hSlopeNormal = 0x40 # CAnimParamHandle + m_hSlopeNormal_WorldSpace = 0x42 # CAnimParamHandle + +class CSlowDownOnSlopesUpdateNode: + m_flSlowDownStrength = 0x68 # float + +class CSolveIKChainUpdateNode: + m_targetHandles = 0x68 # CUtlVector + m_opFixedData = 0x80 # SolveIKChainPoseOpFixedSettings_t + +class CSolveIKTargetHandle_t: + m_positionHandle = 0x0 # CAnimParamHandle + m_orientationHandle = 0x2 # CAnimParamHandle + +class CSpeedScaleUpdateNode: + m_paramIndex = 0x68 # CAnimParamHandle + +class CStanceOverrideUpdateNode: + m_footStanceInfo = 0x68 # CUtlVector + m_pStanceSourceNode = 0x80 # CAnimUpdateNodeRef + m_hParameter = 0x90 # CAnimParamHandle + m_eMode = 0x94 # StanceOverrideMode + +class CStanceScaleUpdateNode: + m_hParam = 0x68 # CAnimParamHandle + +class CStateActionUpdater: + m_pAction = 0x0 # CSmartPtr + m_eBehavior = 0x8 # StateActionBehavior + +class CStateMachineComponentUpdater: + m_stateMachine = 0x30 # CAnimStateMachineUpdater + +class CStateMachineUpdateNode: + m_stateMachine = 0x68 # CAnimStateMachineUpdater + m_stateData = 0xC0 # CUtlVector + m_transitionData = 0xD8 # CUtlVector + m_bBlockWaningTags = 0xF4 # bool + m_bLockStateWhenWaning = 0xF5 # bool + +class CStateNodeStateData: + m_pChild = 0x0 # CAnimUpdateNodeRef + m_bExclusiveRootMotion = 0x0 # bitfield:1 + +class CStateNodeTransitionData: + m_curve = 0x0 # CBlendCurve + m_blendDuration = 0x8 # CAnimValue + m_resetCycleValue = 0x10 # CAnimValue + m_bReset = 0x0 # bitfield:1 + m_resetCycleOption = 0x0 # bitfield:3 + +class CStateUpdateData: + m_name = 0x0 # CUtlString + m_hScript = 0x8 # AnimScriptHandle + m_transitionIndices = 0x10 # CUtlVector + m_actions = 0x28 # CUtlVector + m_stateID = 0x40 # AnimStateID + m_bIsStartState = 0x0 # bitfield:1 + m_bIsEndState = 0x0 # bitfield:1 + m_bIsPassthrough = 0x0 # bitfield:1 + +class CStaticPoseCache: + m_poses = 0x10 # CUtlVector + m_nBoneCount = 0x28 # int32_t + m_nMorphCount = 0x2C # int32_t + +class CStepsRemainingMetricEvaluator: + m_footIndices = 0x50 # CUtlVector + m_flMinStepsRemaining = 0x68 # float + +class CStopAtGoalUpdateNode: + m_flOuterRadius = 0x6C # float + m_flInnerRadius = 0x70 # float + m_flMaxScale = 0x74 # float + m_flMinScale = 0x78 # float + m_damping = 0x80 # CAnimInputDamping + +class CSubtractUpdateNode: + m_footMotionTiming = 0x8C # BinaryNodeChildOption + m_bApplyToFootMotion = 0x90 # bool + m_bApplyChannelsSeparately = 0x91 # bool + m_bUseModelSpace = 0x92 # bool + +class CTiltTwistConstraint: + m_nTargetAxis = 0x70 # int32_t + m_nSlaveAxis = 0x74 # int32_t + +class CTimeRemainingMetricEvaluator: + m_bMatchByTimeRemaining = 0x50 # bool + m_flMaxTimeRemaining = 0x54 # float + m_bFilterByTimeRemaining = 0x58 # bool + m_flMinTimeRemaining = 0x5C # float + +class CToggleComponentActionUpdater: + m_componentID = 0x18 # AnimComponentID + m_bSetEnabled = 0x1C # bool + +class CTransitionUpdateData: + m_srcStateIndex = 0x0 # uint8_t + m_destStateIndex = 0x1 # uint8_t + m_bDisabled = 0x0 # bitfield:1 + +class CTurnHelperUpdateNode: + m_facingTarget = 0x6C # AnimValueSource + m_turnStartTimeOffset = 0x70 # float + m_turnDuration = 0x74 # float + m_bMatchChildDuration = 0x78 # bool + m_manualTurnOffset = 0x7C # float + m_bUseManualTurnOffset = 0x80 # bool + +class CTwistConstraint: + m_bInverse = 0x70 # bool + m_qParentBindRotation = 0x80 # Quaternion + m_qChildBindRotation = 0x90 # Quaternion + +class CTwoBoneIKUpdateNode: + m_opFixedData = 0x70 # TwoBoneIKSettings_t + +class CUnaryUpdateNode: + m_pChildNode = 0x58 # CAnimUpdateNodeRef + +class CVPhysXSurfacePropertiesList: + m_surfacePropertiesList = 0x0 # CUtlVector + +class CVRInputComponentUpdater: + m_FingerCurl_Thumb = 0x34 # CAnimParamHandle + m_FingerCurl_Index = 0x36 # CAnimParamHandle + m_FingerCurl_Middle = 0x38 # CAnimParamHandle + m_FingerCurl_Ring = 0x3A # CAnimParamHandle + m_FingerCurl_Pinky = 0x3C # CAnimParamHandle + m_FingerSplay_Thumb_Index = 0x3E # CAnimParamHandle + m_FingerSplay_Index_Middle = 0x40 # CAnimParamHandle + m_FingerSplay_Middle_Ring = 0x42 # CAnimParamHandle + m_FingerSplay_Ring_Pinky = 0x44 # CAnimParamHandle + +class CVectorAnimParameter: + m_defaultValue = 0x60 # Vector + m_bInterpolate = 0x6C # bool + +class CVectorQuantizer: + m_centroidVectors = 0x0 # CUtlVector + m_nCentroids = 0x18 # int32_t + m_nDimensions = 0x1C # int32_t + +class CVirtualAnimParameter: + m_expressionString = 0x50 # CUtlString + m_eParamType = 0x58 # AnimParamType_t + +class CVrSkeletalInputSettings: + m_wristBones = 0x0 # CUtlVector + m_fingers = 0x18 # CUtlVector + m_name = 0x30 # CUtlString + m_outerKnuckle1 = 0x38 # CUtlString + m_outerKnuckle2 = 0x40 # CUtlString + m_eHand = 0x48 # AnimVRHand_t + +class CWayPointHelperUpdateNode: + m_flStartCycle = 0x6C # float + m_flEndCycle = 0x70 # float + m_bOnlyGoals = 0x74 # bool + m_bPreventOvershoot = 0x75 # bool + m_bPreventUndershoot = 0x76 # bool + +class CWristBone: + m_name = 0x0 # CUtlString + m_vForwardLS = 0x8 # Vector + m_vUpLS = 0x14 # Vector + m_vOffset = 0x20 # Vector + +class ChainToSolveData_t: + m_nChainIndex = 0x0 # int32_t + m_SolverSettings = 0x4 # IKSolverSettings_t + m_TargetSettings = 0x10 # IKTargetSettings_t + m_DebugSetting = 0x38 # SolveIKChainAnimNodeDebugSetting + m_flDebugNormalizedValue = 0x3C # float + m_vDebugOffset = 0x40 # VectorAligned + +class ConfigIndex: + m_nGroup = 0x0 # uint16_t + m_nConfig = 0x2 # uint16_t + +class FingerBone_t: + m_boneIndex = 0x0 # int32_t + m_hingeAxis = 0x4 # Vector + m_vCapsulePos1 = 0x10 # Vector + m_vCapsulePos2 = 0x1C # Vector + m_flMinAngle = 0x28 # float + m_flMaxAngle = 0x2C # float + m_flRadius = 0x30 # float + +class FingerChain_t: + m_targets = 0x0 # CUtlVector + m_bones = 0x18 # CUtlVector + m_vTipOffset = 0x30 # Vector + m_vSplayHingeAxis = 0x3C # Vector + m_tipParentBoneIndex = 0x48 # int32_t + m_metacarpalBoneIndex = 0x4C # int32_t + m_flSplayMinAngle = 0x50 # float + m_flSplayMaxAngle = 0x54 # float + m_flFingerScaleRatio = 0x58 # float + +class FingerSource_t: + m_nFingerIndex = 0x0 # AnimVRFinger_t + m_flFingerWeight = 0x4 # float + +class FollowAttachmentSettings_t: + m_attachment = 0x0 # CAnimAttachment + m_boneIndex = 0x80 # int32_t + m_bMatchTranslation = 0x84 # bool + m_bMatchRotation = 0x85 # bool + +class FootFixedData_t: + m_vToeOffset = 0x0 # VectorAligned + m_vHeelOffset = 0x10 # VectorAligned + m_nTargetBoneIndex = 0x20 # int32_t + m_nAnkleBoneIndex = 0x24 # int32_t + m_nIKAnchorBoneIndex = 0x28 # int32_t + m_ikChainIndex = 0x2C # int32_t + m_flMaxIKLength = 0x30 # float + m_nFootIndex = 0x34 # int32_t + m_nTagIndex = 0x38 # int32_t + m_flMaxRotationLeft = 0x3C # float + m_flMaxRotationRight = 0x40 # float + +class FootFixedSettings: + m_traceSettings = 0x0 # TraceSettings_t + m_vFootBaseBindPosePositionMS = 0x10 # VectorAligned + m_flFootBaseLength = 0x20 # float + m_flMaxRotationLeft = 0x24 # float + m_flMaxRotationRight = 0x28 # float + m_footstepLandedTagIndex = 0x2C # int32_t + m_bEnableTracing = 0x30 # bool + m_flTraceAngleBlend = 0x34 # float + m_nDisableTagIndex = 0x38 # int32_t + m_nFootIndex = 0x3C # int32_t + +class FootLockPoseOpFixedSettings: + m_footInfo = 0x0 # CUtlVector + m_hipDampingSettings = 0x18 # CAnimInputDamping + m_nHipBoneIndex = 0x28 # int32_t + m_ikSolverType = 0x2C # IKSolverType + m_bApplyTilt = 0x30 # bool + m_bApplyHipDrop = 0x31 # bool + m_bAlwaysUseFallbackHinge = 0x32 # bool + m_bApplyFootRotationLimits = 0x33 # bool + m_bApplyLegTwistLimits = 0x34 # bool + m_flMaxFootHeight = 0x38 # float + m_flExtensionScale = 0x3C # float + m_flMaxLegTwist = 0x40 # float + m_bEnableLockBreaking = 0x44 # bool + m_flLockBreakTolerance = 0x48 # float + m_flLockBlendTime = 0x4C # float + m_bEnableStretching = 0x50 # bool + m_flMaxStretchAmount = 0x54 # float + m_flStretchExtensionScale = 0x58 # float + +class FootPinningPoseOpFixedData_t: + m_footInfo = 0x0 # CUtlVector + m_flBlendTime = 0x18 # float + m_flLockBreakDistance = 0x1C # float + m_flMaxLegTwist = 0x20 # float + m_nHipBoneIndex = 0x24 # int32_t + m_bApplyLegTwistLimits = 0x28 # bool + m_bApplyFootRotationLimits = 0x29 # bool + +class FootStepTrigger: + m_tags = 0x0 # CUtlVector + m_nFootIndex = 0x18 # int32_t + m_triggerPhase = 0x1C # StepPhase + +class HSequence: + m_Value = 0x0 # int32_t + +class HitReactFixedSettings_t: + m_nWeightListIndex = 0x0 # int32_t + m_nEffectedBoneCount = 0x4 # int32_t + m_flMaxImpactForce = 0x8 # float + m_flMinImpactForce = 0xC # float + m_flWhipImpactScale = 0x10 # float + m_flCounterRotationScale = 0x14 # float + m_flDistanceFadeScale = 0x18 # float + m_flPropagationScale = 0x1C # float + m_flWhipDelay = 0x20 # float + m_flSpringStrength = 0x24 # float + m_flWhipSpringStrength = 0x28 # float + m_flMaxAngleRadians = 0x2C # float + m_nHipBoneIndex = 0x30 # int32_t + m_flHipBoneTranslationScale = 0x34 # float + m_flHipDipSpringStrength = 0x38 # float + m_flHipDipImpactScale = 0x3C # float + m_flHipDipDelay = 0x40 # float + +class IKBoneNameAndIndex_t: + m_Name = 0x0 # CUtlString + +class IKDemoCaptureSettings_t: + m_parentBoneName = 0x0 # CUtlString + m_eMode = 0x8 # IKChannelMode + m_ikChainName = 0x10 # CUtlString + m_oneBoneStart = 0x18 # CUtlString + m_oneBoneEnd = 0x20 # CUtlString + +class IKSolverSettings_t: + m_SolverType = 0x0 # IKSolverType + m_nNumIterations = 0x4 # int32_t + +class IKTargetSettings_t: + m_TargetSource = 0x0 # IKTargetSource + m_Bone = 0x8 # IKBoneNameAndIndex_t + m_AnimgraphParameterNamePosition = 0x18 # AnimParamID + m_AnimgraphParameterNameOrientation = 0x1C # AnimParamID + m_TargetCoordSystem = 0x20 # IKTargetCoordinateSystem + +class JiggleBoneSettingsList_t: + m_boneSettings = 0x0 # CUtlVector + +class JiggleBoneSettings_t: + m_nBoneIndex = 0x0 # int32_t + m_flSpringStrength = 0x4 # float + m_flMaxTimeStep = 0x8 # float + m_flDamping = 0xC # float + m_vBoundsMaxLS = 0x10 # Vector + m_vBoundsMinLS = 0x1C # Vector + m_eSimSpace = 0x28 # JiggleBoneSimSpace + +class LookAtBone_t: + m_index = 0x0 # int32_t + m_weight = 0x4 # float + +class LookAtOpFixedSettings_t: + m_attachment = 0x0 # CAnimAttachment + m_damping = 0x80 # CAnimInputDamping + m_bones = 0x90 # CUtlVector + m_flYawLimit = 0xA8 # float + m_flPitchLimit = 0xAC # float + m_flHysteresisInnerAngle = 0xB0 # float + m_flHysteresisOuterAngle = 0xB4 # float + m_bRotateYawForward = 0xB8 # bool + m_bMaintainUpDirection = 0xB9 # bool + m_bTargetIsPosition = 0xBA # bool + m_bUseHysteresis = 0xBB # bool + +class MaterialGroup_t: + m_name = 0x0 # CUtlString + m_materials = 0x8 # CUtlVector> + +class ModelBoneFlexDriverControl_t: + m_nBoneComponent = 0x0 # ModelBoneFlexComponent_t + m_flexController = 0x8 # CUtlString + m_flexControllerToken = 0x10 # uint32_t + m_flMin = 0x14 # float + m_flMax = 0x18 # float + +class ModelBoneFlexDriver_t: + m_boneName = 0x0 # CUtlString + m_boneNameToken = 0x8 # uint32_t + m_controls = 0x10 # CUtlVector + +class ModelSkeletonData_t: + m_boneName = 0x0 # CUtlVector + m_nParent = 0x18 # CUtlVector + m_boneSphere = 0x30 # CUtlVector + m_nFlag = 0x48 # CUtlVector + m_bonePosParent = 0x60 # CUtlVector + m_boneRotParent = 0x78 # CUtlVector + m_boneScaleParent = 0x90 # CUtlVector + +class MoodAnimationLayer_t: + m_sName = 0x0 # CUtlString + m_bActiveListening = 0x8 # bool + m_bActiveTalking = 0x9 # bool + m_layerAnimations = 0x10 # CUtlVector + m_flIntensity = 0x28 # CRangeFloat + m_flDurationScale = 0x30 # CRangeFloat + m_bScaleWithInts = 0x38 # bool + m_flNextStart = 0x3C # CRangeFloat + m_flStartOffset = 0x44 # CRangeFloat + m_flEndOffset = 0x4C # CRangeFloat + m_flFadeIn = 0x54 # float + m_flFadeOut = 0x58 # float + +class MoodAnimation_t: + m_sName = 0x0 # CUtlString + m_flWeight = 0x8 # float + +class MotionBlendItem: + m_pChild = 0x0 # CSmartPtr + m_flKeyValue = 0x8 # float + +class MotionDBIndex: + m_nIndex = 0x0 # uint32_t + +class MotionIndex: + m_nGroup = 0x0 # uint16_t + m_nMotion = 0x2 # uint16_t + +class ParamSpanSample_t: + m_value = 0x0 # CAnimVariant + m_flCycle = 0x14 # float + +class ParamSpan_t: + m_samples = 0x0 # CUtlVector + m_hParam = 0x18 # CAnimParamHandle + m_eParamType = 0x1A # AnimParamType_t + m_flStartCycle = 0x1C # float + m_flEndCycle = 0x20 # float + +class PermModelDataAnimatedMaterialAttribute_t: + m_AttributeName = 0x0 # CUtlString + m_nNumChannels = 0x8 # int32_t + +class PermModelData_t: + m_name = 0x0 # CUtlString + m_modelInfo = 0x8 # PermModelInfo_t + m_ExtParts = 0x60 # CUtlVector + m_refMeshes = 0x78 # CUtlVector> + m_refMeshGroupMasks = 0x90 # CUtlVector + m_refPhysGroupMasks = 0xA8 # CUtlVector + m_refLODGroupMasks = 0xC0 # CUtlVector + m_lodGroupSwitchDistances = 0xD8 # CUtlVector + m_refPhysicsData = 0xF0 # CUtlVector> + m_refPhysicsHitboxData = 0x108 # CUtlVector> + m_refAnimGroups = 0x120 # CUtlVector> + m_refSequenceGroups = 0x138 # CUtlVector> + m_meshGroups = 0x150 # CUtlVector + m_materialGroups = 0x168 # CUtlVector + m_nDefaultMeshGroupMask = 0x180 # uint64_t + m_modelSkeleton = 0x188 # ModelSkeletonData_t + m_remappingTable = 0x230 # CUtlVector + m_remappingTableStarts = 0x248 # CUtlVector + m_boneFlexDrivers = 0x260 # CUtlVector + m_pModelConfigList = 0x278 # CModelConfigList* + m_BodyGroupsHiddenInTools = 0x280 # CUtlVector + m_refAnimIncludeModels = 0x298 # CUtlVector> + m_AnimatedMaterialAttributes = 0x2B0 # CUtlVector + +class PermModelExtPart_t: + m_Transform = 0x0 # CTransform + m_Name = 0x20 # CUtlString + m_nParent = 0x28 # int32_t + m_refModel = 0x30 # CStrongHandle + +class PermModelInfo_t: + m_nFlags = 0x0 # uint32_t + m_vHullMin = 0x4 # Vector + m_vHullMax = 0x10 # Vector + m_vViewMin = 0x1C # Vector + m_vViewMax = 0x28 # Vector + m_flMass = 0x34 # float + m_vEyePosition = 0x38 # Vector + m_flMaxEyeDeflection = 0x44 # float + m_sSurfaceProperty = 0x48 # CUtlString + m_keyValueText = 0x50 # CUtlString + +class PhysSoftbodyDesc_t: + m_ParticleBoneHash = 0x0 # CUtlVector + m_Particles = 0x18 # CUtlVector + m_Springs = 0x30 # CUtlVector + m_Capsules = 0x48 # CUtlVector + m_InitPose = 0x60 # CUtlVector + m_ParticleBoneName = 0x78 # CUtlVector + +class RenderSkeletonBone_t: + m_boneName = 0x0 # CUtlString + m_parentName = 0x8 # CUtlString + m_invBindPose = 0x10 # matrix3x4_t + m_bbox = 0x40 # SkeletonBoneBounds_t + m_flSphereRadius = 0x58 # float + +class SampleCode: + m_subCode = 0x0 # uint8_t[8] + +class ScriptInfo_t: + m_code = 0x0 # CUtlString + m_paramsModified = 0x8 # CUtlVector + m_proxyReadParams = 0x20 # CUtlVector + m_proxyWriteParams = 0x38 # CUtlVector + m_eScriptType = 0x50 # AnimScriptType + +class SkeletalInputOpFixedSettings_t: + m_wristBones = 0x0 # CUtlVector + m_fingers = 0x18 # CUtlVector + m_outerKnuckle1 = 0x30 # int32_t + m_outerKnuckle2 = 0x34 # int32_t + m_eHand = 0x38 # AnimVRHand_t + m_eMotionRange = 0x3C # AnimVRHandMotionRange_t + m_eTransformSource = 0x40 # AnimVrBoneTransformSource_t + m_bEnableIK = 0x44 # bool + m_bEnableCollision = 0x45 # bool + +class SkeletonBoneBounds_t: + m_vecCenter = 0x0 # Vector + m_vecSize = 0xC # Vector + +class SolveIKChainPoseOpFixedSettings_t: + m_ChainsToSolveData = 0x0 # CUtlVector + m_bMatchTargetOrientation = 0x18 # bool + +class StanceInfo_t: + m_vPosition = 0x0 # Vector + m_flDirection = 0xC # float + +class TagSpan_t: + m_tagIndex = 0x0 # int32_t + m_startCycle = 0x4 # float + m_endCycle = 0x8 # float + +class TraceSettings_t: + m_flTraceHeight = 0x0 # float + m_flTraceRadius = 0x4 # float + +class TwoBoneIKSettings_t: + m_endEffectorType = 0x0 # IkEndEffectorType + m_endEffectorAttachment = 0x10 # CAnimAttachment + m_targetType = 0x90 # IkTargetType + m_targetAttachment = 0xA0 # CAnimAttachment + m_targetBoneIndex = 0x120 # int32_t + m_hPositionParam = 0x124 # CAnimParamHandle + m_hRotationParam = 0x126 # CAnimParamHandle + m_bAlwaysUseFallbackHinge = 0x128 # bool + m_vLsFallbackHingeAxis = 0x130 # VectorAligned + m_nFixedBoneIndex = 0x140 # int32_t + m_nMiddleBoneIndex = 0x144 # int32_t + m_nEndBoneIndex = 0x148 # int32_t + m_bMatchTargetOrientation = 0x14C # bool + m_bConstrainTwist = 0x14D # bool + m_flMaxTwist = 0x150 # float + +class VPhysXAggregateData_t: + m_nFlags = 0x0 # uint16_t + m_nRefCounter = 0x2 # uint16_t + m_bonesHash = 0x8 # CUtlVector + m_boneNames = 0x20 # CUtlVector + m_indexNames = 0x38 # CUtlVector + m_indexHash = 0x50 # CUtlVector + m_bindPose = 0x68 # CUtlVector + m_parts = 0x80 # CUtlVector + m_constraints2 = 0x98 # CUtlVector + m_joints = 0xB0 # CUtlVector + m_pFeModel = 0xC8 # PhysFeModelDesc_t* + m_boneParents = 0xD0 # CUtlVector + m_surfacePropertyHashes = 0xE8 # CUtlVector + m_collisionAttributes = 0x100 # CUtlVector + m_debugPartNames = 0x118 # CUtlVector + m_embeddedKeyvalues = 0x130 # CUtlString + +class VPhysXBodyPart_t: + m_nFlags = 0x0 # uint32_t + m_flMass = 0x4 # float + m_rnShape = 0x8 # VPhysics2ShapeDef_t + m_nCollisionAttributeIndex = 0x80 # uint16_t + m_nReserved = 0x82 # uint16_t + m_flInertiaScale = 0x84 # float + m_flLinearDamping = 0x88 # float + m_flAngularDamping = 0x8C # float + m_bOverrideMassCenter = 0x90 # bool + m_vMassCenterOverride = 0x94 # Vector + +class VPhysXCollisionAttributes_t: + m_CollisionGroup = 0x0 # uint32_t + m_InteractAs = 0x8 # CUtlVector + m_InteractWith = 0x20 # CUtlVector + m_InteractExclude = 0x38 # CUtlVector + m_CollisionGroupString = 0x50 # CUtlString + m_InteractAsStrings = 0x58 # CUtlVector + m_InteractWithStrings = 0x70 # CUtlVector + m_InteractExcludeStrings = 0x88 # CUtlVector + +class VPhysXConstraint2_t: + m_nFlags = 0x0 # uint32_t + m_nParent = 0x4 # uint16_t + m_nChild = 0x6 # uint16_t + m_params = 0x8 # VPhysXConstraintParams_t + +class VPhysXConstraintParams_t: + m_nType = 0x0 # int8_t + m_nTranslateMotion = 0x1 # int8_t + m_nRotateMotion = 0x2 # int8_t + m_nFlags = 0x3 # int8_t + m_anchor = 0x4 # Vector[2] + m_axes = 0x1C # QuaternionStorage[2] + m_maxForce = 0x3C # float + m_maxTorque = 0x40 # float + m_linearLimitValue = 0x44 # float + m_linearLimitRestitution = 0x48 # float + m_linearLimitSpring = 0x4C # float + m_linearLimitDamping = 0x50 # float + m_twistLowLimitValue = 0x54 # float + m_twistLowLimitRestitution = 0x58 # float + m_twistLowLimitSpring = 0x5C # float + m_twistLowLimitDamping = 0x60 # float + m_twistHighLimitValue = 0x64 # float + m_twistHighLimitRestitution = 0x68 # float + m_twistHighLimitSpring = 0x6C # float + m_twistHighLimitDamping = 0x70 # float + m_swing1LimitValue = 0x74 # float + m_swing1LimitRestitution = 0x78 # float + m_swing1LimitSpring = 0x7C # float + m_swing1LimitDamping = 0x80 # float + m_swing2LimitValue = 0x84 # float + m_swing2LimitRestitution = 0x88 # float + m_swing2LimitSpring = 0x8C # float + m_swing2LimitDamping = 0x90 # float + m_goalPosition = 0x94 # Vector + m_goalOrientation = 0xA0 # QuaternionStorage + m_goalAngularVelocity = 0xB0 # Vector + m_driveSpringX = 0xBC # float + m_driveSpringY = 0xC0 # float + m_driveSpringZ = 0xC4 # float + m_driveDampingX = 0xC8 # float + m_driveDampingY = 0xCC # float + m_driveDampingZ = 0xD0 # float + m_driveSpringTwist = 0xD4 # float + m_driveSpringSwing = 0xD8 # float + m_driveSpringSlerp = 0xDC # float + m_driveDampingTwist = 0xE0 # float + m_driveDampingSwing = 0xE4 # float + m_driveDampingSlerp = 0xE8 # float + m_solverIterationCount = 0xEC # int32_t + m_projectionLinearTolerance = 0xF0 # float + m_projectionAngularTolerance = 0xF4 # float + +class VPhysXJoint_t: + m_nType = 0x0 # uint16_t + m_nBody1 = 0x2 # uint16_t + m_nBody2 = 0x4 # uint16_t + m_nFlags = 0x6 # uint16_t + m_Frame1 = 0x10 # CTransform + m_Frame2 = 0x30 # CTransform + m_bEnableCollision = 0x50 # bool + m_bEnableLinearLimit = 0x51 # bool + m_LinearLimit = 0x54 # VPhysXRange_t + m_bEnableLinearMotor = 0x5C # bool + m_vLinearTargetVelocity = 0x60 # Vector + m_flMaxForce = 0x6C # float + m_bEnableSwingLimit = 0x70 # bool + m_SwingLimit = 0x74 # VPhysXRange_t + m_bEnableTwistLimit = 0x7C # bool + m_TwistLimit = 0x80 # VPhysXRange_t + m_bEnableAngularMotor = 0x88 # bool + m_vAngularTargetVelocity = 0x8C # Vector + m_flMaxTorque = 0x98 # float + m_flLinearFrequency = 0x9C # float + m_flLinearDampingRatio = 0xA0 # float + m_flAngularFrequency = 0xA4 # float + m_flAngularDampingRatio = 0xA8 # float + m_flFriction = 0xAC # float + +class VPhysXRange_t: + m_flMin = 0x0 # float + m_flMax = 0x4 # float + +class VPhysics2ShapeDef_t: + m_spheres = 0x0 # CUtlVector + m_capsules = 0x18 # CUtlVector + m_hulls = 0x30 # CUtlVector + m_meshes = 0x48 # CUtlVector + m_CollisionAttributeIndices = 0x60 # CUtlVector + +class WeightList: + m_name = 0x0 # CUtlString + m_weights = 0x8 # CUtlVector + +class WristBone_t: + m_xOffsetTransformMS = 0x0 # CTransform + m_boneIndex = 0x20 # int32_t diff --git a/generated/animationsystem.dll.rs b/generated/animationsystem.dll.rs index 7367c64..cbafb5c 100644 --- a/generated/animationsystem.dll.rs +++ b/generated/animationsystem.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.563817600 UTC + * 2023-10-17 02:04:49.915588500 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod AimMatrixOpFixedSettings_t { pub const m_attachment: usize = 0x0; // CAnimAttachment pub const m_damping: usize = 0x80; // CAnimInputDamping diff --git a/generated/client.dll.cs b/generated/client.dll.cs index 69a02e8..4f32cbf 100644 --- a/generated/client.dll.cs +++ b/generated/client.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:32.884630900 UTC + * 2023-10-17 02:04:51.383225900 UTC */ public static class ActiveModelConfig_t { diff --git a/generated/client.dll.hpp b/generated/client.dll.hpp index b988d9f..bd89875 100644 --- a/generated/client.dll.hpp +++ b/generated/client.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:51.341476500 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:32.843400800 UTC - */ - namespace ActiveModelConfig_t { constexpr std::ptrdiff_t m_Handle = 0x28; // ModelConfigHandle_t constexpr std::ptrdiff_t m_Name = 0x30; // CUtlSymbolLarge diff --git a/generated/client.dll.py b/generated/client.dll.py new file mode 100644 index 0000000..a10d671 --- /dev/null +++ b/generated/client.dll.py @@ -0,0 +1,3439 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:51.425967900 UTC +''' + +class ActiveModelConfig_t: + m_Handle = 0x28 # ModelConfigHandle_t + m_Name = 0x30 # CUtlSymbolLarge + m_AssociatedEntities = 0x38 # C_NetworkUtlVectorBase> + m_AssociatedEntityNames = 0x50 # C_NetworkUtlVectorBase + +class CAnimGraphNetworkedVariables: + m_PredNetBoolVariables = 0x8 # C_NetworkUtlVectorBase + m_PredNetByteVariables = 0x20 # C_NetworkUtlVectorBase + m_PredNetUInt16Variables = 0x38 # C_NetworkUtlVectorBase + m_PredNetIntVariables = 0x50 # C_NetworkUtlVectorBase + m_PredNetUInt32Variables = 0x68 # C_NetworkUtlVectorBase + m_PredNetUInt64Variables = 0x80 # C_NetworkUtlVectorBase + m_PredNetFloatVariables = 0x98 # C_NetworkUtlVectorBase + m_PredNetVectorVariables = 0xB0 # C_NetworkUtlVectorBase + m_PredNetQuaternionVariables = 0xC8 # C_NetworkUtlVectorBase + m_OwnerOnlyPredNetBoolVariables = 0xE0 # C_NetworkUtlVectorBase + m_OwnerOnlyPredNetByteVariables = 0xF8 # C_NetworkUtlVectorBase + m_OwnerOnlyPredNetUInt16Variables = 0x110 # C_NetworkUtlVectorBase + m_OwnerOnlyPredNetIntVariables = 0x128 # C_NetworkUtlVectorBase + m_OwnerOnlyPredNetUInt32Variables = 0x140 # C_NetworkUtlVectorBase + m_OwnerOnlyPredNetUInt64Variables = 0x158 # C_NetworkUtlVectorBase + m_OwnerOnlyPredNetFloatVariables = 0x170 # C_NetworkUtlVectorBase + m_OwnerOnlyPredNetVectorVariables = 0x188 # C_NetworkUtlVectorBase + m_OwnerOnlyPredNetQuaternionVariables = 0x1A0 # C_NetworkUtlVectorBase + m_nBoolVariablesCount = 0x1B8 # int32_t + m_nOwnerOnlyBoolVariablesCount = 0x1BC # int32_t + m_nRandomSeedOffset = 0x1C0 # int32_t + m_flLastTeleportTime = 0x1C4 # float + +class CAttributeList: + m_Attributes = 0x8 # C_UtlVectorEmbeddedNetworkVar + m_pManager = 0x58 # CAttributeManager* + +class CAttributeManager: + m_Providers = 0x8 # CUtlVector> + m_iReapplyProvisionParity = 0x20 # int32_t + m_hOuter = 0x24 # CHandle + m_bPreventLoopback = 0x28 # bool + m_ProviderType = 0x2C # attributeprovidertypes_t + m_CachedResults = 0x30 # CUtlVector + +class CAttributeManager_cached_attribute_float_t: + flIn = 0x0 # float + iAttribHook = 0x8 # CUtlSymbolLarge + flOut = 0x10 # float + +class CBaseAnimGraph: + m_bInitiallyPopulateInterpHistory = 0xCC0 # bool + m_bShouldAnimateDuringGameplayPause = 0xCC1 # bool + m_bSuppressAnimEventSounds = 0xCC3 # bool + m_bAnimGraphUpdateEnabled = 0xCD0 # bool + m_flMaxSlopeDistance = 0xCD4 # float + m_vLastSlopeCheckPos = 0xCD8 # Vector + m_vecForce = 0xCE8 # Vector + m_nForceBone = 0xCF4 # int32_t + m_pClientsideRagdoll = 0xCF8 # CBaseAnimGraph* + m_bBuiltRagdoll = 0xD00 # bool + m_pRagdollPose = 0xD18 # PhysicsRagdollPose_t* + m_bClientRagdoll = 0xD20 # bool + m_bHasAnimatedMaterialAttributes = 0xD30 # bool + +class CBaseAnimGraphController: + m_baseLayer = 0x18 # CNetworkedSequenceOperation + m_animGraphNetworkedVars = 0x40 # CAnimGraphNetworkedVariables + m_bSequenceFinished = 0x1320 # bool + m_flLastEventCycle = 0x1324 # float + m_flLastEventAnimTime = 0x1328 # float + m_flPlaybackRate = 0x132C # CNetworkedQuantizedFloat + m_flPrevAnimTime = 0x1334 # float + m_bClientSideAnimation = 0x1338 # bool + m_bNetworkedAnimationInputsChanged = 0x1339 # bool + m_nPrevNewSequenceParity = 0x133A # uint8_t + m_nPrevResetEventsParity = 0x133B # uint8_t + m_nNewSequenceParity = 0x133C # int32_t + m_nResetEventsParity = 0x1340 # int32_t + m_nAnimLoopMode = 0x1344 # AnimLoopMode_t + m_hAnimationUpdate = 0x13E4 # AnimationUpdateListHandle_t + m_hLastAnimEventSequence = 0x13E8 # HSequence + +class CBasePlayerController: + m_nFinalPredictedTick = 0x548 # int32_t + m_CommandContext = 0x550 # C_CommandContext + m_nInButtonsWhichAreToggles = 0x5D0 # uint64_t + m_nTickBase = 0x5D8 # uint32_t + m_hPawn = 0x5DC # CHandle + m_hPredictedPawn = 0x5E0 # CHandle + m_nSplitScreenSlot = 0x5E4 # CSplitScreenSlot + m_hSplitOwner = 0x5E8 # CHandle + m_hSplitScreenPlayers = 0x5F0 # CUtlVector> + m_bIsHLTV = 0x608 # bool + m_iConnected = 0x60C # PlayerConnectedState + m_iszPlayerName = 0x610 # char[128] + m_steamID = 0x698 # uint64_t + m_bIsLocalPlayerController = 0x6A0 # bool + m_iDesiredFOV = 0x6A4 # uint32_t + +class CBasePlayerVData: + m_sModelName = 0x28 # CResourceNameTyped> + m_flHeadDamageMultiplier = 0x108 # CSkillFloat + m_flChestDamageMultiplier = 0x118 # CSkillFloat + m_flStomachDamageMultiplier = 0x128 # CSkillFloat + m_flArmDamageMultiplier = 0x138 # CSkillFloat + m_flLegDamageMultiplier = 0x148 # CSkillFloat + m_flHoldBreathTime = 0x158 # float + m_flDrowningDamageInterval = 0x15C # float + m_nDrowningDamageInitial = 0x160 # int32_t + m_nDrowningDamageMax = 0x164 # int32_t + m_nWaterSpeed = 0x168 # int32_t + m_flUseRange = 0x16C # float + m_flUseAngleTolerance = 0x170 # float + m_flCrouchTime = 0x174 # float + +class CBasePlayerWeaponVData: + m_szWorldModel = 0x28 # CResourceNameTyped> + m_bBuiltRightHanded = 0x108 # bool + m_bAllowFlipping = 0x109 # bool + m_bIsFullAuto = 0x10A # bool + m_nNumBullets = 0x10C # int32_t + m_sMuzzleAttachment = 0x110 # CUtlString + m_szMuzzleFlashParticle = 0x118 # CResourceNameTyped> + m_iFlags = 0x1F8 # ItemFlagTypes_t + m_nPrimaryAmmoType = 0x1F9 # AmmoIndex_t + m_nSecondaryAmmoType = 0x1FA # AmmoIndex_t + m_iMaxClip1 = 0x1FC # int32_t + m_iMaxClip2 = 0x200 # int32_t + m_iDefaultClip1 = 0x204 # int32_t + m_iDefaultClip2 = 0x208 # int32_t + m_iWeight = 0x20C # int32_t + m_bAutoSwitchTo = 0x210 # bool + m_bAutoSwitchFrom = 0x211 # bool + m_iRumbleEffect = 0x214 # RumbleEffect_t + m_aShootSounds = 0x218 # CUtlMap + m_iSlot = 0x238 # int32_t + m_iPosition = 0x23C # int32_t + +class CBaseProp: + m_bModelOverrodeBlockLOS = 0xE80 # bool + m_iShapeType = 0xE84 # int32_t + m_bConformToCollisionBounds = 0xE88 # bool + m_mPreferredCatchTransform = 0xE8C # matrix3x4_t + +class CBodyComponent: + m_pSceneNode = 0x8 # CGameSceneNode* + __m_pChainEntity = 0x20 # CNetworkVarChainer + +class CBodyComponentBaseAnimGraph: + m_animationController = 0x470 # CBaseAnimGraphController + __m_pChainEntity = 0x18B0 # CNetworkVarChainer + +class CBodyComponentBaseModelEntity: + __m_pChainEntity = 0x470 # CNetworkVarChainer + +class CBodyComponentPoint: + m_sceneNode = 0x50 # CGameSceneNode + __m_pChainEntity = 0x1A0 # CNetworkVarChainer + +class CBodyComponentSkeletonInstance: + m_skeletonInstance = 0x50 # CSkeletonInstance + __m_pChainEntity = 0x440 # CNetworkVarChainer + +class CBombTarget: + m_bBombPlantedHere = 0xCC8 # bool + +class CBuoyancyHelper: + m_flFluidDensity = 0x18 # float + +class CCSGameModeRules: + __m_pChainEntity = 0x8 # CNetworkVarChainer + +class CCSGameModeRules_Deathmatch: + m_bFirstThink = 0x30 # bool + m_bFirstThinkAfterConnected = 0x31 # bool + m_flDMBonusStartTime = 0x34 # GameTime_t + m_flDMBonusTimeLength = 0x38 # float + m_nDMBonusWeaponLoadoutSlot = 0x3C # int16_t + +class CCSObserver_ObserverServices: + m_hLastObserverTarget = 0x58 # CEntityHandle + m_vecObserverInterpolateOffset = 0x5C # Vector + m_vecObserverInterpStartPos = 0x68 # Vector + m_flObsInterp_PathLength = 0x74 # float + m_qObsInterp_OrientationStart = 0x80 # Quaternion + m_qObsInterp_OrientationTravelDir = 0x90 # Quaternion + m_obsInterpState = 0xA0 # ObserverInterpState_t + m_bObserverInterpolationNeedsDeferredSetup = 0xA4 # bool + +class CCSPlayerBase_CameraServices: + m_iFOV = 0x210 # uint32_t + m_iFOVStart = 0x214 # uint32_t + m_flFOVTime = 0x218 # GameTime_t + m_flFOVRate = 0x21C # float + m_hZoomOwner = 0x220 # CHandle + m_flLastShotFOV = 0x224 # float + +class CCSPlayerController: + m_pInGameMoneyServices = 0x6D0 # CCSPlayerController_InGameMoneyServices* + m_pInventoryServices = 0x6D8 # CCSPlayerController_InventoryServices* + m_pActionTrackingServices = 0x6E0 # CCSPlayerController_ActionTrackingServices* + m_pDamageServices = 0x6E8 # CCSPlayerController_DamageServices* + m_iPing = 0x6F0 # uint32_t + m_bHasCommunicationAbuseMute = 0x6F4 # bool + m_szCrosshairCodes = 0x6F8 # CUtlSymbolLarge + m_iPendingTeamNum = 0x700 # uint8_t + m_flForceTeamTime = 0x704 # GameTime_t + m_iCompTeammateColor = 0x708 # int32_t + m_bEverPlayedOnTeam = 0x70C # bool + m_flPreviousForceJoinTeamTime = 0x710 # GameTime_t + m_szClan = 0x718 # CUtlSymbolLarge + m_sSanitizedPlayerName = 0x720 # CUtlString + m_iCoachingTeam = 0x728 # int32_t + m_nPlayerDominated = 0x730 # uint64_t + m_nPlayerDominatingMe = 0x738 # uint64_t + m_iCompetitiveRanking = 0x740 # int32_t + m_iCompetitiveWins = 0x744 # int32_t + m_iCompetitiveRankType = 0x748 # int8_t + m_iCompetitiveRankingPredicted_Win = 0x74C # int32_t + m_iCompetitiveRankingPredicted_Loss = 0x750 # int32_t + m_iCompetitiveRankingPredicted_Tie = 0x754 # int32_t + m_nEndMatchNextMapVote = 0x758 # int32_t + m_unActiveQuestId = 0x75C # uint16_t + m_nQuestProgressReason = 0x760 # QuestProgress::Reason + m_unPlayerTvControlFlags = 0x764 # uint32_t + m_iDraftIndex = 0x790 # int32_t + m_msQueuedModeDisconnectionTimestamp = 0x794 # uint32_t + m_uiAbandonRecordedReason = 0x798 # uint32_t + m_bEverFullyConnected = 0x79C # bool + m_bAbandonAllowsSurrender = 0x79D # bool + m_bAbandonOffersInstantSurrender = 0x79E # bool + m_bDisconnection1MinWarningPrinted = 0x79F # bool + m_bScoreReported = 0x7A0 # bool + m_nDisconnectionTick = 0x7A4 # int32_t + m_bControllingBot = 0x7B0 # bool + m_bHasControlledBotThisRound = 0x7B1 # bool + m_bHasBeenControlledByPlayerThisRound = 0x7B2 # bool + m_nBotsControlledThisRound = 0x7B4 # int32_t + m_bCanControlObservedBot = 0x7B8 # bool + m_hPlayerPawn = 0x7BC # CHandle + m_hObserverPawn = 0x7C0 # CHandle + m_bPawnIsAlive = 0x7C4 # bool + m_iPawnHealth = 0x7C8 # uint32_t + m_iPawnArmor = 0x7CC # int32_t + m_bPawnHasDefuser = 0x7D0 # bool + m_bPawnHasHelmet = 0x7D1 # bool + m_nPawnCharacterDefIndex = 0x7D2 # uint16_t + m_iPawnLifetimeStart = 0x7D4 # int32_t + m_iPawnLifetimeEnd = 0x7D8 # int32_t + m_iPawnBotDifficulty = 0x7DC # int32_t + m_hOriginalControllerOfCurrentPawn = 0x7E0 # CHandle + m_iScore = 0x7E4 # int32_t + m_vecKills = 0x7E8 # C_NetworkUtlVectorBase + m_iMVPs = 0x800 # int32_t + m_bIsPlayerNameDirty = 0x804 # bool + +class CCSPlayerController_ActionTrackingServices: + m_perRoundStats = 0x40 # C_UtlVectorEmbeddedNetworkVar + m_matchStats = 0x90 # CSMatchStats_t + m_iNumRoundKills = 0x108 # int32_t + m_iNumRoundKillsHeadshots = 0x10C # int32_t + +class CCSPlayerController_DamageServices: + m_nSendUpdate = 0x40 # int32_t + m_DamageList = 0x48 # C_UtlVectorEmbeddedNetworkVar + +class CCSPlayerController_InGameMoneyServices: + m_iAccount = 0x40 # int32_t + m_iStartAccount = 0x44 # int32_t + m_iTotalCashSpent = 0x48 # int32_t + m_iCashSpentThisRound = 0x4C # int32_t + m_nPreviousAccount = 0x50 # int32_t + +class CCSPlayerController_InventoryServices: + m_unMusicID = 0x40 # uint16_t + m_rank = 0x44 # MedalRank_t[6] + m_nPersonaDataPublicLevel = 0x5C # int32_t + m_nPersonaDataPublicCommendsLeader = 0x60 # int32_t + m_nPersonaDataPublicCommendsTeacher = 0x64 # int32_t + m_nPersonaDataPublicCommendsFriendly = 0x68 # int32_t + m_vecServerAuthoritativeWeaponSlots = 0x70 # C_UtlVectorEmbeddedNetworkVar + +class CCSPlayer_ActionTrackingServices: + m_hLastWeaponBeforeC4AutoSwitch = 0x40 # CHandle + m_bIsRescuing = 0x44 # bool + m_weaponPurchasesThisMatch = 0x48 # WeaponPurchaseTracker_t + m_weaponPurchasesThisRound = 0xA0 # WeaponPurchaseTracker_t + +class CCSPlayer_BulletServices: + m_totalHitsOnServer = 0x40 # int32_t + +class CCSPlayer_BuyServices: + m_vecSellbackPurchaseEntries = 0x40 # C_UtlVectorEmbeddedNetworkVar + +class CCSPlayer_CameraServices: + m_flDeathCamTilt = 0x228 # float + +class CCSPlayer_HostageServices: + m_hCarriedHostage = 0x40 # CHandle + m_hCarriedHostageProp = 0x44 # CHandle + +class CCSPlayer_ItemServices: + m_bHasDefuser = 0x40 # bool + m_bHasHelmet = 0x41 # bool + m_bHasHeavyArmor = 0x42 # bool + +class CCSPlayer_MovementServices: + m_flMaxFallVelocity = 0x210 # float + m_vecLadderNormal = 0x214 # Vector + m_nLadderSurfacePropIndex = 0x220 # int32_t + m_flDuckAmount = 0x224 # float + m_flDuckSpeed = 0x228 # float + m_bDuckOverride = 0x22C # bool + m_bDesiresDuck = 0x22D # bool + m_flDuckOffset = 0x230 # float + m_nDuckTimeMsecs = 0x234 # uint32_t + m_nDuckJumpTimeMsecs = 0x238 # uint32_t + m_nJumpTimeMsecs = 0x23C # uint32_t + m_flLastDuckTime = 0x240 # float + m_vecLastPositionAtFullCrouchSpeed = 0x250 # Vector2D + m_duckUntilOnGround = 0x258 # bool + m_bHasWalkMovedSinceLastJump = 0x259 # bool + m_bInStuckTest = 0x25A # bool + m_flStuckCheckTime = 0x268 # float[64][2] + m_nTraceCount = 0x468 # int32_t + m_StuckLast = 0x46C # int32_t + m_bSpeedCropped = 0x470 # bool + m_nOldWaterLevel = 0x474 # int32_t + m_flWaterEntryTime = 0x478 # float + m_vecForward = 0x47C # Vector + m_vecLeft = 0x488 # Vector + m_vecUp = 0x494 # Vector + m_vecPreviouslyPredictedOrigin = 0x4A0 # Vector + m_bOldJumpPressed = 0x4AC # bool + m_flJumpPressedTime = 0x4B0 # float + m_flJumpUntil = 0x4B4 # float + m_flJumpVel = 0x4B8 # float + m_fStashGrenadeParameterWhen = 0x4BC # GameTime_t + m_nButtonDownMaskPrev = 0x4C0 # uint64_t + m_flOffsetTickCompleteTime = 0x4C8 # float + m_flOffsetTickStashedSpeed = 0x4CC # float + m_flStamina = 0x4D0 # float + m_bUpdatePredictedOriginAfterDataUpdate = 0x4D4 # bool + +class CCSPlayer_PingServices: + m_hPlayerPing = 0x40 # CHandle + +class CCSPlayer_ViewModelServices: + m_hViewModel = 0x40 # CHandle[3] + +class CCSPlayer_WaterServices: + m_flWaterJumpTime = 0x40 # float + m_vecWaterJumpVel = 0x44 # Vector + m_flSwimSoundTime = 0x50 # float + +class CCSPlayer_WeaponServices: + m_flNextAttack = 0xA8 # GameTime_t + m_bIsLookingAtWeapon = 0xAC # bool + m_bIsHoldingLookAtWeapon = 0xAD # bool + +class CCSWeaponBaseVData: + m_WeaponType = 0x240 # CSWeaponType + m_WeaponCategory = 0x244 # CSWeaponCategory + m_szViewModel = 0x248 # CResourceNameTyped> + m_szPlayerModel = 0x328 # CResourceNameTyped> + m_szWorldDroppedModel = 0x408 # CResourceNameTyped> + m_szAimsightLensMaskModel = 0x4E8 # CResourceNameTyped> + m_szMagazineModel = 0x5C8 # CResourceNameTyped> + m_szHeatEffect = 0x6A8 # CResourceNameTyped> + m_szEjectBrassEffect = 0x788 # CResourceNameTyped> + m_szMuzzleFlashParticleAlt = 0x868 # CResourceNameTyped> + m_szMuzzleFlashThirdPersonParticle = 0x948 # CResourceNameTyped> + m_szMuzzleFlashThirdPersonParticleAlt = 0xA28 # CResourceNameTyped> + m_szTracerParticle = 0xB08 # CResourceNameTyped> + m_GearSlot = 0xBE8 # gear_slot_t + m_GearSlotPosition = 0xBEC # int32_t + m_DefaultLoadoutSlot = 0xBF0 # loadout_slot_t + m_sWrongTeamMsg = 0xBF8 # CUtlString + m_nPrice = 0xC00 # int32_t + m_nKillAward = 0xC04 # int32_t + m_nPrimaryReserveAmmoMax = 0xC08 # int32_t + m_nSecondaryReserveAmmoMax = 0xC0C # int32_t + m_bMeleeWeapon = 0xC10 # bool + m_bHasBurstMode = 0xC11 # bool + m_bIsRevolver = 0xC12 # bool + m_bCannotShootUnderwater = 0xC13 # bool + m_szName = 0xC18 # CUtlString + m_szAnimExtension = 0xC20 # CUtlString + m_eSilencerType = 0xC28 # CSWeaponSilencerType + m_nCrosshairMinDistance = 0xC2C # int32_t + m_nCrosshairDeltaDistance = 0xC30 # int32_t + m_flCycleTime = 0xC34 # CFiringModeFloat + m_flMaxSpeed = 0xC3C # CFiringModeFloat + m_flSpread = 0xC44 # CFiringModeFloat + m_flInaccuracyCrouch = 0xC4C # CFiringModeFloat + m_flInaccuracyStand = 0xC54 # CFiringModeFloat + m_flInaccuracyJump = 0xC5C # CFiringModeFloat + m_flInaccuracyLand = 0xC64 # CFiringModeFloat + m_flInaccuracyLadder = 0xC6C # CFiringModeFloat + m_flInaccuracyFire = 0xC74 # CFiringModeFloat + m_flInaccuracyMove = 0xC7C # CFiringModeFloat + m_flRecoilAngle = 0xC84 # CFiringModeFloat + m_flRecoilAngleVariance = 0xC8C # CFiringModeFloat + m_flRecoilMagnitude = 0xC94 # CFiringModeFloat + m_flRecoilMagnitudeVariance = 0xC9C # CFiringModeFloat + m_nTracerFrequency = 0xCA4 # CFiringModeInt + m_flInaccuracyJumpInitial = 0xCAC # float + m_flInaccuracyJumpApex = 0xCB0 # float + m_flInaccuracyReload = 0xCB4 # float + m_nRecoilSeed = 0xCB8 # int32_t + m_nSpreadSeed = 0xCBC # int32_t + m_flTimeToIdleAfterFire = 0xCC0 # float + m_flIdleInterval = 0xCC4 # float + m_flAttackMovespeedFactor = 0xCC8 # float + m_flHeatPerShot = 0xCCC # float + m_flInaccuracyPitchShift = 0xCD0 # float + m_flInaccuracyAltSoundThreshold = 0xCD4 # float + m_flBotAudibleRange = 0xCD8 # float + m_szUseRadioSubtitle = 0xCE0 # CUtlString + m_bUnzoomsAfterShot = 0xCE8 # bool + m_bHideViewModelWhenZoomed = 0xCE9 # bool + m_nZoomLevels = 0xCEC # int32_t + m_nZoomFOV1 = 0xCF0 # int32_t + m_nZoomFOV2 = 0xCF4 # int32_t + m_flZoomTime0 = 0xCF8 # float + m_flZoomTime1 = 0xCFC # float + m_flZoomTime2 = 0xD00 # float + m_flIronSightPullUpSpeed = 0xD04 # float + m_flIronSightPutDownSpeed = 0xD08 # float + m_flIronSightFOV = 0xD0C # float + m_flIronSightPivotForward = 0xD10 # float + m_flIronSightLooseness = 0xD14 # float + m_angPivotAngle = 0xD18 # QAngle + m_vecIronSightEyePos = 0xD24 # Vector + m_nDamage = 0xD30 # int32_t + m_flHeadshotMultiplier = 0xD34 # float + m_flArmorRatio = 0xD38 # float + m_flPenetration = 0xD3C # float + m_flRange = 0xD40 # float + m_flRangeModifier = 0xD44 # float + m_flFlinchVelocityModifierLarge = 0xD48 # float + m_flFlinchVelocityModifierSmall = 0xD4C # float + m_flRecoveryTimeCrouch = 0xD50 # float + m_flRecoveryTimeStand = 0xD54 # float + m_flRecoveryTimeCrouchFinal = 0xD58 # float + m_flRecoveryTimeStandFinal = 0xD5C # float + m_nRecoveryTransitionStartBullet = 0xD60 # int32_t + m_nRecoveryTransitionEndBullet = 0xD64 # int32_t + m_flThrowVelocity = 0xD68 # float + m_vSmokeColor = 0xD6C # Vector + m_szAnimClass = 0xD78 # CUtlString + +class CClientAlphaProperty: + m_nRenderFX = 0x10 # uint8_t + m_nRenderMode = 0x11 # uint8_t + m_bAlphaOverride = 0x0 # bitfield:1 + m_bShadowAlphaOverride = 0x0 # bitfield:1 + m_nReserved = 0x0 # bitfield:6 + m_nAlpha = 0x13 # uint8_t + m_nDesyncOffset = 0x14 # uint16_t + m_nReserved2 = 0x16 # uint16_t + m_nDistFadeStart = 0x18 # uint16_t + m_nDistFadeEnd = 0x1A # uint16_t + m_flFadeScale = 0x1C # float + m_flRenderFxStartTime = 0x20 # GameTime_t + m_flRenderFxDuration = 0x24 # float + +class CCollisionProperty: + m_collisionAttribute = 0x10 # VPhysicsCollisionAttribute_t + m_vecMins = 0x40 # Vector + m_vecMaxs = 0x4C # Vector + m_usSolidFlags = 0x5A # uint8_t + m_nSolidType = 0x5B # SolidType_t + m_triggerBloat = 0x5C # uint8_t + m_nSurroundType = 0x5D # SurroundingBoundsType_t + m_CollisionGroup = 0x5E # uint8_t + m_nEnablePhysics = 0x5F # uint8_t + m_flBoundingRadius = 0x60 # float + m_vecSpecifiedSurroundingMins = 0x64 # Vector + m_vecSpecifiedSurroundingMaxs = 0x70 # Vector + m_vecSurroundingMaxs = 0x7C # Vector + m_vecSurroundingMins = 0x88 # Vector + m_vCapsuleCenter1 = 0x94 # Vector + m_vCapsuleCenter2 = 0xA0 # Vector + m_flCapsuleRadius = 0xAC # float + +class CComicBook: + m_CoverImage = 0x8 # CPanoramaImageName + m_XmlFile = 0x18 # CUtlString + +class CCompositeMaterialEditorDoc: + m_nVersion = 0x8 # int32_t + m_Points = 0x10 # CUtlVector + m_KVthumbnail = 0x28 # KeyValues3 + +class CDamageRecord: + m_PlayerDamager = 0x28 # CHandle + m_PlayerRecipient = 0x2C # CHandle + m_hPlayerControllerDamager = 0x30 # CHandle + m_hPlayerControllerRecipient = 0x34 # CHandle + m_szPlayerDamagerName = 0x38 # CUtlString + m_szPlayerRecipientName = 0x40 # CUtlString + m_DamagerXuid = 0x48 # uint64_t + m_RecipientXuid = 0x50 # uint64_t + m_iDamage = 0x58 # int32_t + m_iActualHealthRemoved = 0x5C # int32_t + m_iNumHits = 0x60 # int32_t + m_iLastBulletUpdate = 0x64 # int32_t + m_bIsOtherEnemy = 0x68 # bool + m_killType = 0x69 # EKillTypes_t + +class CDecalInfo: + m_flAnimationScale = 0x0 # float + m_flAnimationLifeSpan = 0x4 # float + m_flPlaceTime = 0x8 # float + m_flFadeStartTime = 0xC # float + m_flFadeDuration = 0x10 # float + m_nVBSlot = 0x14 # int32_t + m_nBoneIndex = 0x18 # int32_t + m_pNext = 0x28 # CDecalInfo* + m_pPrev = 0x30 # CDecalInfo* + m_nDecalMaterialIndex = 0x90 # int32_t + +class CEconItemAttribute: + m_iAttributeDefinitionIndex = 0x30 # uint16_t + m_flValue = 0x34 # float + m_flInitialValue = 0x38 # float + m_nRefundableCurrency = 0x3C # int32_t + m_bSetBonus = 0x40 # bool + +class CEffectData: + m_vOrigin = 0x8 # Vector + m_vStart = 0x14 # Vector + m_vNormal = 0x20 # Vector + m_vAngles = 0x2C # QAngle + m_hEntity = 0x38 # CEntityHandle + m_hOtherEntity = 0x3C # CEntityHandle + m_flScale = 0x40 # float + m_flMagnitude = 0x44 # float + m_flRadius = 0x48 # float + m_nSurfaceProp = 0x4C # CUtlStringToken + m_nEffectIndex = 0x50 # CWeakHandle + m_nDamageType = 0x58 # uint32_t + m_nPenetrate = 0x5C # uint8_t + m_nMaterial = 0x5E # uint16_t + m_nHitBox = 0x60 # uint16_t + m_nColor = 0x62 # uint8_t + m_fFlags = 0x63 # uint8_t + m_nAttachmentIndex = 0x64 # AttachmentHandle_t + m_nAttachmentName = 0x68 # CUtlStringToken + m_iEffectName = 0x6C # uint16_t + m_nExplosionType = 0x6E # uint8_t + +class CEntityIdentity: + m_nameStringableIndex = 0x14 # int32_t + m_name = 0x18 # CUtlSymbolLarge + m_designerName = 0x20 # CUtlSymbolLarge + m_flags = 0x30 # uint32_t + m_worldGroupId = 0x38 # WorldGroupId_t + m_fDataObjectTypes = 0x3C # uint32_t + m_PathIndex = 0x40 # ChangeAccessorFieldPathIndex_t + m_pPrev = 0x58 # CEntityIdentity* + m_pNext = 0x60 # CEntityIdentity* + m_pPrevByClass = 0x68 # CEntityIdentity* + m_pNextByClass = 0x70 # CEntityIdentity* + +class CEntityInstance: + m_iszPrivateVScripts = 0x8 # CUtlSymbolLarge + m_pEntity = 0x10 # CEntityIdentity* + m_CScriptComponent = 0x28 # CScriptComponent* + +class CFireOverlay: + m_pOwner = 0xD0 # C_FireSmoke* + m_vBaseColors = 0xD8 # Vector[4] + m_flScale = 0x108 # float + m_nGUID = 0x10C # int32_t + +class CFlashlightEffect: + m_bIsOn = 0x10 # bool + m_bMuzzleFlashEnabled = 0x20 # bool + m_flMuzzleFlashBrightness = 0x24 # float + m_quatMuzzleFlashOrientation = 0x30 # Quaternion + m_vecMuzzleFlashOrigin = 0x40 # Vector + m_flFov = 0x4C # float + m_flFarZ = 0x50 # float + m_flLinearAtten = 0x54 # float + m_bCastsShadows = 0x58 # bool + m_flCurrentPullBackDist = 0x5C # float + m_FlashlightTexture = 0x60 # CStrongHandle + m_MuzzleFlashTexture = 0x68 # CStrongHandle + m_textureName = 0x70 # char[64] + +class CFuncWater: + m_BuoyancyHelper = 0xCC0 # CBuoyancyHelper + +class CGameSceneNode: + m_nodeToWorld = 0x10 # CTransform + m_pOwner = 0x30 # CEntityInstance* + m_pParent = 0x38 # CGameSceneNode* + m_pChild = 0x40 # CGameSceneNode* + m_pNextSibling = 0x48 # CGameSceneNode* + m_hParent = 0x70 # CGameSceneNodeHandle + m_vecOrigin = 0x80 # CNetworkOriginCellCoordQuantizedVector + m_angRotation = 0xB8 # QAngle + m_flScale = 0xC4 # float + m_vecAbsOrigin = 0xC8 # Vector + m_angAbsRotation = 0xD4 # QAngle + m_flAbsScale = 0xE0 # float + m_nParentAttachmentOrBone = 0xE4 # int16_t + m_bDebugAbsOriginChanges = 0xE6 # bool + m_bDormant = 0xE7 # bool + m_bForceParentToBeNetworked = 0xE8 # bool + m_bDirtyHierarchy = 0x0 # bitfield:1 + m_bDirtyBoneMergeInfo = 0x0 # bitfield:1 + m_bNetworkedPositionChanged = 0x0 # bitfield:1 + m_bNetworkedAnglesChanged = 0x0 # bitfield:1 + m_bNetworkedScaleChanged = 0x0 # bitfield:1 + m_bWillBeCallingPostDataUpdate = 0x0 # bitfield:1 + m_bNotifyBoneTransformsChanged = 0x0 # bitfield:1 + m_bBoneMergeFlex = 0x0 # bitfield:1 + m_nLatchAbsOrigin = 0x0 # bitfield:2 + m_bDirtyBoneMergeBoneToRoot = 0x0 # bitfield:1 + m_nHierarchicalDepth = 0xEB # uint8_t + m_nHierarchyType = 0xEC # uint8_t + m_nDoNotSetAnimTimeInInvalidatePhysicsCount = 0xED # uint8_t + m_name = 0xF0 # CUtlStringToken + m_hierarchyAttachName = 0x130 # CUtlStringToken + m_flZOffset = 0x134 # float + m_vRenderOrigin = 0x138 # Vector + +class CGameSceneNodeHandle: + m_hOwner = 0x8 # CEntityHandle + m_name = 0xC # CUtlStringToken + +class CGlobalLightBase: + m_bSpotLight = 0x10 # bool + m_SpotLightOrigin = 0x14 # Vector + m_SpotLightAngles = 0x20 # QAngle + m_ShadowDirection = 0x2C # Vector + m_AmbientDirection = 0x38 # Vector + m_SpecularDirection = 0x44 # Vector + m_InspectorSpecularDirection = 0x50 # Vector + m_flSpecularPower = 0x5C # float + m_flSpecularIndependence = 0x60 # float + m_SpecularColor = 0x64 # Color + m_bStartDisabled = 0x68 # bool + m_bEnabled = 0x69 # bool + m_LightColor = 0x6A # Color + m_AmbientColor1 = 0x6E # Color + m_AmbientColor2 = 0x72 # Color + m_AmbientColor3 = 0x76 # Color + m_flSunDistance = 0x7C # float + m_flFOV = 0x80 # float + m_flNearZ = 0x84 # float + m_flFarZ = 0x88 # float + m_bEnableShadows = 0x8C # bool + m_bOldEnableShadows = 0x8D # bool + m_bBackgroundClearNotRequired = 0x8E # bool + m_flCloudScale = 0x90 # float + m_flCloud1Speed = 0x94 # float + m_flCloud1Direction = 0x98 # float + m_flCloud2Speed = 0x9C # float + m_flCloud2Direction = 0xA0 # float + m_flAmbientScale1 = 0xB0 # float + m_flAmbientScale2 = 0xB4 # float + m_flGroundScale = 0xB8 # float + m_flLightScale = 0xBC # float + m_flFoWDarkness = 0xC0 # float + m_bEnableSeparateSkyboxFog = 0xC4 # bool + m_vFowColor = 0xC8 # Vector + m_ViewOrigin = 0xD4 # Vector + m_ViewAngles = 0xE0 # QAngle + m_flViewFoV = 0xEC # float + m_WorldPoints = 0xF0 # Vector[8] + m_vFogOffsetLayer0 = 0x4A8 # Vector2D + m_vFogOffsetLayer1 = 0x4B0 # Vector2D + m_hEnvWind = 0x4B8 # CHandle + m_hEnvSky = 0x4BC # CHandle + +class CGlowOverlay: + m_vPos = 0x8 # Vector + m_bDirectional = 0x14 # bool + m_vDirection = 0x18 # Vector + m_bInSky = 0x24 # bool + m_skyObstructionScale = 0x28 # float + m_Sprites = 0x30 # CGlowSprite[4] + m_nSprites = 0xB0 # int32_t + m_flProxyRadius = 0xB4 # float + m_flHDRColorScale = 0xB8 # float + m_flGlowObstructionScale = 0xBC # float + m_bCacheGlowObstruction = 0xC0 # bool + m_bCacheSkyObstruction = 0xC1 # bool + m_bActivated = 0xC2 # int16_t + m_ListIndex = 0xC4 # uint16_t + m_queryHandle = 0xC8 # int32_t + +class CGlowProperty: + m_fGlowColor = 0x8 # Vector + m_iGlowType = 0x30 # int32_t + m_iGlowTeam = 0x34 # int32_t + m_nGlowRange = 0x38 # int32_t + m_nGlowRangeMin = 0x3C # int32_t + m_glowColorOverride = 0x40 # Color + m_bFlashing = 0x44 # bool + m_flGlowTime = 0x48 # float + m_flGlowStartTime = 0x4C # float + m_bEligibleForScreenHighlight = 0x50 # bool + m_bGlowing = 0x51 # bool + +class CGlowSprite: + m_vColor = 0x0 # Vector + m_flHorzSize = 0xC # float + m_flVertSize = 0x10 # float + m_hMaterial = 0x18 # CStrongHandle + +class CGrenadeTracer: + m_flTracerDuration = 0xCE0 # float + m_nType = 0xCE4 # GrenadeType_t + +class CHitboxComponent: + m_bvDisabledHitGroups = 0x24 # uint32_t[1] + +class CInfoDynamicShadowHint: + m_bDisabled = 0x540 # bool + m_flRange = 0x544 # float + m_nImportance = 0x548 # int32_t + m_nLightChoice = 0x54C # int32_t + m_hLight = 0x550 # CHandle + +class CInfoDynamicShadowHintBox: + m_vBoxMins = 0x558 # Vector + m_vBoxMaxs = 0x564 # Vector + +class CInfoOffscreenPanoramaTexture: + m_bDisabled = 0x540 # bool + m_nResolutionX = 0x544 # int32_t + m_nResolutionY = 0x548 # int32_t + m_szLayoutFileName = 0x550 # CUtlSymbolLarge + m_RenderAttrName = 0x558 # CUtlSymbolLarge + m_TargetEntities = 0x560 # C_NetworkUtlVectorBase> + m_nTargetChangeCount = 0x578 # int32_t + m_vecCSSClasses = 0x580 # C_NetworkUtlVectorBase + m_bCheckCSSClasses = 0x6F8 # bool + +class CInfoWorldLayer: + m_pOutputOnEntitiesSpawned = 0x540 # CEntityIOOutput + m_worldName = 0x568 # CUtlSymbolLarge + m_layerName = 0x570 # CUtlSymbolLarge + m_bWorldLayerVisible = 0x578 # bool + m_bEntitiesSpawned = 0x579 # bool + m_bCreateAsChildSpawnGroup = 0x57A # bool + m_hLayerSpawnGroup = 0x57C # uint32_t + m_bWorldLayerActuallyVisible = 0x580 # bool + +class CInterpolatedValue: + m_flStartTime = 0x0 # float + m_flEndTime = 0x4 # float + m_flStartValue = 0x8 # float + m_flEndValue = 0xC # float + m_nInterpType = 0x10 # int32_t + +class CLightComponent: + __m_pChainEntity = 0x48 # CNetworkVarChainer + m_Color = 0x85 # Color + m_SecondaryColor = 0x89 # Color + m_flBrightness = 0x90 # float + m_flBrightnessScale = 0x94 # float + m_flBrightnessMult = 0x98 # float + m_flRange = 0x9C # float + m_flFalloff = 0xA0 # float + m_flAttenuation0 = 0xA4 # float + m_flAttenuation1 = 0xA8 # float + m_flAttenuation2 = 0xAC # float + m_flTheta = 0xB0 # float + m_flPhi = 0xB4 # float + m_hLightCookie = 0xB8 # CStrongHandle + m_nCascades = 0xC0 # int32_t + m_nCastShadows = 0xC4 # int32_t + m_nShadowWidth = 0xC8 # int32_t + m_nShadowHeight = 0xCC # int32_t + m_bRenderDiffuse = 0xD0 # bool + m_nRenderSpecular = 0xD4 # int32_t + m_bRenderTransmissive = 0xD8 # bool + m_flOrthoLightWidth = 0xDC # float + m_flOrthoLightHeight = 0xE0 # float + m_nStyle = 0xE4 # int32_t + m_Pattern = 0xE8 # CUtlString + m_nCascadeRenderStaticObjects = 0xF0 # int32_t + m_flShadowCascadeCrossFade = 0xF4 # float + m_flShadowCascadeDistanceFade = 0xF8 # float + m_flShadowCascadeDistance0 = 0xFC # float + m_flShadowCascadeDistance1 = 0x100 # float + m_flShadowCascadeDistance2 = 0x104 # float + m_flShadowCascadeDistance3 = 0x108 # float + m_nShadowCascadeResolution0 = 0x10C # int32_t + m_nShadowCascadeResolution1 = 0x110 # int32_t + m_nShadowCascadeResolution2 = 0x114 # int32_t + m_nShadowCascadeResolution3 = 0x118 # int32_t + m_bUsesBakedShadowing = 0x11C # bool + m_nShadowPriority = 0x120 # int32_t + m_nBakedShadowIndex = 0x124 # int32_t + m_bRenderToCubemaps = 0x128 # bool + m_LightGroups = 0x130 # CUtlSymbolLarge + m_nDirectLight = 0x138 # int32_t + m_nIndirectLight = 0x13C # int32_t + m_flFadeMinDist = 0x140 # float + m_flFadeMaxDist = 0x144 # float + m_flShadowFadeMinDist = 0x148 # float + m_flShadowFadeMaxDist = 0x14C # float + m_bEnabled = 0x150 # bool + m_bFlicker = 0x151 # bool + m_bPrecomputedFieldsValid = 0x152 # bool + m_vPrecomputedBoundsMins = 0x154 # Vector + m_vPrecomputedBoundsMaxs = 0x160 # Vector + m_vPrecomputedOBBOrigin = 0x16C # Vector + m_vPrecomputedOBBAngles = 0x178 # QAngle + m_vPrecomputedOBBExtent = 0x184 # Vector + m_flPrecomputedMaxRange = 0x190 # float + m_nFogLightingMode = 0x194 # int32_t + m_flFogContributionStength = 0x198 # float + m_flNearClipPlane = 0x19C # float + m_SkyColor = 0x1A0 # Color + m_flSkyIntensity = 0x1A4 # float + m_SkyAmbientBounce = 0x1A8 # Color + m_bUseSecondaryColor = 0x1AC # bool + m_bMixedShadows = 0x1AD # bool + m_flLightStyleStartTime = 0x1B0 # GameTime_t + m_flCapsuleLength = 0x1B4 # float + m_flMinRoughness = 0x1B8 # float + +class CLogicRelay: + m_OnTrigger = 0x540 # CEntityIOOutput + m_OnSpawn = 0x568 # CEntityIOOutput + m_bDisabled = 0x590 # bool + m_bWaitForRefire = 0x591 # bool + m_bTriggerOnce = 0x592 # bool + m_bFastRetrigger = 0x593 # bool + m_bPassthoughCaller = 0x594 # bool + +class CModelState: + m_hModel = 0xA0 # CStrongHandle + m_ModelName = 0xA8 # CUtlSymbolLarge + m_bClientClothCreationSuppressed = 0xE8 # bool + m_MeshGroupMask = 0x180 # uint64_t + m_nIdealMotionType = 0x222 # int8_t + m_nForceLOD = 0x223 # int8_t + m_nClothUpdateFlags = 0x224 # int8_t + +class CNetworkedSequenceOperation: + m_hSequence = 0x8 # HSequence + m_flPrevCycle = 0xC # float + m_flCycle = 0x10 # float + m_flWeight = 0x14 # CNetworkedQuantizedFloat + m_bSequenceChangeNetworked = 0x1C # bool + m_bDiscontinuity = 0x1D # bool + m_flPrevCycleFromDiscontinuity = 0x20 # float + m_flPrevCycleForAnimEventDetection = 0x24 # float + +class CPlayer_CameraServices: + m_vecCsViewPunchAngle = 0x40 # QAngle + m_nCsViewPunchAngleTick = 0x4C # GameTick_t + m_flCsViewPunchAngleTickRatio = 0x50 # float + m_PlayerFog = 0x58 # C_fogplayerparams_t + m_hColorCorrectionCtrl = 0x98 # CHandle + m_hViewEntity = 0x9C # CHandle + m_hTonemapController = 0xA0 # CHandle + m_audio = 0xA8 # audioparams_t + m_PostProcessingVolumes = 0x120 # C_NetworkUtlVectorBase> + m_flOldPlayerZ = 0x138 # float + m_flOldPlayerViewOffsetZ = 0x13C # float + m_CurrentFog = 0x140 # fogparams_t + m_hOldFogController = 0x1A8 # CHandle + m_bOverrideFogColor = 0x1AC # bool[5] + m_OverrideFogColor = 0x1B1 # Color[5] + m_bOverrideFogStartEnd = 0x1C5 # bool[5] + m_fOverrideFogStart = 0x1CC # float[5] + m_fOverrideFogEnd = 0x1E0 # float[5] + m_hActivePostProcessingVolume = 0x1F4 # CHandle + m_angDemoViewAngles = 0x1F8 # QAngle + +class CPlayer_MovementServices: + m_nImpulse = 0x40 # int32_t + m_nButtons = 0x48 # CInButtonState + m_nQueuedButtonDownMask = 0x68 # uint64_t + m_nQueuedButtonChangeMask = 0x70 # uint64_t + m_nButtonDoublePressed = 0x78 # uint64_t + m_pButtonPressedCmdNumber = 0x80 # uint32_t[64] + m_nLastCommandNumberProcessed = 0x180 # uint32_t + m_nToggleButtonDownMask = 0x188 # uint64_t + m_flMaxspeed = 0x190 # float + m_arrForceSubtickMoveWhen = 0x194 # float[4] + m_flForwardMove = 0x1A4 # float + m_flLeftMove = 0x1A8 # float + m_flUpMove = 0x1AC # float + m_vecLastMovementImpulses = 0x1B0 # Vector + m_vecOldViewAngles = 0x1BC # QAngle + +class CPlayer_MovementServices_Humanoid: + m_flStepSoundTime = 0x1D0 # float + m_flFallVelocity = 0x1D4 # float + m_bInCrouch = 0x1D8 # bool + m_nCrouchState = 0x1DC # uint32_t + m_flCrouchTransitionStartTime = 0x1E0 # GameTime_t + m_bDucked = 0x1E4 # bool + m_bDucking = 0x1E5 # bool + m_bInDuckJump = 0x1E6 # bool + m_groundNormal = 0x1E8 # Vector + m_flSurfaceFriction = 0x1F4 # float + m_surfaceProps = 0x1F8 # CUtlStringToken + m_nStepside = 0x208 # int32_t + +class CPlayer_ObserverServices: + m_iObserverMode = 0x40 # uint8_t + m_hObserverTarget = 0x44 # CHandle + m_iObserverLastMode = 0x48 # ObserverMode_t + m_bForcedObserverMode = 0x4C # bool + m_flObserverChaseDistance = 0x50 # float + m_flObserverChaseDistanceCalcTime = 0x54 # GameTime_t + +class CPlayer_WeaponServices: + m_bAllowSwitchToNoWeapon = 0x40 # bool + m_hMyWeapons = 0x48 # C_NetworkUtlVectorBase> + m_hActiveWeapon = 0x60 # CHandle + m_hLastWeapon = 0x64 # CHandle + m_iAmmo = 0x68 # uint16_t[32] + +class CPointOffScreenIndicatorUi: + m_bBeenEnabled = 0xF20 # bool + m_bHide = 0xF21 # bool + m_flSeenTargetTime = 0xF24 # float + m_pTargetPanel = 0xF28 # C_PointClientUIWorldPanel* + +class CPointTemplate: + m_iszWorldName = 0x540 # CUtlSymbolLarge + m_iszSource2EntityLumpName = 0x548 # CUtlSymbolLarge + m_iszEntityFilterName = 0x550 # CUtlSymbolLarge + m_flTimeoutInterval = 0x558 # float + m_bAsynchronouslySpawnEntities = 0x55C # bool + m_pOutputOnSpawned = 0x560 # CEntityIOOutput + m_clientOnlyEntityBehavior = 0x588 # PointTemplateClientOnlyEntityBehavior_t + m_ownerSpawnGroupType = 0x58C # PointTemplateOwnerSpawnGroupType_t + m_createdSpawnGroupHandles = 0x590 # CUtlVector + m_SpawnedEntityHandles = 0x5A8 # CUtlVector + m_ScriptSpawnCallback = 0x5C0 # HSCRIPT + m_ScriptCallbackScope = 0x5C8 # HSCRIPT + +class CPrecipitationVData: + m_szParticlePrecipitationEffect = 0x28 # CResourceNameTyped> + m_flInnerDistance = 0x108 # float + m_nAttachType = 0x10C # ParticleAttachment_t + m_bBatchSameVolumeType = 0x110 # bool + m_nRTEnvCP = 0x114 # int32_t + m_nRTEnvCPComponent = 0x118 # int32_t + m_szModifier = 0x120 # CUtlString + +class CProjectedTextureBase: + m_hTargetEntity = 0xC # CHandle + m_bState = 0x10 # bool + m_bAlwaysUpdate = 0x11 # bool + m_flLightFOV = 0x14 # float + m_bEnableShadows = 0x18 # bool + m_bSimpleProjection = 0x19 # bool + m_bLightOnlyTarget = 0x1A # bool + m_bLightWorld = 0x1B # bool + m_bCameraSpace = 0x1C # bool + m_flBrightnessScale = 0x20 # float + m_LightColor = 0x24 # Color + m_flIntensity = 0x28 # float + m_flLinearAttenuation = 0x2C # float + m_flQuadraticAttenuation = 0x30 # float + m_bVolumetric = 0x34 # bool + m_flVolumetricIntensity = 0x38 # float + m_flNoiseStrength = 0x3C # float + m_flFlashlightTime = 0x40 # float + m_nNumPlanes = 0x44 # uint32_t + m_flPlaneOffset = 0x48 # float + m_flColorTransitionTime = 0x4C # float + m_flAmbient = 0x50 # float + m_SpotlightTextureName = 0x54 # char[512] + m_nSpotlightTextureFrame = 0x254 # int32_t + m_nShadowQuality = 0x258 # uint32_t + m_flNearZ = 0x25C # float + m_flFarZ = 0x260 # float + m_flProjectionSize = 0x264 # float + m_flRotation = 0x268 # float + m_bFlipHorizontal = 0x26C # bool + +class CRenderComponent: + __m_pChainEntity = 0x10 # CNetworkVarChainer + m_bIsRenderingWithViewModels = 0x50 # bool + m_nSplitscreenFlags = 0x54 # uint32_t + m_bEnableRendering = 0x60 # bool + m_bInterpolationReadyToDraw = 0xB0 # bool + +class CSMatchStats_t: + m_iEnemy5Ks = 0x68 # int32_t + m_iEnemy4Ks = 0x6C # int32_t + m_iEnemy3Ks = 0x70 # int32_t + +class CSPerRoundStats_t: + m_iKills = 0x30 # int32_t + m_iDeaths = 0x34 # int32_t + m_iAssists = 0x38 # int32_t + m_iDamage = 0x3C # int32_t + m_iEquipmentValue = 0x40 # int32_t + m_iMoneySaved = 0x44 # int32_t + m_iKillReward = 0x48 # int32_t + m_iLiveTime = 0x4C # int32_t + m_iHeadShotKills = 0x50 # int32_t + m_iObjective = 0x54 # int32_t + m_iCashEarned = 0x58 # int32_t + m_iUtilityDamage = 0x5C # int32_t + m_iEnemiesFlashed = 0x60 # int32_t + +class CScriptComponent: + m_scriptClassName = 0x30 # CUtlSymbolLarge + +class CSkeletonInstance: + m_modelState = 0x160 # CModelState + m_bIsAnimationEnabled = 0x390 # bool + m_bUseParentRenderBounds = 0x391 # bool + m_bDisableSolidCollisionsForHierarchy = 0x392 # bool + m_bDirtyMotionType = 0x0 # bitfield:1 + m_bIsGeneratingLatchedParentSpaceState = 0x0 # bitfield:1 + m_materialGroup = 0x394 # CUtlStringToken + m_nHitboxSet = 0x398 # uint8_t + +class CSkyboxReference: + m_worldGroupId = 0x540 # WorldGroupId_t + m_hSkyCamera = 0x544 # CHandle + +class CTimeline: + m_flValues = 0x10 # float[64] + m_nValueCounts = 0x110 # int32_t[64] + m_nBucketCount = 0x210 # int32_t + m_flInterval = 0x214 # float + m_flFinalValue = 0x218 # float + m_nCompressionType = 0x21C # TimelineCompression_t + m_bStopped = 0x220 # bool + +class C_AttributeContainer: + m_Item = 0x50 # C_EconItemView + m_iExternalItemProviderRegisteredToken = 0x498 # int32_t + m_ullRegisteredAsItemID = 0x4A0 # uint64_t + +class C_BarnLight: + m_bEnabled = 0xCC0 # bool + m_nColorMode = 0xCC4 # int32_t + m_Color = 0xCC8 # Color + m_flColorTemperature = 0xCCC # float + m_flBrightness = 0xCD0 # float + m_flBrightnessScale = 0xCD4 # float + m_nDirectLight = 0xCD8 # int32_t + m_nBakedShadowIndex = 0xCDC # int32_t + m_nLuminaireShape = 0xCE0 # int32_t + m_flLuminaireSize = 0xCE4 # float + m_flLuminaireAnisotropy = 0xCE8 # float + m_LightStyleString = 0xCF0 # CUtlString + m_flLightStyleStartTime = 0xCF8 # GameTime_t + m_QueuedLightStyleStrings = 0xD00 # C_NetworkUtlVectorBase + m_LightStyleEvents = 0xD18 # C_NetworkUtlVectorBase + m_LightStyleTargets = 0xD30 # C_NetworkUtlVectorBase> + m_StyleEvent = 0xD48 # CEntityIOOutput[4] + m_hLightCookie = 0xDE8 # CStrongHandle + m_flShape = 0xDF0 # float + m_flSoftX = 0xDF4 # float + m_flSoftY = 0xDF8 # float + m_flSkirt = 0xDFC # float + m_flSkirtNear = 0xE00 # float + m_vSizeParams = 0xE04 # Vector + m_flRange = 0xE10 # float + m_vShear = 0xE14 # Vector + m_nBakeSpecularToCubemaps = 0xE20 # int32_t + m_vBakeSpecularToCubemapsSize = 0xE24 # Vector + m_nCastShadows = 0xE30 # int32_t + m_nShadowMapSize = 0xE34 # int32_t + m_nShadowPriority = 0xE38 # int32_t + m_bContactShadow = 0xE3C # bool + m_nBounceLight = 0xE40 # int32_t + m_flBounceScale = 0xE44 # float + m_flMinRoughness = 0xE48 # float + m_vAlternateColor = 0xE4C # Vector + m_fAlternateColorBrightness = 0xE58 # float + m_nFog = 0xE5C # int32_t + m_flFogStrength = 0xE60 # float + m_nFogShadows = 0xE64 # int32_t + m_flFogScale = 0xE68 # float + m_flFadeSizeStart = 0xE6C # float + m_flFadeSizeEnd = 0xE70 # float + m_flShadowFadeSizeStart = 0xE74 # float + m_flShadowFadeSizeEnd = 0xE78 # float + m_bPrecomputedFieldsValid = 0xE7C # bool + m_vPrecomputedBoundsMins = 0xE80 # Vector + m_vPrecomputedBoundsMaxs = 0xE8C # Vector + m_vPrecomputedOBBOrigin = 0xE98 # Vector + m_vPrecomputedOBBAngles = 0xEA4 # QAngle + m_vPrecomputedOBBExtent = 0xEB0 # Vector + +class C_BaseButton: + m_glowEntity = 0xCC0 # CHandle + m_usable = 0xCC4 # bool + m_szDisplayText = 0xCC8 # CUtlSymbolLarge + +class C_BaseCSGrenade: + m_bClientPredictDelete = 0x1940 # bool + m_bRedraw = 0x1968 # bool + m_bIsHeldByPlayer = 0x1969 # bool + m_bPinPulled = 0x196A # bool + m_bJumpThrow = 0x196B # bool + m_eThrowStatus = 0x196C # EGrenadeThrowState + m_fThrowTime = 0x1970 # GameTime_t + m_flThrowStrength = 0x1974 # float + m_flThrowStrengthApproach = 0x1978 # float + m_fDropTime = 0x197C # GameTime_t + +class C_BaseCSGrenadeProjectile: + m_vInitialVelocity = 0x1068 # Vector + m_nBounces = 0x1074 # int32_t + m_nExplodeEffectIndex = 0x1078 # CStrongHandle + m_nExplodeEffectTickBegin = 0x1080 # int32_t + m_vecExplodeEffectOrigin = 0x1084 # Vector + m_flSpawnTime = 0x1090 # GameTime_t + vecLastTrailLinePos = 0x1094 # Vector + flNextTrailLineTime = 0x10A0 # GameTime_t + m_bExplodeEffectBegan = 0x10A4 # bool + m_bCanCreateGrenadeTrail = 0x10A5 # bool + m_nSnapshotTrajectoryEffectIndex = 0x10A8 # ParticleIndex_t + m_hSnapshotTrajectoryParticleSnapshot = 0x10B0 # CStrongHandle + m_arrTrajectoryTrailPoints = 0x10B8 # CUtlVector + m_arrTrajectoryTrailPointCreationTimes = 0x10D0 # CUtlVector + m_flTrajectoryTrailEffectCreationTime = 0x10E8 # float + +class C_BaseClientUIEntity: + m_bEnabled = 0xCC8 # bool + m_DialogXMLName = 0xCD0 # CUtlSymbolLarge + m_PanelClassName = 0xCD8 # CUtlSymbolLarge + m_PanelID = 0xCE0 # CUtlSymbolLarge + +class C_BaseCombatCharacter: + m_hMyWearables = 0x1018 # C_NetworkUtlVectorBase> + m_bloodColor = 0x1030 # int32_t + m_leftFootAttachment = 0x1034 # AttachmentHandle_t + m_rightFootAttachment = 0x1035 # AttachmentHandle_t + m_nWaterWakeMode = 0x1038 # C_BaseCombatCharacter::WaterWakeMode_t + m_flWaterWorldZ = 0x103C # float + m_flWaterNextTraceTime = 0x1040 # float + m_flFieldOfView = 0x1044 # float + +class C_BaseDoor: + m_bIsUsable = 0xCC0 # bool + +class C_BaseEntity: + m_CBodyComponent = 0x30 # CBodyComponent* + m_NetworkTransmitComponent = 0x38 # CNetworkTransmitComponent + m_nLastThinkTick = 0x308 # GameTick_t + m_pGameSceneNode = 0x310 # CGameSceneNode* + m_pRenderComponent = 0x318 # CRenderComponent* + m_pCollision = 0x320 # CCollisionProperty* + m_iMaxHealth = 0x328 # int32_t + m_iHealth = 0x32C # int32_t + m_lifeState = 0x330 # uint8_t + m_bTakesDamage = 0x331 # bool + m_nTakeDamageFlags = 0x334 # TakeDamageFlags_t + m_ubInterpolationFrame = 0x338 # uint8_t + m_hSceneObjectController = 0x33C # CHandle + m_nNoInterpolationTick = 0x340 # int32_t + m_nVisibilityNoInterpolationTick = 0x344 # int32_t + m_flProxyRandomValue = 0x348 # float + m_iEFlags = 0x34C # int32_t + m_nWaterType = 0x350 # uint8_t + m_bInterpolateEvenWithNoModel = 0x351 # bool + m_bPredictionEligible = 0x352 # bool + m_bApplyLayerMatchIDToModel = 0x353 # bool + m_tokLayerMatchID = 0x354 # CUtlStringToken + m_nSubclassID = 0x358 # CUtlStringToken + m_nSimulationTick = 0x368 # int32_t + m_iCurrentThinkContext = 0x36C # int32_t + m_aThinkFunctions = 0x370 # CUtlVector + m_flAnimTime = 0x388 # float + m_flSimulationTime = 0x38C # float + m_nSceneObjectOverrideFlags = 0x390 # uint8_t + m_bHasSuccessfullyInterpolated = 0x391 # bool + m_bHasAddedVarsToInterpolation = 0x392 # bool + m_bRenderEvenWhenNotSuccessfullyInterpolated = 0x393 # bool + m_nInterpolationLatchDirtyFlags = 0x394 # int32_t[2] + m_ListEntry = 0x39C # uint16_t[11] + m_flCreateTime = 0x3B4 # GameTime_t + m_flSpeed = 0x3B8 # float + m_EntClientFlags = 0x3BC # uint16_t + m_bClientSideRagdoll = 0x3BE # bool + m_iTeamNum = 0x3BF # uint8_t + m_spawnflags = 0x3C0 # uint32_t + m_nNextThinkTick = 0x3C4 # GameTick_t + m_fFlags = 0x3C8 # uint32_t + m_vecAbsVelocity = 0x3CC # Vector + m_vecVelocity = 0x3D8 # CNetworkVelocityVector + m_vecBaseVelocity = 0x408 # Vector + m_hEffectEntity = 0x414 # CHandle + m_hOwnerEntity = 0x418 # CHandle + m_MoveCollide = 0x41C # MoveCollide_t + m_MoveType = 0x41D # MoveType_t + m_flWaterLevel = 0x420 # float + m_fEffects = 0x424 # uint32_t + m_hGroundEntity = 0x428 # CHandle + m_flFriction = 0x42C # float + m_flElasticity = 0x430 # float + m_flGravityScale = 0x434 # float + m_flTimeScale = 0x438 # float + m_bSimulatedEveryTick = 0x43C # bool + m_bAnimatedEveryTick = 0x43D # bool + m_flNavIgnoreUntilTime = 0x440 # GameTime_t + m_hThink = 0x444 # uint16_t + m_fBBoxVisFlags = 0x450 # uint8_t + m_bPredictable = 0x451 # bool + m_bRenderWithViewModels = 0x452 # bool + m_nSplitUserPlayerPredictionSlot = 0x454 # CSplitScreenSlot + m_nFirstPredictableCommand = 0x458 # int32_t + m_nLastPredictableCommand = 0x45C # int32_t + m_hOldMoveParent = 0x460 # CHandle + m_Particles = 0x468 # CParticleProperty + m_vecPredictedScriptFloats = 0x490 # CUtlVector + m_vecPredictedScriptFloatIDs = 0x4A8 # CUtlVector + m_nNextScriptVarRecordID = 0x4D8 # int32_t + m_vecAngVelocity = 0x4E8 # QAngle + m_DataChangeEventRef = 0x4F4 # int32_t + m_dependencies = 0x4F8 # CUtlVector + m_nCreationTick = 0x510 # int32_t + m_bAnimTimeChanged = 0x529 # bool + m_bSimulationTimeChanged = 0x52A # bool + m_sUniqueHammerID = 0x538 # CUtlString + +class C_BaseFire: + m_flScale = 0x540 # float + m_flStartScale = 0x544 # float + m_flScaleTime = 0x548 # float + m_nFlags = 0x54C # uint32_t + +class C_BaseFlex: + m_flexWeight = 0xE90 # C_NetworkUtlVectorBase + m_vLookTargetPosition = 0xEA8 # Vector + m_blinktoggle = 0xEC0 # bool + m_nLastFlexUpdateFrameCount = 0xF20 # int32_t + m_CachedViewTarget = 0xF24 # Vector + m_nNextSceneEventId = 0xF30 # uint32_t + m_iBlink = 0xF34 # int32_t + m_blinktime = 0xF38 # float + m_prevblinktoggle = 0xF3C # bool + m_iJawOpen = 0xF40 # int32_t + m_flJawOpenAmount = 0xF44 # float + m_flBlinkAmount = 0xF48 # float + m_iMouthAttachment = 0xF4C # AttachmentHandle_t + m_iEyeAttachment = 0xF4D # AttachmentHandle_t + m_bResetFlexWeightsOnModelChange = 0xF4E # bool + m_nEyeOcclusionRendererBone = 0xF68 # int32_t + m_mEyeOcclusionRendererCameraToBoneTransform = 0xF6C # matrix3x4_t + m_vEyeOcclusionRendererHalfExtent = 0xF9C # Vector + m_PhonemeClasses = 0xFB8 # C_BaseFlex::Emphasized_Phoneme[3] + +class C_BaseFlex_Emphasized_Phoneme: + m_sClassName = 0x0 # CUtlString + m_flAmount = 0x18 # float + m_bRequired = 0x1C # bool + m_bBasechecked = 0x1D # bool + m_bValid = 0x1E # bool + +class C_BaseGrenade: + m_bHasWarnedAI = 0x1018 # bool + m_bIsSmokeGrenade = 0x1019 # bool + m_bIsLive = 0x101A # bool + m_DmgRadius = 0x101C # float + m_flDetonateTime = 0x1020 # GameTime_t + m_flWarnAITime = 0x1024 # float + m_flDamage = 0x1028 # float + m_iszBounceSound = 0x1030 # CUtlSymbolLarge + m_ExplosionSound = 0x1038 # CUtlString + m_hThrower = 0x1044 # CHandle + m_flNextAttack = 0x105C # GameTime_t + m_hOriginalThrower = 0x1060 # CHandle + +class C_BaseModelEntity: + m_CRenderComponent = 0xA10 # CRenderComponent* + m_CHitboxComponent = 0xA18 # CHitboxComponent + m_bInitModelEffects = 0xA60 # bool + m_bIsStaticProp = 0xA61 # bool + m_nLastAddDecal = 0xA64 # int32_t + m_nDecalsAdded = 0xA68 # int32_t + m_iOldHealth = 0xA6C # int32_t + m_nRenderMode = 0xA70 # RenderMode_t + m_nRenderFX = 0xA71 # RenderFx_t + m_bAllowFadeInView = 0xA72 # bool + m_clrRender = 0xA73 # Color + m_vecRenderAttributes = 0xA78 # C_UtlVectorEmbeddedNetworkVar + m_LightGroup = 0xAE0 # CUtlStringToken + m_bRenderToCubemaps = 0xAE4 # bool + m_Collision = 0xAE8 # CCollisionProperty + m_Glow = 0xB98 # CGlowProperty + m_flGlowBackfaceMult = 0xBF0 # float + m_fadeMinDist = 0xBF4 # float + m_fadeMaxDist = 0xBF8 # float + m_flFadeScale = 0xBFC # float + m_flShadowStrength = 0xC00 # float + m_nObjectCulling = 0xC04 # uint8_t + m_nAddDecal = 0xC08 # int32_t + m_vDecalPosition = 0xC0C # Vector + m_vDecalForwardAxis = 0xC18 # Vector + m_flDecalHealBloodRate = 0xC24 # float + m_flDecalHealHeightRate = 0xC28 # float + m_ConfigEntitiesToPropagateMaterialDecalsTo = 0xC30 # C_NetworkUtlVectorBase> + m_vecViewOffset = 0xC48 # CNetworkViewOffsetVector + m_pClientAlphaProperty = 0xC78 # CClientAlphaProperty* + m_ClientOverrideTint = 0xC80 # Color + m_bUseClientOverrideTint = 0xC84 # bool + +class C_BasePlayerPawn: + m_pWeaponServices = 0x10A8 # CPlayer_WeaponServices* + m_pItemServices = 0x10B0 # CPlayer_ItemServices* + m_pAutoaimServices = 0x10B8 # CPlayer_AutoaimServices* + m_pObserverServices = 0x10C0 # CPlayer_ObserverServices* + m_pWaterServices = 0x10C8 # CPlayer_WaterServices* + m_pUseServices = 0x10D0 # CPlayer_UseServices* + m_pFlashlightServices = 0x10D8 # CPlayer_FlashlightServices* + m_pCameraServices = 0x10E0 # CPlayer_CameraServices* + m_pMovementServices = 0x10E8 # CPlayer_MovementServices* + m_ServerViewAngleChanges = 0x10F8 # C_UtlVectorEmbeddedNetworkVar + m_nHighestConsumedServerViewAngleChangeIndex = 0x1148 # uint32_t + v_angle = 0x114C # QAngle + v_anglePrevious = 0x1158 # QAngle + m_iHideHUD = 0x1164 # uint32_t + m_skybox3d = 0x1168 # sky3dparams_t + m_flDeathTime = 0x11F8 # GameTime_t + m_vecPredictionError = 0x11FC # Vector + m_flPredictionErrorTime = 0x1208 # GameTime_t + m_flFOVSensitivityAdjust = 0x120C # float + m_flMouseSensitivity = 0x1210 # float + m_vOldOrigin = 0x1214 # Vector + m_flOldSimulationTime = 0x1220 # float + m_nLastExecutedCommandNumber = 0x1224 # int32_t + m_nLastExecutedCommandTick = 0x1228 # int32_t + m_hController = 0x122C # CHandle + m_bIsSwappingToPredictableController = 0x1230 # bool + +class C_BasePlayerWeapon: + m_nNextPrimaryAttackTick = 0x1560 # GameTick_t + m_flNextPrimaryAttackTickRatio = 0x1564 # float + m_nNextSecondaryAttackTick = 0x1568 # GameTick_t + m_flNextSecondaryAttackTickRatio = 0x156C # float + m_iClip1 = 0x1570 # int32_t + m_iClip2 = 0x1574 # int32_t + m_pReserveAmmo = 0x1578 # int32_t[2] + +class C_BasePropDoor: + m_eDoorState = 0x10F8 # DoorState_t + m_modelChanged = 0x10FC # bool + m_bLocked = 0x10FD # bool + m_closedPosition = 0x1100 # Vector + m_closedAngles = 0x110C # QAngle + m_hMaster = 0x1118 # CHandle + m_vWhereToSetLightingOrigin = 0x111C # Vector + +class C_BaseTrigger: + m_bDisabled = 0xCC0 # bool + m_bClientSidePredicted = 0xCC1 # bool + +class C_BaseViewModel: + m_vecLastFacing = 0xE88 # Vector + m_nViewModelIndex = 0xE94 # uint32_t + m_nAnimationParity = 0xE98 # uint32_t + m_flAnimationStartTime = 0xE9C # float + m_hWeapon = 0xEA0 # CHandle + m_sVMName = 0xEA8 # CUtlSymbolLarge + m_sAnimationPrefix = 0xEB0 # CUtlSymbolLarge + m_hWeaponModel = 0xEB8 # CHandle + m_iCameraAttachment = 0xEBC # AttachmentHandle_t + m_vecLastCameraAngles = 0xEC0 # QAngle + m_previousElapsedDuration = 0xECC # float + m_previousCycle = 0xED0 # float + m_nOldAnimationParity = 0xED4 # int32_t + m_hOldLayerSequence = 0xED8 # HSequence + m_oldLayer = 0xEDC # int32_t + m_oldLayerStartTime = 0xEE0 # float + m_hControlPanel = 0xEE4 # CHandle + +class C_Beam: + m_flFrameRate = 0xCC0 # float + m_flHDRColorScale = 0xCC4 # float + m_flFireTime = 0xCC8 # GameTime_t + m_flDamage = 0xCCC # float + m_nNumBeamEnts = 0xCD0 # uint8_t + m_queryHandleHalo = 0xCD4 # int32_t + m_hBaseMaterial = 0xCF8 # CStrongHandle + m_nHaloIndex = 0xD00 # CStrongHandle + m_nBeamType = 0xD08 # BeamType_t + m_nBeamFlags = 0xD0C # uint32_t + m_hAttachEntity = 0xD10 # CHandle[10] + m_nAttachIndex = 0xD38 # AttachmentHandle_t[10] + m_fWidth = 0xD44 # float + m_fEndWidth = 0xD48 # float + m_fFadeLength = 0xD4C # float + m_fHaloScale = 0xD50 # float + m_fAmplitude = 0xD54 # float + m_fStartFrame = 0xD58 # float + m_fSpeed = 0xD5C # float + m_flFrame = 0xD60 # float + m_nClipStyle = 0xD64 # BeamClipStyle_t + m_bTurnedOff = 0xD68 # bool + m_vecEndPos = 0xD6C # Vector + m_hEndEntity = 0xD78 # CHandle + +class C_BreakableProp: + m_OnBreak = 0xEC8 # CEntityIOOutput + m_OnHealthChanged = 0xEF0 # CEntityOutputTemplate + m_OnTakeDamage = 0xF18 # CEntityIOOutput + m_impactEnergyScale = 0xF40 # float + m_iMinHealthDmg = 0xF44 # int32_t + m_flPressureDelay = 0xF48 # float + m_hBreaker = 0xF4C # CHandle + m_PerformanceMode = 0xF50 # PerformanceMode_t + m_flDmgModBullet = 0xF54 # float + m_flDmgModClub = 0xF58 # float + m_flDmgModExplosive = 0xF5C # float + m_flDmgModFire = 0xF60 # float + m_iszPhysicsDamageTableName = 0xF68 # CUtlSymbolLarge + m_iszBasePropData = 0xF70 # CUtlSymbolLarge + m_iInteractions = 0xF78 # int32_t + m_flPreventDamageBeforeTime = 0xF7C # GameTime_t + m_bHasBreakPiecesOrCommands = 0xF80 # bool + m_explodeDamage = 0xF84 # float + m_explodeRadius = 0xF88 # float + m_explosionDelay = 0xF90 # float + m_explosionBuildupSound = 0xF98 # CUtlSymbolLarge + m_explosionCustomEffect = 0xFA0 # CUtlSymbolLarge + m_explosionCustomSound = 0xFA8 # CUtlSymbolLarge + m_explosionModifier = 0xFB0 # CUtlSymbolLarge + m_hPhysicsAttacker = 0xFB8 # CHandle + m_flLastPhysicsInfluenceTime = 0xFBC # GameTime_t + m_flDefaultFadeScale = 0xFC0 # float + m_hLastAttacker = 0xFC4 # CHandle + m_hFlareEnt = 0xFC8 # CHandle + m_noGhostCollision = 0xFCC # bool + +class C_BulletHitModel: + m_matLocal = 0xE80 # matrix3x4_t + m_iBoneIndex = 0xEB0 # int32_t + m_hPlayerParent = 0xEB4 # CHandle + m_bIsHit = 0xEB8 # bool + m_flTimeCreated = 0xEBC # float + m_vecStartPos = 0xEC0 # Vector + +class C_C4: + m_szScreenText = 0x1940 # char[32] + m_bombdroppedlightParticleIndex = 0x1960 # ParticleIndex_t + m_bStartedArming = 0x1964 # bool + m_fArmedTime = 0x1968 # GameTime_t + m_bBombPlacedAnimation = 0x196C # bool + m_bIsPlantingViaUse = 0x196D # bool + m_entitySpottedState = 0x1970 # EntitySpottedState_t + m_nSpotRules = 0x1988 # int32_t + m_bPlayedArmingBeeps = 0x198C # bool[7] + m_bBombPlanted = 0x1993 # bool + m_bDroppedFromDeath = 0x1994 # bool + +class C_CSGOViewModel: + m_bShouldIgnoreOffsetAndAccuracy = 0xF10 # bool + m_nWeaponParity = 0xF14 # uint32_t + m_nOldWeaponParity = 0xF18 # uint32_t + m_nLastKnownAssociatedWeaponEntIndex = 0xF1C # CEntityIndex + m_bNeedToQueueHighResComposite = 0xF20 # bool + m_vLoweredWeaponOffset = 0xF64 # QAngle + +class C_CSGO_MapPreviewCameraPath: + m_flZFar = 0x540 # float + m_flZNear = 0x544 # float + m_bLoop = 0x548 # bool + m_bVerticalFOV = 0x549 # bool + m_bConstantSpeed = 0x54A # bool + m_flDuration = 0x54C # float + m_flPathLength = 0x590 # float + m_flPathDuration = 0x594 # float + +class C_CSGO_MapPreviewCameraPathNode: + m_szParentPathUniqueID = 0x540 # CUtlSymbolLarge + m_nPathIndex = 0x548 # int32_t + m_vInTangentLocal = 0x54C # Vector + m_vOutTangentLocal = 0x558 # Vector + m_flFOV = 0x564 # float + m_flSpeed = 0x568 # float + m_flEaseIn = 0x56C # float + m_flEaseOut = 0x570 # float + m_vInTangentWorld = 0x574 # Vector + m_vOutTangentWorld = 0x580 # Vector + +class C_CSGO_PreviewModel: + m_animgraph = 0x1018 # CUtlString + m_animgraphCharacterModeString = 0x1020 # CUtlString + m_defaultAnim = 0x1028 # CUtlString + m_nDefaultAnimLoopMode = 0x1030 # AnimLoopMode_t + m_flInitialModelScale = 0x1034 # float + +class C_CSGO_PreviewPlayer: + m_animgraph = 0x22C8 # CUtlString + m_animgraphCharacterModeString = 0x22D0 # CUtlString + m_flInitialModelScale = 0x22D8 # float + +class C_CSGO_TeamPreviewCamera: + m_nVariant = 0x5A0 # int32_t + m_bDofEnabled = 0x5A4 # bool + m_flDofNearBlurry = 0x5A8 # float + m_flDofNearCrisp = 0x5AC # float + m_flDofFarCrisp = 0x5B0 # float + m_flDofFarBlurry = 0x5B4 # float + m_flDofTiltToGround = 0x5B8 # float + +class C_CSGO_TeamPreviewCharacterPosition: + m_nVariant = 0x540 # int32_t + m_nRandom = 0x544 # int32_t + m_nOrdinal = 0x548 # int32_t + m_sWeaponName = 0x550 # CUtlString + m_xuid = 0x558 # uint64_t + m_agentItem = 0x560 # C_EconItemView + m_glovesItem = 0x9A8 # C_EconItemView + m_weaponItem = 0xDF0 # C_EconItemView + +class C_CSGameRules: + __m_pChainEntity = 0x8 # CNetworkVarChainer + m_bFreezePeriod = 0x30 # bool + m_bWarmupPeriod = 0x31 # bool + m_fWarmupPeriodEnd = 0x34 # GameTime_t + m_fWarmupPeriodStart = 0x38 # GameTime_t + m_nTotalPausedTicks = 0x3C # int32_t + m_nPauseStartTick = 0x40 # int32_t + m_bServerPaused = 0x44 # bool + m_bGamePaused = 0x45 # bool + m_bTerroristTimeOutActive = 0x46 # bool + m_bCTTimeOutActive = 0x47 # bool + m_flTerroristTimeOutRemaining = 0x48 # float + m_flCTTimeOutRemaining = 0x4C # float + m_nTerroristTimeOuts = 0x50 # int32_t + m_nCTTimeOuts = 0x54 # int32_t + m_bTechnicalTimeOut = 0x58 # bool + m_bMatchWaitingForResume = 0x59 # bool + m_iRoundTime = 0x5C # int32_t + m_fMatchStartTime = 0x60 # float + m_fRoundStartTime = 0x64 # GameTime_t + m_flRestartRoundTime = 0x68 # GameTime_t + m_bGameRestart = 0x6C # bool + m_flGameStartTime = 0x70 # float + m_timeUntilNextPhaseStarts = 0x74 # float + m_gamePhase = 0x78 # int32_t + m_totalRoundsPlayed = 0x7C # int32_t + m_nRoundsPlayedThisPhase = 0x80 # int32_t + m_nOvertimePlaying = 0x84 # int32_t + m_iHostagesRemaining = 0x88 # int32_t + m_bAnyHostageReached = 0x8C # bool + m_bMapHasBombTarget = 0x8D # bool + m_bMapHasRescueZone = 0x8E # bool + m_bMapHasBuyZone = 0x8F # bool + m_bIsQueuedMatchmaking = 0x90 # bool + m_nQueuedMatchmakingMode = 0x94 # int32_t + m_bIsValveDS = 0x98 # bool + m_bLogoMap = 0x99 # bool + m_bPlayAllStepSoundsOnServer = 0x9A # bool + m_iSpectatorSlotCount = 0x9C # int32_t + m_MatchDevice = 0xA0 # int32_t + m_bHasMatchStarted = 0xA4 # bool + m_nNextMapInMapgroup = 0xA8 # int32_t + m_szTournamentEventName = 0xAC # char[512] + m_szTournamentEventStage = 0x2AC # char[512] + m_szMatchStatTxt = 0x4AC # char[512] + m_szTournamentPredictionsTxt = 0x6AC # char[512] + m_nTournamentPredictionsPct = 0x8AC # int32_t + m_flCMMItemDropRevealStartTime = 0x8B0 # GameTime_t + m_flCMMItemDropRevealEndTime = 0x8B4 # GameTime_t + m_bIsDroppingItems = 0x8B8 # bool + m_bIsQuestEligible = 0x8B9 # bool + m_bIsHltvActive = 0x8BA # bool + m_nGuardianModeWaveNumber = 0x8BC # int32_t + m_nGuardianModeSpecialKillsRemaining = 0x8C0 # int32_t + m_nGuardianModeSpecialWeaponNeeded = 0x8C4 # int32_t + m_nGuardianGrenadesToGiveBots = 0x8C8 # int32_t + m_nNumHeaviesToSpawn = 0x8CC # int32_t + m_numGlobalGiftsGiven = 0x8D0 # uint32_t + m_numGlobalGifters = 0x8D4 # uint32_t + m_numGlobalGiftsPeriodSeconds = 0x8D8 # uint32_t + m_arrFeaturedGiftersAccounts = 0x8DC # uint32_t[4] + m_arrFeaturedGiftersGifts = 0x8EC # uint32_t[4] + m_arrProhibitedItemIndices = 0x8FC # uint16_t[100] + m_arrTournamentActiveCasterAccounts = 0x9C4 # uint32_t[4] + m_numBestOfMaps = 0x9D4 # int32_t + m_nHalloweenMaskListSeed = 0x9D8 # int32_t + m_bBombDropped = 0x9DC # bool + m_bBombPlanted = 0x9DD # bool + m_iRoundWinStatus = 0x9E0 # int32_t + m_eRoundWinReason = 0x9E4 # int32_t + m_bTCantBuy = 0x9E8 # bool + m_bCTCantBuy = 0x9E9 # bool + m_flGuardianBuyUntilTime = 0x9EC # GameTime_t + m_iMatchStats_RoundResults = 0x9F0 # int32_t[30] + m_iMatchStats_PlayersAlive_CT = 0xA68 # int32_t[30] + m_iMatchStats_PlayersAlive_T = 0xAE0 # int32_t[30] + m_TeamRespawnWaveTimes = 0xB58 # float[32] + m_flNextRespawnWave = 0xBD8 # GameTime_t[32] + m_nServerQuestID = 0xC58 # int32_t + m_vMinimapMins = 0xC5C # Vector + m_vMinimapMaxs = 0xC68 # Vector + m_MinimapVerticalSectionHeights = 0xC74 # float[8] + m_bDontIncrementCoopWave = 0xC94 # bool + m_bSpawnedTerrorHuntHeavy = 0xC95 # bool + m_nEndMatchMapGroupVoteTypes = 0xC98 # int32_t[10] + m_nEndMatchMapGroupVoteOptions = 0xCC0 # int32_t[10] + m_nEndMatchMapVoteWinner = 0xCE8 # int32_t + m_iNumConsecutiveCTLoses = 0xCEC # int32_t + m_iNumConsecutiveTerroristLoses = 0xCF0 # int32_t + m_bMarkClientStopRecordAtRoundEnd = 0xD10 # bool + m_bMatchAbortedDueToPlayerBan = 0xD68 # bool + m_bHasTriggeredRoundStartMusic = 0xD69 # bool + m_bHasTriggeredCoopSpawnReset = 0xD6A # bool + m_bSwitchingTeamsAtRoundReset = 0xD6B # bool + m_pGameModeRules = 0xD88 # CCSGameModeRules* + m_RetakeRules = 0xD90 # C_RetakeGameRules + m_nMatchEndCount = 0xEA8 # uint8_t + m_nTTeamIntroVariant = 0xEAC # int32_t + m_nCTTeamIntroVariant = 0xEB0 # int32_t + m_bTeamIntroPeriod = 0xEB4 # bool + m_flLastPerfSampleTime = 0x4EC0 # double + +class C_CSGameRulesProxy: + m_pGameRules = 0x540 # C_CSGameRules* + +class C_CSObserverPawn: + m_hDetectParentChange = 0x16A0 # CEntityHandle + +class C_CSPlayerPawn: + m_pBulletServices = 0x16A0 # CCSPlayer_BulletServices* + m_pHostageServices = 0x16A8 # CCSPlayer_HostageServices* + m_pBuyServices = 0x16B0 # CCSPlayer_BuyServices* + m_pGlowServices = 0x16B8 # CCSPlayer_GlowServices* + m_pActionTrackingServices = 0x16C0 # CCSPlayer_ActionTrackingServices* + m_flHealthShotBoostExpirationTime = 0x16C8 # GameTime_t + m_flLastFiredWeaponTime = 0x16CC # GameTime_t + m_bHasFemaleVoice = 0x16D0 # bool + m_flLandseconds = 0x16D4 # float + m_flOldFallVelocity = 0x16D8 # float + m_szLastPlaceName = 0x16DC # char[18] + m_bPrevDefuser = 0x16EE # bool + m_bPrevHelmet = 0x16EF # bool + m_nPrevArmorVal = 0x16F0 # int32_t + m_nPrevGrenadeAmmoCount = 0x16F4 # int32_t + m_unPreviousWeaponHash = 0x16F8 # uint32_t + m_unWeaponHash = 0x16FC # uint32_t + m_bInBuyZone = 0x1700 # bool + m_bPreviouslyInBuyZone = 0x1701 # bool + m_aimPunchAngle = 0x1704 # QAngle + m_aimPunchAngleVel = 0x1710 # QAngle + m_aimPunchTickBase = 0x171C # int32_t + m_aimPunchTickFraction = 0x1720 # float + m_aimPunchCache = 0x1728 # CUtlVector + m_bInLanding = 0x1748 # bool + m_flLandingTime = 0x174C # float + m_bInHostageRescueZone = 0x1750 # bool + m_bInBombZone = 0x1751 # bool + m_bIsBuyMenuOpen = 0x1752 # bool + m_flTimeOfLastInjury = 0x1754 # GameTime_t + m_flNextSprayDecalTime = 0x1758 # GameTime_t + m_iRetakesOffering = 0x1870 # int32_t + m_iRetakesOfferingCard = 0x1874 # int32_t + m_bRetakesHasDefuseKit = 0x1878 # bool + m_bRetakesMVPLastRound = 0x1879 # bool + m_iRetakesMVPBoostItem = 0x187C # int32_t + m_RetakesMVPBoostExtraUtility = 0x1880 # loadout_slot_t + m_bNeedToReApplyGloves = 0x18A0 # bool + m_EconGloves = 0x18A8 # C_EconItemView + m_bMustSyncRagdollState = 0x1CF0 # bool + m_nRagdollDamageBone = 0x1CF4 # int32_t + m_vRagdollDamageForce = 0x1CF8 # Vector + m_vRagdollDamagePosition = 0x1D04 # Vector + m_szRagdollDamageWeaponName = 0x1D10 # char[64] + m_bRagdollDamageHeadshot = 0x1D50 # bool + m_bLastHeadBoneTransformIsValid = 0x2290 # bool + m_lastLandTime = 0x2294 # GameTime_t + m_bOnGroundLastTick = 0x2298 # bool + m_qDeathEyeAngles = 0x22B4 # QAngle + m_bSkipOneHeadConstraintUpdate = 0x22C0 # bool + +class C_CSPlayerPawnBase: + m_pPingServices = 0x1250 # CCSPlayer_PingServices* + m_pViewModelServices = 0x1258 # CPlayer_ViewModelServices* + m_fRenderingClipPlane = 0x1260 # float[4] + m_nLastClipPlaneSetupFrame = 0x1270 # int32_t + m_vecLastClipCameraPos = 0x1274 # Vector + m_vecLastClipCameraForward = 0x1280 # Vector + m_bClipHitStaticWorld = 0x128C # bool + m_bCachedPlaneIsValid = 0x128D # bool + m_pClippingWeapon = 0x1290 # C_CSWeaponBase* + m_previousPlayerState = 0x1298 # CSPlayerState + m_flLastCollisionCeiling = 0x129C # float + m_flLastCollisionCeilingChangeTime = 0x12A0 # float + m_grenadeParameterStashTime = 0x12C0 # GameTime_t + m_bGrenadeParametersStashed = 0x12C4 # bool + m_angStashedShootAngles = 0x12C8 # QAngle + m_vecStashedGrenadeThrowPosition = 0x12D4 # Vector + m_vecStashedVelocity = 0x12E0 # Vector + m_angShootAngleHistory = 0x12EC # QAngle[2] + m_vecThrowPositionHistory = 0x1304 # Vector[2] + m_vecVelocityHistory = 0x131C # Vector[2] + m_thirdPersonHeading = 0x1338 # QAngle + m_flSlopeDropOffset = 0x1350 # float + m_flSlopeDropHeight = 0x1360 # float + m_vHeadConstraintOffset = 0x1370 # Vector + m_bIsScoped = 0x1388 # bool + m_bIsWalking = 0x1389 # bool + m_bResumeZoom = 0x138A # bool + m_iPlayerState = 0x138C # CSPlayerState + m_bIsDefusing = 0x1390 # bool + m_bIsGrabbingHostage = 0x1391 # bool + m_iBlockingUseActionInProgress = 0x1394 # CSPlayerBlockingUseAction_t + m_bIsRescuing = 0x1398 # bool + m_fImmuneToGunGameDamageTime = 0x139C # GameTime_t + m_fImmuneToGunGameDamageTimeLast = 0x13A0 # GameTime_t + m_bGunGameImmunity = 0x13A4 # bool + m_bHasMovedSinceSpawn = 0x13A5 # bool + m_unTotalRoundDamageDealt = 0x13A8 # uint32_t + m_fMolotovUseTime = 0x13AC # float + m_fMolotovDamageTime = 0x13B0 # float + m_nWhichBombZone = 0x13B4 # int32_t + m_bInNoDefuseArea = 0x13B8 # bool + m_iThrowGrenadeCounter = 0x13BC # int32_t + m_bWaitForNoAttack = 0x13C0 # bool + m_flGuardianTooFarDistFrac = 0x13C4 # float + m_flDetectedByEnemySensorTime = 0x13C8 # GameTime_t + m_flNextGuardianTooFarWarning = 0x13CC # float + m_bSuppressGuardianTooFarWarningAudio = 0x13D0 # bool + m_bKilledByTaser = 0x13D1 # bool + m_iMoveState = 0x13D4 # int32_t + m_bCanMoveDuringFreezePeriod = 0x13D8 # bool + m_flLowerBodyYawTarget = 0x13DC # float + m_bStrafing = 0x13E0 # bool + m_flLastSpawnTimeIndex = 0x13E4 # GameTime_t + m_flEmitSoundTime = 0x13E8 # GameTime_t + m_iAddonBits = 0x13EC # int32_t + m_iPrimaryAddon = 0x13F0 # int32_t + m_iSecondaryAddon = 0x13F4 # int32_t + m_iProgressBarDuration = 0x13F8 # int32_t + m_flProgressBarStartTime = 0x13FC # float + m_iDirection = 0x1400 # int32_t + m_iShotsFired = 0x1404 # int32_t + m_bNightVisionOn = 0x1408 # bool + m_bHasNightVision = 0x1409 # bool + m_flVelocityModifier = 0x140C # float + m_flHitHeading = 0x1410 # float + m_nHitBodyPart = 0x1414 # int32_t + m_iStartAccount = 0x1418 # int32_t + m_vecIntroStartEyePosition = 0x141C # Vector + m_vecIntroStartPlayerForward = 0x1428 # Vector + m_flClientDeathTime = 0x1434 # GameTime_t + m_flNightVisionAlpha = 0x1438 # float + m_bScreenTearFrameCaptured = 0x143C # bool + m_flFlashBangTime = 0x1440 # float + m_flFlashScreenshotAlpha = 0x1444 # float + m_flFlashOverlayAlpha = 0x1448 # float + m_bFlashBuildUp = 0x144C # bool + m_bFlashDspHasBeenCleared = 0x144D # bool + m_bFlashScreenshotHasBeenGrabbed = 0x144E # bool + m_flFlashMaxAlpha = 0x1450 # float + m_flFlashDuration = 0x1454 # float + m_lastStandingPos = 0x1458 # Vector + m_vecLastMuzzleFlashPos = 0x1464 # Vector + m_angLastMuzzleFlashAngle = 0x1470 # QAngle + m_hMuzzleFlashShape = 0x147C # CHandle + m_iHealthBarRenderMaskIndex = 0x1480 # int32_t + m_flHealthFadeValue = 0x1484 # float + m_flHealthFadeAlpha = 0x1488 # float + m_nMyCollisionGroup = 0x148C # int32_t + m_ignoreLadderJumpTime = 0x1490 # float + m_ladderSurpressionTimer = 0x1498 # CountdownTimer + m_lastLadderNormal = 0x14B0 # Vector + m_lastLadderPos = 0x14BC # Vector + m_flDeathCCWeight = 0x14D0 # float + m_bOldIsScoped = 0x14D4 # bool + m_flPrevRoundEndTime = 0x14D8 # float + m_flPrevMatchEndTime = 0x14DC # float + m_unCurrentEquipmentValue = 0x14E0 # uint16_t + m_unRoundStartEquipmentValue = 0x14E2 # uint16_t + m_unFreezetimeEndEquipmentValue = 0x14E4 # uint16_t + m_vecThirdPersonViewPositionOverride = 0x14E8 # Vector + m_nHeavyAssaultSuitCooldownRemaining = 0x14F4 # int32_t + m_ArmorValue = 0x14F8 # int32_t + m_angEyeAngles = 0x1500 # QAngle + m_fNextThinkPushAway = 0x1518 # float + m_bShouldAutobuyDMWeapons = 0x151C # bool + m_bShouldAutobuyNow = 0x151D # bool + m_bHud_MiniScoreHidden = 0x151E # bool + m_bHud_RadarHidden = 0x151F # bool + m_nLastKillerIndex = 0x1520 # CEntityIndex + m_nLastConcurrentKilled = 0x1524 # int32_t + m_nDeathCamMusic = 0x1528 # int32_t + m_iIDEntIndex = 0x152C # CEntityIndex + m_delayTargetIDTimer = 0x1530 # CountdownTimer + m_iTargetedWeaponEntIndex = 0x1548 # CEntityIndex + m_iOldIDEntIndex = 0x154C # CEntityIndex + m_holdTargetIDTimer = 0x1550 # CountdownTimer + m_flCurrentMusicStartTime = 0x156C # float + m_flMusicRoundStartTime = 0x1570 # float + m_bDeferStartMusicOnWarmup = 0x1574 # bool + m_cycleLatch = 0x1578 # int32_t + m_serverIntendedCycle = 0x157C # float + m_vecPlayerPatchEconIndices = 0x1580 # uint32_t[5] + m_bHideTargetID = 0x159C # bool + m_nextTaserShakeTime = 0x15A0 # float + m_firstTaserShakeTime = 0x15A4 # float + m_flLastSmokeOverlayAlpha = 0x15A8 # float + m_vLastSmokeOverlayColor = 0x15AC # Vector + m_nPlayerSmokedFx = 0x15B8 # ParticleIndex_t + m_flNextMagDropTime = 0x15BC # float + m_nLastMagDropAttachmentIndex = 0x15C0 # int32_t + m_vecBulletHitModels = 0x15C8 # CUtlVector + m_vecPickupModelSlerpers = 0x15E0 # CUtlVector + m_vecLastAliveLocalVelocity = 0x15F8 # Vector + m_entitySpottedState = 0x1620 # EntitySpottedState_t + m_nSurvivalTeamNumber = 0x1638 # int32_t + m_bGuardianShouldSprayCustomXMark = 0x163C # bool + m_bHasDeathInfo = 0x163D # bool + m_flDeathInfoTime = 0x1640 # float + m_vecDeathInfoOrigin = 0x1644 # Vector + m_bKilledByHeadshot = 0x1650 # bool + m_hOriginalController = 0x1654 # CHandle + +class C_CSPlayerResource: + m_bHostageAlive = 0x540 # bool[12] + m_isHostageFollowingSomeone = 0x54C # bool[12] + m_iHostageEntityIDs = 0x558 # CEntityIndex[12] + m_bombsiteCenterA = 0x588 # Vector + m_bombsiteCenterB = 0x594 # Vector + m_hostageRescueX = 0x5A0 # int32_t[4] + m_hostageRescueY = 0x5B0 # int32_t[4] + m_hostageRescueZ = 0x5C0 # int32_t[4] + m_bEndMatchNextMapAllVoted = 0x5D0 # bool + m_foundGoalPositions = 0x5D1 # bool + +class C_CSTeam: + m_szTeamMatchStat = 0x5F8 # char[512] + m_numMapVictories = 0x7F8 # int32_t + m_bSurrendered = 0x7FC # bool + m_scoreFirstHalf = 0x800 # int32_t + m_scoreSecondHalf = 0x804 # int32_t + m_scoreOvertime = 0x808 # int32_t + m_szClanTeamname = 0x80C # char[129] + m_iClanID = 0x890 # uint32_t + m_szTeamFlagImage = 0x894 # char[8] + m_szTeamLogoImage = 0x89C # char[8] + +class C_CSWeaponBase: + m_flFireSequenceStartTime = 0x15D0 # float + m_nFireSequenceStartTimeChange = 0x15D4 # int32_t + m_nFireSequenceStartTimeAck = 0x15D8 # int32_t + m_bPlayerFireEventIsPrimary = 0x15DC # bool + m_seqIdle = 0x15E0 # HSequence + m_seqFirePrimary = 0x15E4 # HSequence + m_seqFireSecondary = 0x15E8 # HSequence + m_ClientPreviousWeaponState = 0x1600 # CSWeaponState_t + m_iState = 0x1604 # CSWeaponState_t + m_flCrosshairDistance = 0x1608 # float + m_iAmmoLastCheck = 0x160C # int32_t + m_iAlpha = 0x1610 # int32_t + m_iScopeTextureID = 0x1614 # int32_t + m_iCrosshairTextureID = 0x1618 # int32_t + m_flGunAccuracyPosition = 0x161C # float + m_nViewModelIndex = 0x1620 # uint32_t + m_bReloadsWithClips = 0x1624 # bool + m_flTimeWeaponIdle = 0x1628 # GameTime_t + m_bFireOnEmpty = 0x162C # bool + m_OnPlayerPickup = 0x1630 # CEntityIOOutput + m_weaponMode = 0x1658 # CSWeaponMode + m_flTurningInaccuracyDelta = 0x165C # float + m_vecTurningInaccuracyEyeDirLast = 0x1660 # Vector + m_flTurningInaccuracy = 0x166C # float + m_fAccuracyPenalty = 0x1670 # float + m_flLastAccuracyUpdateTime = 0x1674 # GameTime_t + m_fAccuracySmoothedForZoom = 0x1678 # float + m_fScopeZoomEndTime = 0x167C # GameTime_t + m_iRecoilIndex = 0x1680 # int32_t + m_flRecoilIndex = 0x1684 # float + m_bBurstMode = 0x1688 # bool + m_flPostponeFireReadyTime = 0x168C # GameTime_t + m_bInReload = 0x1690 # bool + m_bReloadVisuallyComplete = 0x1691 # bool + m_flDroppedAtTime = 0x1694 # GameTime_t + m_bIsHauledBack = 0x1698 # bool + m_bSilencerOn = 0x1699 # bool + m_flTimeSilencerSwitchComplete = 0x169C # GameTime_t + m_iOriginalTeamNumber = 0x16A0 # int32_t + m_flNextAttackRenderTimeOffset = 0x16A4 # float + m_bVisualsDataSet = 0x1720 # bool + m_bOldFirstPersonSpectatedState = 0x1721 # bool + m_hOurPing = 0x1724 # CHandle + m_nOurPingIndex = 0x1728 # CEntityIndex + m_vecOurPingPos = 0x172C # Vector + m_bGlowForPing = 0x1738 # bool + m_bUIWeapon = 0x1739 # bool + m_hPrevOwner = 0x1748 # CHandle + m_nDropTick = 0x174C # GameTick_t + m_donated = 0x176C # bool + m_fLastShotTime = 0x1770 # GameTime_t + m_bWasOwnedByCT = 0x1774 # bool + m_bWasOwnedByTerrorist = 0x1775 # bool + m_gunHeat = 0x1778 # float + m_smokeAttachments = 0x177C # uint32_t + m_lastSmokeTime = 0x1780 # GameTime_t + m_flLastClientFireBulletTime = 0x1784 # float + m_IronSightController = 0x1840 # C_IronSightController + m_iIronSightMode = 0x18F0 # int32_t + m_flLastLOSTraceFailureTime = 0x1900 # GameTime_t + m_iNumEmptyAttacks = 0x1904 # int32_t + +class C_CSWeaponBaseGun: + m_zoomLevel = 0x1940 # int32_t + m_iBurstShotsRemaining = 0x1944 # int32_t + m_iSilencerBodygroup = 0x1948 # int32_t + m_silencedModelIndex = 0x1958 # int32_t + m_inPrecache = 0x195C # bool + m_bNeedsBoltAction = 0x195D # bool + +class C_Chicken: + m_hHolidayHatAddon = 0x10F0 # CHandle + m_jumpedThisFrame = 0x10F4 # bool + m_leader = 0x10F8 # CHandle + m_AttributeManager = 0x1100 # C_AttributeContainer + m_OriginalOwnerXuidLow = 0x15A8 # uint32_t + m_OriginalOwnerXuidHigh = 0x15AC # uint32_t + m_bAttributesInitialized = 0x15B0 # bool + m_hWaterWakeParticles = 0x15B4 # ParticleIndex_t + +class C_ClientRagdoll: + m_bFadeOut = 0xE80 # bool + m_bImportant = 0xE81 # bool + m_flEffectTime = 0xE84 # GameTime_t + m_gibDespawnTime = 0xE88 # GameTime_t + m_iCurrentFriction = 0xE8C # int32_t + m_iMinFriction = 0xE90 # int32_t + m_iMaxFriction = 0xE94 # int32_t + m_iFrictionAnimState = 0xE98 # int32_t + m_bReleaseRagdoll = 0xE9C # bool + m_iEyeAttachment = 0xE9D # AttachmentHandle_t + m_bFadingOut = 0xE9E # bool + m_flScaleEnd = 0xEA0 # float[10] + m_flScaleTimeStart = 0xEC8 # GameTime_t[10] + m_flScaleTimeEnd = 0xEF0 # GameTime_t[10] + +class C_ColorCorrection: + m_vecOrigin = 0x540 # Vector + m_MinFalloff = 0x54C # float + m_MaxFalloff = 0x550 # float + m_flFadeInDuration = 0x554 # float + m_flFadeOutDuration = 0x558 # float + m_flMaxWeight = 0x55C # float + m_flCurWeight = 0x560 # float + m_netlookupFilename = 0x564 # char[512] + m_bEnabled = 0x764 # bool + m_bMaster = 0x765 # bool + m_bClientSide = 0x766 # bool + m_bExclusive = 0x767 # bool + m_bEnabledOnClient = 0x768 # bool[1] + m_flCurWeightOnClient = 0x76C # float[1] + m_bFadingIn = 0x770 # bool[1] + m_flFadeStartWeight = 0x774 # float[1] + m_flFadeStartTime = 0x778 # float[1] + m_flFadeDuration = 0x77C # float[1] + +class C_ColorCorrectionVolume: + m_LastEnterWeight = 0xCC8 # float + m_LastEnterTime = 0xCCC # float + m_LastExitWeight = 0xCD0 # float + m_LastExitTime = 0xCD4 # float + m_bEnabled = 0xCD8 # bool + m_MaxWeight = 0xCDC # float + m_FadeDuration = 0xCE0 # float + m_Weight = 0xCE4 # float + m_lookupFilename = 0xCE8 # char[512] + +class C_CommandContext: + needsprocessing = 0x0 # bool + command_number = 0x78 # int32_t + +class C_CsmFovOverride: + m_cameraName = 0x540 # CUtlString + m_flCsmFovOverrideValue = 0x548 # float + +class C_DecoyProjectile: + m_flTimeParticleEffectSpawn = 0x1110 # GameTime_t + +class C_DynamicLight: + m_Flags = 0xCC0 # uint8_t + m_LightStyle = 0xCC1 # uint8_t + m_Radius = 0xCC4 # float + m_Exponent = 0xCC8 # int32_t + m_InnerAngle = 0xCCC # float + m_OuterAngle = 0xCD0 # float + m_SpotRadius = 0xCD4 # float + +class C_DynamicProp: + m_bUseHitboxesForRenderBox = 0xFD0 # bool + m_bUseAnimGraph = 0xFD1 # bool + m_pOutputAnimBegun = 0xFD8 # CEntityIOOutput + m_pOutputAnimOver = 0x1000 # CEntityIOOutput + m_pOutputAnimLoopCycleOver = 0x1028 # CEntityIOOutput + m_OnAnimReachedStart = 0x1050 # CEntityIOOutput + m_OnAnimReachedEnd = 0x1078 # CEntityIOOutput + m_iszDefaultAnim = 0x10A0 # CUtlSymbolLarge + m_nDefaultAnimLoopMode = 0x10A8 # AnimLoopMode_t + m_bAnimateOnServer = 0x10AC # bool + m_bRandomizeCycle = 0x10AD # bool + m_bStartDisabled = 0x10AE # bool + m_bScriptedMovement = 0x10AF # bool + m_bFiredStartEndOutput = 0x10B0 # bool + m_bForceNpcExclude = 0x10B1 # bool + m_bCreateNonSolid = 0x10B2 # bool + m_bIsOverrideProp = 0x10B3 # bool + m_iInitialGlowState = 0x10B4 # int32_t + m_nGlowRange = 0x10B8 # int32_t + m_nGlowRangeMin = 0x10BC # int32_t + m_glowColor = 0x10C0 # Color + m_nGlowTeam = 0x10C4 # int32_t + m_iCachedFrameCount = 0x10C8 # int32_t + m_vecCachedRenderMins = 0x10CC # Vector + m_vecCachedRenderMaxs = 0x10D8 # Vector + +class C_EconEntity: + m_flFlexDelayTime = 0x1028 # float + m_flFlexDelayedWeight = 0x1030 # float* + m_bAttributesInitialized = 0x1038 # bool + m_AttributeManager = 0x1040 # C_AttributeContainer + m_OriginalOwnerXuidLow = 0x14E8 # uint32_t + m_OriginalOwnerXuidHigh = 0x14EC # uint32_t + m_nFallbackPaintKit = 0x14F0 # int32_t + m_nFallbackSeed = 0x14F4 # int32_t + m_flFallbackWear = 0x14F8 # float + m_nFallbackStatTrak = 0x14FC # int32_t + m_bClientside = 0x1500 # bool + m_bParticleSystemsCreated = 0x1501 # bool + m_vecAttachedParticles = 0x1508 # CUtlVector + m_hViewmodelAttachment = 0x1520 # CHandle + m_iOldTeam = 0x1524 # int32_t + m_bAttachmentDirty = 0x1528 # bool + m_nUnloadedModelIndex = 0x152C # int32_t + m_iNumOwnerValidationRetries = 0x1530 # int32_t + m_hOldProvidee = 0x1540 # CHandle + m_vecAttachedModels = 0x1548 # CUtlVector + +class C_EconEntity_AttachedModelData_t: + m_iModelDisplayFlags = 0x0 # int32_t + +class C_EconItemView: + m_bInventoryImageRgbaRequested = 0x60 # bool + m_bInventoryImageTriedCache = 0x61 # bool + m_nInventoryImageRgbaWidth = 0x80 # int32_t + m_nInventoryImageRgbaHeight = 0x84 # int32_t + m_szCurrentLoadCachedFileName = 0x88 # char[260] + m_bRestoreCustomMaterialAfterPrecache = 0x1B8 # bool + m_iItemDefinitionIndex = 0x1BA # uint16_t + m_iEntityQuality = 0x1BC # int32_t + m_iEntityLevel = 0x1C0 # uint32_t + m_iItemID = 0x1C8 # uint64_t + m_iItemIDHigh = 0x1D0 # uint32_t + m_iItemIDLow = 0x1D4 # uint32_t + m_iAccountID = 0x1D8 # uint32_t + m_iInventoryPosition = 0x1DC # uint32_t + m_bInitialized = 0x1E8 # bool + m_bIsStoreItem = 0x1E9 # bool + m_bIsTradeItem = 0x1EA # bool + m_iEntityQuantity = 0x1EC # int32_t + m_iRarityOverride = 0x1F0 # int32_t + m_iQualityOverride = 0x1F4 # int32_t + m_unClientFlags = 0x1F8 # uint8_t + m_unOverrideStyle = 0x1F9 # uint8_t + m_AttributeList = 0x210 # CAttributeList + m_NetworkedDynamicAttributes = 0x270 # CAttributeList + m_szCustomName = 0x2D0 # char[161] + m_szCustomNameOverride = 0x371 # char[161] + m_bInitializedTags = 0x440 # bool + +class C_EconWearable: + m_nForceSkin = 0x1560 # int32_t + m_bAlwaysAllow = 0x1564 # bool + +class C_EntityDissolve: + m_flStartTime = 0xCC8 # GameTime_t + m_flFadeInStart = 0xCCC # float + m_flFadeInLength = 0xCD0 # float + m_flFadeOutModelStart = 0xCD4 # float + m_flFadeOutModelLength = 0xCD8 # float + m_flFadeOutStart = 0xCDC # float + m_flFadeOutLength = 0xCE0 # float + m_flNextSparkTime = 0xCE4 # GameTime_t + m_nDissolveType = 0xCE8 # EntityDisolveType_t + m_vDissolverOrigin = 0xCEC # Vector + m_nMagnitude = 0xCF8 # uint32_t + m_bCoreExplode = 0xCFC # bool + m_bLinkedToServerEnt = 0xCFD # bool + +class C_EntityFlame: + m_hEntAttached = 0x540 # CHandle + m_hOldAttached = 0x568 # CHandle + m_bCheapEffect = 0x56C # bool + +class C_EnvCombinedLightProbeVolume: + m_Color = 0x15A8 # Color + m_flBrightness = 0x15AC # float + m_hCubemapTexture = 0x15B0 # CStrongHandle + m_bCustomCubemapTexture = 0x15B8 # bool + m_hLightProbeTexture = 0x15C0 # CStrongHandle + m_hLightProbeDirectLightIndicesTexture = 0x15C8 # CStrongHandle + m_hLightProbeDirectLightScalarsTexture = 0x15D0 # CStrongHandle + m_hLightProbeDirectLightShadowsTexture = 0x15D8 # CStrongHandle + m_vBoxMins = 0x15E0 # Vector + m_vBoxMaxs = 0x15EC # Vector + m_LightGroups = 0x15F8 # CUtlSymbolLarge + m_bMoveable = 0x1600 # bool + m_nHandshake = 0x1604 # int32_t + m_nEnvCubeMapArrayIndex = 0x1608 # int32_t + m_nPriority = 0x160C # int32_t + m_bStartDisabled = 0x1610 # bool + m_flEdgeFadeDist = 0x1614 # float + m_vEdgeFadeDists = 0x1618 # Vector + m_nLightProbeSizeX = 0x1624 # int32_t + m_nLightProbeSizeY = 0x1628 # int32_t + m_nLightProbeSizeZ = 0x162C # int32_t + m_nLightProbeAtlasX = 0x1630 # int32_t + m_nLightProbeAtlasY = 0x1634 # int32_t + m_nLightProbeAtlasZ = 0x1638 # int32_t + m_bEnabled = 0x1651 # bool + +class C_EnvCubemap: + m_hCubemapTexture = 0x5C8 # CStrongHandle + m_bCustomCubemapTexture = 0x5D0 # bool + m_flInfluenceRadius = 0x5D4 # float + m_vBoxProjectMins = 0x5D8 # Vector + m_vBoxProjectMaxs = 0x5E4 # Vector + m_LightGroups = 0x5F0 # CUtlSymbolLarge + m_bMoveable = 0x5F8 # bool + m_nHandshake = 0x5FC # int32_t + m_nEnvCubeMapArrayIndex = 0x600 # int32_t + m_nPriority = 0x604 # int32_t + m_flEdgeFadeDist = 0x608 # float + m_vEdgeFadeDists = 0x60C # Vector + m_flDiffuseScale = 0x618 # float + m_bStartDisabled = 0x61C # bool + m_bDefaultEnvMap = 0x61D # bool + m_bDefaultSpecEnvMap = 0x61E # bool + m_bIndoorCubeMap = 0x61F # bool + m_bCopyDiffuseFromDefaultCubemap = 0x620 # bool + m_bEnabled = 0x630 # bool + +class C_EnvCubemapFog: + m_flEndDistance = 0x540 # float + m_flStartDistance = 0x544 # float + m_flFogFalloffExponent = 0x548 # float + m_bHeightFogEnabled = 0x54C # bool + m_flFogHeightWidth = 0x550 # float + m_flFogHeightEnd = 0x554 # float + m_flFogHeightStart = 0x558 # float + m_flFogHeightExponent = 0x55C # float + m_flLODBias = 0x560 # float + m_bActive = 0x564 # bool + m_bStartDisabled = 0x565 # bool + m_flFogMaxOpacity = 0x568 # float + m_nCubemapSourceType = 0x56C # int32_t + m_hSkyMaterial = 0x570 # CStrongHandle + m_iszSkyEntity = 0x578 # CUtlSymbolLarge + m_hFogCubemapTexture = 0x580 # CStrongHandle + m_bHasHeightFogEnd = 0x588 # bool + m_bFirstTime = 0x589 # bool + +class C_EnvDecal: + m_hDecalMaterial = 0xCC0 # CStrongHandle + m_flWidth = 0xCC8 # float + m_flHeight = 0xCCC # float + m_flDepth = 0xCD0 # float + m_nRenderOrder = 0xCD4 # uint32_t + m_bProjectOnWorld = 0xCD8 # bool + m_bProjectOnCharacters = 0xCD9 # bool + m_bProjectOnWater = 0xCDA # bool + m_flDepthSortBias = 0xCDC # float + +class C_EnvDetailController: + m_flFadeStartDist = 0x540 # float + m_flFadeEndDist = 0x544 # float + +class C_EnvLightProbeVolume: + m_hLightProbeTexture = 0x1520 # CStrongHandle + m_hLightProbeDirectLightIndicesTexture = 0x1528 # CStrongHandle + m_hLightProbeDirectLightScalarsTexture = 0x1530 # CStrongHandle + m_hLightProbeDirectLightShadowsTexture = 0x1538 # CStrongHandle + m_vBoxMins = 0x1540 # Vector + m_vBoxMaxs = 0x154C # Vector + m_LightGroups = 0x1558 # CUtlSymbolLarge + m_bMoveable = 0x1560 # bool + m_nHandshake = 0x1564 # int32_t + m_nPriority = 0x1568 # int32_t + m_bStartDisabled = 0x156C # bool + m_nLightProbeSizeX = 0x1570 # int32_t + m_nLightProbeSizeY = 0x1574 # int32_t + m_nLightProbeSizeZ = 0x1578 # int32_t + m_nLightProbeAtlasX = 0x157C # int32_t + m_nLightProbeAtlasY = 0x1580 # int32_t + m_nLightProbeAtlasZ = 0x1584 # int32_t + m_bEnabled = 0x1591 # bool + +class C_EnvParticleGlow: + m_flAlphaScale = 0x1270 # float + m_flRadiusScale = 0x1274 # float + m_flSelfIllumScale = 0x1278 # float + m_ColorTint = 0x127C # Color + m_hTextureOverride = 0x1280 # CStrongHandle + +class C_EnvScreenOverlay: + m_iszOverlayNames = 0x540 # CUtlSymbolLarge[10] + m_flOverlayTimes = 0x590 # float[10] + m_flStartTime = 0x5B8 # GameTime_t + m_iDesiredOverlay = 0x5BC # int32_t + m_bIsActive = 0x5C0 # bool + m_bWasActive = 0x5C1 # bool + m_iCachedDesiredOverlay = 0x5C4 # int32_t + m_iCurrentOverlay = 0x5C8 # int32_t + m_flCurrentOverlayTime = 0x5CC # GameTime_t + +class C_EnvSky: + m_hSkyMaterial = 0xCC0 # CStrongHandle + m_hSkyMaterialLightingOnly = 0xCC8 # CStrongHandle + m_bStartDisabled = 0xCD0 # bool + m_vTintColor = 0xCD1 # Color + m_vTintColorLightingOnly = 0xCD5 # Color + m_flBrightnessScale = 0xCDC # float + m_nFogType = 0xCE0 # int32_t + m_flFogMinStart = 0xCE4 # float + m_flFogMinEnd = 0xCE8 # float + m_flFogMaxStart = 0xCEC # float + m_flFogMaxEnd = 0xCF0 # float + m_bEnabled = 0xCF4 # bool + +class C_EnvVolumetricFogController: + m_flScattering = 0x540 # float + m_flAnisotropy = 0x544 # float + m_flFadeSpeed = 0x548 # float + m_flDrawDistance = 0x54C # float + m_flFadeInStart = 0x550 # float + m_flFadeInEnd = 0x554 # float + m_flIndirectStrength = 0x558 # float + m_nIndirectTextureDimX = 0x55C # int32_t + m_nIndirectTextureDimY = 0x560 # int32_t + m_nIndirectTextureDimZ = 0x564 # int32_t + m_vBoxMins = 0x568 # Vector + m_vBoxMaxs = 0x574 # Vector + m_bActive = 0x580 # bool + m_flStartAnisoTime = 0x584 # GameTime_t + m_flStartScatterTime = 0x588 # GameTime_t + m_flStartDrawDistanceTime = 0x58C # GameTime_t + m_flStartAnisotropy = 0x590 # float + m_flStartScattering = 0x594 # float + m_flStartDrawDistance = 0x598 # float + m_flDefaultAnisotropy = 0x59C # float + m_flDefaultScattering = 0x5A0 # float + m_flDefaultDrawDistance = 0x5A4 # float + m_bStartDisabled = 0x5A8 # bool + m_bEnableIndirect = 0x5A9 # bool + m_bIsMaster = 0x5AA # bool + m_hFogIndirectTexture = 0x5B0 # CStrongHandle + m_nForceRefreshCount = 0x5B8 # int32_t + m_bFirstTime = 0x5BC # bool + +class C_EnvVolumetricFogVolume: + m_bActive = 0x540 # bool + m_vBoxMins = 0x544 # Vector + m_vBoxMaxs = 0x550 # Vector + m_bStartDisabled = 0x55C # bool + m_flStrength = 0x560 # float + m_nFalloffShape = 0x564 # int32_t + m_flFalloffExponent = 0x568 # float + +class C_EnvWind: + m_EnvWindShared = 0x540 # C_EnvWindShared + +class C_EnvWindClientside: + m_EnvWindShared = 0x540 # C_EnvWindShared + +class C_EnvWindShared: + m_flStartTime = 0x8 # GameTime_t + m_iWindSeed = 0xC # uint32_t + m_iMinWind = 0x10 # uint16_t + m_iMaxWind = 0x12 # uint16_t + m_windRadius = 0x14 # int32_t + m_iMinGust = 0x18 # uint16_t + m_iMaxGust = 0x1A # uint16_t + m_flMinGustDelay = 0x1C # float + m_flMaxGustDelay = 0x20 # float + m_flGustDuration = 0x24 # float + m_iGustDirChange = 0x28 # uint16_t + m_location = 0x2C # Vector + m_iszGustSound = 0x38 # int32_t + m_iWindDir = 0x3C # int32_t + m_flWindSpeed = 0x40 # float + m_currentWindVector = 0x44 # Vector + m_CurrentSwayVector = 0x50 # Vector + m_PrevSwayVector = 0x5C # Vector + m_iInitialWindDir = 0x68 # uint16_t + m_flInitialWindSpeed = 0x6C # float + m_flVariationTime = 0x70 # GameTime_t + m_flSwayTime = 0x74 # GameTime_t + m_flSimTime = 0x78 # GameTime_t + m_flSwitchTime = 0x7C # GameTime_t + m_flAveWindSpeed = 0x80 # float + m_bGusting = 0x84 # bool + m_flWindAngleVariation = 0x88 # float + m_flWindSpeedVariation = 0x8C # float + m_iEntIndex = 0x90 # CEntityIndex + +class C_EnvWindShared_WindAveEvent_t: + m_flStartWindSpeed = 0x0 # float + m_flAveWindSpeed = 0x4 # float + +class C_EnvWindShared_WindVariationEvent_t: + m_flWindAngleVariation = 0x0 # float + m_flWindSpeedVariation = 0x4 # float + +class C_FireSmoke: + m_nFlameModelIndex = 0x550 # int32_t + m_nFlameFromAboveModelIndex = 0x554 # int32_t + m_flScaleRegister = 0x558 # float + m_flScaleStart = 0x55C # float + m_flScaleEnd = 0x560 # float + m_flScaleTimeStart = 0x564 # GameTime_t + m_flScaleTimeEnd = 0x568 # GameTime_t + m_flChildFlameSpread = 0x56C # float + m_flClipPerc = 0x580 # float + m_bClipTested = 0x584 # bool + m_bFadingOut = 0x585 # bool + m_tParticleSpawn = 0x588 # TimedEvent + m_pFireOverlay = 0x590 # CFireOverlay* + +class C_FireSprite: + m_vecMoveDir = 0xDF0 # Vector + m_bFadeFromAbove = 0xDFC # bool + +class C_Fish: + m_pos = 0xE80 # Vector + m_vel = 0xE8C # Vector + m_angles = 0xE98 # QAngle + m_localLifeState = 0xEA4 # int32_t + m_deathDepth = 0xEA8 # float + m_deathAngle = 0xEAC # float + m_buoyancy = 0xEB0 # float + m_wiggleTimer = 0xEB8 # CountdownTimer + m_wigglePhase = 0xED0 # float + m_wiggleRate = 0xED4 # float + m_actualPos = 0xED8 # Vector + m_actualAngles = 0xEE4 # QAngle + m_poolOrigin = 0xEF0 # Vector + m_waterLevel = 0xEFC # float + m_gotUpdate = 0xF00 # bool + m_x = 0xF04 # float + m_y = 0xF08 # float + m_z = 0xF0C # float + m_angle = 0xF10 # float + m_errorHistory = 0xF14 # float[20] + m_errorHistoryIndex = 0xF64 # int32_t + m_errorHistoryCount = 0xF68 # int32_t + m_averageError = 0xF6C # float + +class C_Fists: + m_bPlayingUninterruptableAct = 0x1940 # bool + m_nUninterruptableActivity = 0x1944 # PlayerAnimEvent_t + +class C_FogController: + m_fog = 0x540 # fogparams_t + m_bUseAngles = 0x5A8 # bool + m_iChangedVariables = 0x5AC # int32_t + +class C_FootstepControl: + m_source = 0xCC8 # CUtlSymbolLarge + m_destination = 0xCD0 # CUtlSymbolLarge + +class C_FuncConveyor: + m_vecMoveDirEntitySpace = 0xCC8 # Vector + m_flTargetSpeed = 0xCD4 # float + m_nTransitionStartTick = 0xCD8 # GameTick_t + m_nTransitionDurationTicks = 0xCDC # int32_t + m_flTransitionStartSpeed = 0xCE0 # float + m_hConveyorModels = 0xCE8 # C_NetworkUtlVectorBase> + m_flCurrentConveyorOffset = 0xD00 # float + m_flCurrentConveyorSpeed = 0xD04 # float + +class C_FuncElectrifiedVolume: + m_nAmbientEffect = 0xCC0 # ParticleIndex_t + m_EffectName = 0xCC8 # CUtlSymbolLarge + m_bState = 0xCD0 # bool + +class C_FuncLadder: + m_vecLadderDir = 0xCC0 # Vector + m_Dismounts = 0xCD0 # CUtlVector> + m_vecLocalTop = 0xCE8 # Vector + m_vecPlayerMountPositionTop = 0xCF4 # Vector + m_vecPlayerMountPositionBottom = 0xD00 # Vector + m_flAutoRideSpeed = 0xD0C # float + m_bDisabled = 0xD10 # bool + m_bFakeLadder = 0xD11 # bool + m_bHasSlack = 0xD12 # bool + +class C_FuncMonitor: + m_targetCamera = 0xCC0 # CUtlString + m_nResolutionEnum = 0xCC8 # int32_t + m_bRenderShadows = 0xCCC # bool + m_bUseUniqueColorTarget = 0xCCD # bool + m_brushModelName = 0xCD0 # CUtlString + m_hTargetCamera = 0xCD8 # CHandle + m_bEnabled = 0xCDC # bool + m_bDraw3DSkybox = 0xCDD # bool + +class C_FuncTrackTrain: + m_nLongAxis = 0xCC0 # int32_t + m_flRadius = 0xCC4 # float + m_flLineLength = 0xCC8 # float + +class C_GlobalLight: + m_WindClothForceHandle = 0xA00 # uint16_t + +class C_GradientFog: + m_hGradientFogTexture = 0x540 # CStrongHandle + m_flFogStartDistance = 0x548 # float + m_flFogEndDistance = 0x54C # float + m_bHeightFogEnabled = 0x550 # bool + m_flFogStartHeight = 0x554 # float + m_flFogEndHeight = 0x558 # float + m_flFarZ = 0x55C # float + m_flFogMaxOpacity = 0x560 # float + m_flFogFalloffExponent = 0x564 # float + m_flFogVerticalExponent = 0x568 # float + m_fogColor = 0x56C # Color + m_flFogStrength = 0x570 # float + m_flFadeTime = 0x574 # float + m_bStartDisabled = 0x578 # bool + m_bIsEnabled = 0x579 # bool + m_bGradientFogNeedsTextures = 0x57A # bool + +class C_HandleTest: + m_Handle = 0x540 # CHandle + m_bSendHandle = 0x544 # bool + +class C_Hostage: + m_entitySpottedState = 0x10A8 # EntitySpottedState_t + m_leader = 0x10C0 # CHandle + m_reuseTimer = 0x10C8 # CountdownTimer + m_vel = 0x10E0 # Vector + m_isRescued = 0x10EC # bool + m_jumpedThisFrame = 0x10ED # bool + m_nHostageState = 0x10F0 # int32_t + m_bHandsHaveBeenCut = 0x10F4 # bool + m_hHostageGrabber = 0x10F8 # CHandle + m_fLastGrabTime = 0x10FC # GameTime_t + m_vecGrabbedPos = 0x1100 # Vector + m_flRescueStartTime = 0x110C # GameTime_t + m_flGrabSuccessTime = 0x1110 # GameTime_t + m_flDropStartTime = 0x1114 # GameTime_t + m_flDeadOrRescuedTime = 0x1118 # GameTime_t + m_blinkTimer = 0x1120 # CountdownTimer + m_lookAt = 0x1138 # Vector + m_lookAroundTimer = 0x1148 # CountdownTimer + m_isInit = 0x1160 # bool + m_eyeAttachment = 0x1161 # AttachmentHandle_t + m_chestAttachment = 0x1162 # AttachmentHandle_t + m_pPredictionOwner = 0x1168 # CBasePlayerController* + m_fNewestAlphaThinkTime = 0x1170 # GameTime_t + +class C_Inferno: + m_nfxFireDamageEffect = 0xD00 # ParticleIndex_t + m_fireXDelta = 0xD04 # int32_t[64] + m_fireYDelta = 0xE04 # int32_t[64] + m_fireZDelta = 0xF04 # int32_t[64] + m_fireParentXDelta = 0x1004 # int32_t[64] + m_fireParentYDelta = 0x1104 # int32_t[64] + m_fireParentZDelta = 0x1204 # int32_t[64] + m_bFireIsBurning = 0x1304 # bool[64] + m_BurnNormal = 0x1344 # Vector[64] + m_fireCount = 0x1644 # int32_t + m_nInfernoType = 0x1648 # int32_t + m_nFireLifetime = 0x164C # float + m_bInPostEffectTime = 0x1650 # bool + m_lastFireCount = 0x1654 # int32_t + m_nFireEffectTickBegin = 0x1658 # int32_t + m_drawableCount = 0x8260 # int32_t + m_blosCheck = 0x8264 # bool + m_nlosperiod = 0x8268 # int32_t + m_maxFireHalfWidth = 0x826C # float + m_maxFireHeight = 0x8270 # float + m_minBounds = 0x8274 # Vector + m_maxBounds = 0x8280 # Vector + m_flLastGrassBurnThink = 0x828C # float + +class C_InfoVisibilityBox: + m_nMode = 0x544 # int32_t + m_vBoxSize = 0x548 # Vector + m_bEnabled = 0x554 # bool + +class C_IronSightController: + m_bIronSightAvailable = 0x10 # bool + m_flIronSightAmount = 0x14 # float + m_flIronSightAmountGained = 0x18 # float + m_flIronSightAmountBiased = 0x1C # float + m_flIronSightAmount_Interpolated = 0x20 # float + m_flIronSightAmountGained_Interpolated = 0x24 # float + m_flIronSightAmountBiased_Interpolated = 0x28 # float + m_flInterpolationLastUpdated = 0x2C # float + m_angDeltaAverage = 0x30 # QAngle[8] + m_angViewLast = 0x90 # QAngle + m_vecDotCoords = 0x9C # Vector2D + m_flDotBlur = 0xA4 # float + m_flSpeedRatio = 0xA8 # float + +class C_Item: + m_bShouldGlow = 0x1560 # bool + m_pReticleHintTextName = 0x1561 # char[256] + +class C_ItemDogtags: + m_OwningPlayer = 0x1668 # CHandle + m_KillingPlayer = 0x166C # CHandle + +class C_LightEntity: + m_CLightComponent = 0xCC0 # CLightComponent* + +class C_LightGlow: + m_nHorizontalSize = 0xCC0 # uint32_t + m_nVerticalSize = 0xCC4 # uint32_t + m_nMinDist = 0xCC8 # uint32_t + m_nMaxDist = 0xCCC # uint32_t + m_nOuterMaxDist = 0xCD0 # uint32_t + m_flGlowProxySize = 0xCD4 # float + m_flHDRColorScale = 0xCD8 # float + m_Glow = 0xCE0 # C_LightGlowOverlay + +class C_LightGlowOverlay: + m_vecOrigin = 0xD0 # Vector + m_vecDirection = 0xDC # Vector + m_nMinDist = 0xE8 # int32_t + m_nMaxDist = 0xEC # int32_t + m_nOuterMaxDist = 0xF0 # int32_t + m_bOneSided = 0xF4 # bool + m_bModulateByDot = 0xF5 # bool + +class C_LocalTempEntity: + flags = 0xE98 # int32_t + die = 0xE9C # GameTime_t + m_flFrameMax = 0xEA0 # float + x = 0xEA4 # float + y = 0xEA8 # float + fadeSpeed = 0xEAC # float + bounceFactor = 0xEB0 # float + hitSound = 0xEB4 # int32_t + priority = 0xEB8 # int32_t + tentOffset = 0xEBC # Vector + m_vecTempEntAngVelocity = 0xEC8 # QAngle + tempent_renderamt = 0xED4 # int32_t + m_vecNormal = 0xED8 # Vector + m_flSpriteScale = 0xEE4 # float + m_nFlickerFrame = 0xEE8 # int32_t + m_flFrameRate = 0xEEC # float + m_flFrame = 0xEF0 # float + m_pszImpactEffect = 0xEF8 # char* + m_pszParticleEffect = 0xF00 # char* + m_bParticleCollision = 0xF08 # bool + m_iLastCollisionFrame = 0xF0C # int32_t + m_vLastCollisionOrigin = 0xF10 # Vector + m_vecTempEntVelocity = 0xF1C # Vector + m_vecPrevAbsOrigin = 0xF28 # Vector + m_vecTempEntAcceleration = 0xF34 # Vector + +class C_MapVetoPickController: + m_nDraftType = 0x550 # int32_t + m_nTeamWinningCoinToss = 0x554 # int32_t + m_nTeamWithFirstChoice = 0x558 # int32_t[64] + m_nVoteMapIdsList = 0x658 # int32_t[7] + m_nAccountIDs = 0x674 # int32_t[64] + m_nMapId0 = 0x774 # int32_t[64] + m_nMapId1 = 0x874 # int32_t[64] + m_nMapId2 = 0x974 # int32_t[64] + m_nMapId3 = 0xA74 # int32_t[64] + m_nMapId4 = 0xB74 # int32_t[64] + m_nMapId5 = 0xC74 # int32_t[64] + m_nStartingSide0 = 0xD74 # int32_t[64] + m_nCurrentPhase = 0xE74 # int32_t + m_nPhaseStartTick = 0xE78 # int32_t + m_nPhaseDurationTicks = 0xE7C # int32_t + m_nPostDataUpdateTick = 0xE80 # int32_t + m_bDisabledHud = 0xE84 # bool + +class C_Melee: + m_flThrowAt = 0x1940 # GameTime_t + +class C_MolotovProjectile: + m_bIsIncGrenade = 0x10F0 # bool + +class C_Multimeter: + m_hTargetC4 = 0xE88 # CHandle + +class C_OmniLight: + m_flInnerAngle = 0xF08 # float + m_flOuterAngle = 0xF0C # float + m_bShowLight = 0xF10 # bool + +class C_ParticleSystem: + m_szSnapshotFileName = 0xCC0 # char[512] + m_bActive = 0xEC0 # bool + m_bFrozen = 0xEC1 # bool + m_flFreezeTransitionDuration = 0xEC4 # float + m_nStopType = 0xEC8 # int32_t + m_bAnimateDuringGameplayPause = 0xECC # bool + m_iEffectIndex = 0xED0 # CStrongHandle + m_flStartTime = 0xED8 # GameTime_t + m_flPreSimTime = 0xEDC # float + m_vServerControlPoints = 0xEE0 # Vector[4] + m_iServerControlPointAssignments = 0xF10 # uint8_t[4] + m_hControlPointEnts = 0xF14 # CHandle[64] + m_bNoSave = 0x1014 # bool + m_bNoFreeze = 0x1015 # bool + m_bNoRamp = 0x1016 # bool + m_bStartActive = 0x1017 # bool + m_iszEffectName = 0x1018 # CUtlSymbolLarge + m_iszControlPointNames = 0x1020 # CUtlSymbolLarge[64] + m_nDataCP = 0x1220 # int32_t + m_vecDataCPValue = 0x1224 # Vector + m_nTintCP = 0x1230 # int32_t + m_clrTint = 0x1234 # Color + m_bOldActive = 0x1258 # bool + m_bOldFrozen = 0x1259 # bool + +class C_PathParticleRope: + m_bStartActive = 0x540 # bool + m_flMaxSimulationTime = 0x544 # float + m_iszEffectName = 0x548 # CUtlSymbolLarge + m_PathNodes_Name = 0x550 # CUtlVector + m_flParticleSpacing = 0x568 # float + m_flSlack = 0x56C # float + m_flRadius = 0x570 # float + m_ColorTint = 0x574 # Color + m_nEffectState = 0x578 # int32_t + m_iEffectIndex = 0x580 # CStrongHandle + m_PathNodes_Position = 0x588 # C_NetworkUtlVectorBase + m_PathNodes_TangentIn = 0x5A0 # C_NetworkUtlVectorBase + m_PathNodes_TangentOut = 0x5B8 # C_NetworkUtlVectorBase + m_PathNodes_Color = 0x5D0 # C_NetworkUtlVectorBase + m_PathNodes_PinEnabled = 0x5E8 # C_NetworkUtlVectorBase + m_PathNodes_RadiusScale = 0x600 # C_NetworkUtlVectorBase + +class C_PhysMagnet: + m_aAttachedObjectsFromServer = 0xE80 # CUtlVector + m_aAttachedObjects = 0xE98 # CUtlVector> + +class C_PhysPropClientside: + m_flTouchDelta = 0xFD0 # GameTime_t + m_fDeathTime = 0xFD4 # GameTime_t + m_impactEnergyScale = 0xFD8 # float + m_inertiaScale = 0xFDC # float + m_flDmgModBullet = 0xFE0 # float + m_flDmgModClub = 0xFE4 # float + m_flDmgModExplosive = 0xFE8 # float + m_flDmgModFire = 0xFEC # float + m_iszPhysicsDamageTableName = 0xFF0 # CUtlSymbolLarge + m_iszBasePropData = 0xFF8 # CUtlSymbolLarge + m_iInteractions = 0x1000 # int32_t + m_bHasBreakPiecesOrCommands = 0x1004 # bool + m_vecDamagePosition = 0x1008 # Vector + m_vecDamageDirection = 0x1014 # Vector + m_nDamageType = 0x1020 # int32_t + +class C_PhysicsProp: + m_bAwake = 0xFD0 # bool + +class C_PickUpModelSlerper: + m_hPlayerParent = 0xE80 # CHandle + m_hItem = 0xE84 # CHandle + m_flTimePickedUp = 0xE88 # float + m_angOriginal = 0xE8C # QAngle + m_vecPosOriginal = 0xE98 # Vector + m_angRandom = 0xEA8 # QAngle + +class C_PlantedC4: + m_bBombTicking = 0xE80 # bool + m_nBombSite = 0xE84 # int32_t + m_nSourceSoundscapeHash = 0xE88 # int32_t + m_entitySpottedState = 0xE90 # EntitySpottedState_t + m_flNextGlow = 0xEA8 # GameTime_t + m_flNextBeep = 0xEAC # GameTime_t + m_flC4Blow = 0xEB0 # GameTime_t + m_bCannotBeDefused = 0xEB4 # bool + m_bHasExploded = 0xEB5 # bool + m_flTimerLength = 0xEB8 # float + m_bBeingDefused = 0xEBC # bool + m_bTenSecWarning = 0xEC0 # float + m_bTriggerWarning = 0xEC4 # float + m_bExplodeWarning = 0xEC8 # float + m_bC4Activated = 0xECC # bool + m_flDefuseLength = 0xED0 # float + m_flDefuseCountDown = 0xED4 # GameTime_t + m_bBombDefused = 0xED8 # bool + m_hBombDefuser = 0xEDC # CHandle + m_hControlPanel = 0xEE0 # CHandle + m_hDefuserMultimeter = 0xEE4 # CHandle + m_flNextRadarFlashTime = 0xEE8 # GameTime_t + m_bRadarFlash = 0xEEC # bool + m_pBombDefuser = 0xEF0 # CHandle + m_fLastDefuseTime = 0xEF4 # GameTime_t + m_pPredictionOwner = 0xEF8 # CBasePlayerController* + +class C_PlayerPing: + m_hPlayer = 0x570 # CHandle + m_hPingedEntity = 0x574 # CHandle + m_iType = 0x578 # int32_t + m_bUrgent = 0x57C # bool + m_szPlaceName = 0x57D # char[18] + +class C_PlayerSprayDecal: + m_nUniqueID = 0xCC0 # int32_t + m_unAccountID = 0xCC4 # uint32_t + m_unTraceID = 0xCC8 # uint32_t + m_rtGcTime = 0xCCC # uint32_t + m_vecEndPos = 0xCD0 # Vector + m_vecStart = 0xCDC # Vector + m_vecLeft = 0xCE8 # Vector + m_vecNormal = 0xCF4 # Vector + m_nPlayer = 0xD00 # int32_t + m_nEntity = 0xD04 # int32_t + m_nHitbox = 0xD08 # int32_t + m_flCreationTime = 0xD0C # float + m_nTintID = 0xD10 # int32_t + m_nVersion = 0xD14 # uint8_t + m_ubSignature = 0xD15 # uint8_t[128] + m_SprayRenderHelper = 0xDA0 # CPlayerSprayDecalRenderHelper + +class C_PlayerVisibility: + m_flVisibilityStrength = 0x540 # float + m_flFogDistanceMultiplier = 0x544 # float + m_flFogMaxDensityMultiplier = 0x548 # float + m_flFadeTime = 0x54C # float + m_bStartDisabled = 0x550 # bool + m_bIsEnabled = 0x551 # bool + +class C_PointCamera: + m_FOV = 0x540 # float + m_Resolution = 0x544 # float + m_bFogEnable = 0x548 # bool + m_FogColor = 0x549 # Color + m_flFogStart = 0x550 # float + m_flFogEnd = 0x554 # float + m_flFogMaxDensity = 0x558 # float + m_bActive = 0x55C # bool + m_bUseScreenAspectRatio = 0x55D # bool + m_flAspectRatio = 0x560 # float + m_bNoSky = 0x564 # bool + m_fBrightness = 0x568 # float + m_flZFar = 0x56C # float + m_flZNear = 0x570 # float + m_bCanHLTVUse = 0x574 # bool + m_bDofEnabled = 0x575 # bool + m_flDofNearBlurry = 0x578 # float + m_flDofNearCrisp = 0x57C # float + m_flDofFarCrisp = 0x580 # float + m_flDofFarBlurry = 0x584 # float + m_flDofTiltToGround = 0x588 # float + m_TargetFOV = 0x58C # float + m_DegreesPerSecond = 0x590 # float + m_bIsOn = 0x594 # bool + m_pNext = 0x598 # C_PointCamera* + +class C_PointCameraVFOV: + m_flVerticalFOV = 0x5A0 # float + +class C_PointClientUIDialog: + m_hActivator = 0xCF0 # CHandle + m_bStartEnabled = 0xCF4 # bool + +class C_PointClientUIHUD: + m_bCheckCSSClasses = 0xCF8 # bool + m_bIgnoreInput = 0xE80 # bool + m_flWidth = 0xE84 # float + m_flHeight = 0xE88 # float + m_flDPI = 0xE8C # float + m_flInteractDistance = 0xE90 # float + m_flDepthOffset = 0xE94 # float + m_unOwnerContext = 0xE98 # uint32_t + m_unHorizontalAlign = 0xE9C # uint32_t + m_unVerticalAlign = 0xEA0 # uint32_t + m_unOrientation = 0xEA4 # uint32_t + m_bAllowInteractionFromAllSceneWorlds = 0xEA8 # bool + m_vecCSSClasses = 0xEB0 # C_NetworkUtlVectorBase + +class C_PointClientUIWorldPanel: + m_bForceRecreateNextUpdate = 0xCF8 # bool + m_bMoveViewToPlayerNextThink = 0xCF9 # bool + m_bCheckCSSClasses = 0xCFA # bool + m_anchorDeltaTransform = 0xD00 # CTransform + m_pOffScreenIndicator = 0xEA0 # CPointOffScreenIndicatorUi* + m_bIgnoreInput = 0xEC8 # bool + m_bLit = 0xEC9 # bool + m_bFollowPlayerAcrossTeleport = 0xECA # bool + m_flWidth = 0xECC # float + m_flHeight = 0xED0 # float + m_flDPI = 0xED4 # float + m_flInteractDistance = 0xED8 # float + m_flDepthOffset = 0xEDC # float + m_unOwnerContext = 0xEE0 # uint32_t + m_unHorizontalAlign = 0xEE4 # uint32_t + m_unVerticalAlign = 0xEE8 # uint32_t + m_unOrientation = 0xEEC # uint32_t + m_bAllowInteractionFromAllSceneWorlds = 0xEF0 # bool + m_vecCSSClasses = 0xEF8 # C_NetworkUtlVectorBase + m_bOpaque = 0xF10 # bool + m_bNoDepth = 0xF11 # bool + m_bRenderBackface = 0xF12 # bool + m_bUseOffScreenIndicator = 0xF13 # bool + m_bExcludeFromSaveGames = 0xF14 # bool + m_bGrabbable = 0xF15 # bool + m_bOnlyRenderToTexture = 0xF16 # bool + m_bDisableMipGen = 0xF17 # bool + m_nExplicitImageLayout = 0xF18 # int32_t + +class C_PointClientUIWorldTextPanel: + m_messageText = 0xF20 # char[512] + +class C_PointCommentaryNode: + m_bActive = 0xE88 # bool + m_bWasActive = 0xE89 # bool + m_flEndTime = 0xE8C # GameTime_t + m_flStartTime = 0xE90 # GameTime_t + m_flStartTimeInCommentary = 0xE94 # float + m_iszCommentaryFile = 0xE98 # CUtlSymbolLarge + m_iszTitle = 0xEA0 # CUtlSymbolLarge + m_iszSpeakers = 0xEA8 # CUtlSymbolLarge + m_iNodeNumber = 0xEB0 # int32_t + m_iNodeNumberMax = 0xEB4 # int32_t + m_bListenedTo = 0xEB8 # bool + m_hViewPosition = 0xEC8 # CHandle + m_bRestartAfterRestore = 0xECC # bool + +class C_PointValueRemapper: + m_bDisabled = 0x540 # bool + m_bDisabledOld = 0x541 # bool + m_bUpdateOnClient = 0x542 # bool + m_nInputType = 0x544 # ValueRemapperInputType_t + m_hRemapLineStart = 0x548 # CHandle + m_hRemapLineEnd = 0x54C # CHandle + m_flMaximumChangePerSecond = 0x550 # float + m_flDisengageDistance = 0x554 # float + m_flEngageDistance = 0x558 # float + m_bRequiresUseKey = 0x55C # bool + m_nOutputType = 0x560 # ValueRemapperOutputType_t + m_hOutputEntities = 0x568 # C_NetworkUtlVectorBase> + m_nHapticsType = 0x580 # ValueRemapperHapticsType_t + m_nMomentumType = 0x584 # ValueRemapperMomentumType_t + m_flMomentumModifier = 0x588 # float + m_flSnapValue = 0x58C # float + m_flCurrentMomentum = 0x590 # float + m_nRatchetType = 0x594 # ValueRemapperRatchetType_t + m_flRatchetOffset = 0x598 # float + m_flInputOffset = 0x59C # float + m_bEngaged = 0x5A0 # bool + m_bFirstUpdate = 0x5A1 # bool + m_flPreviousValue = 0x5A4 # float + m_flPreviousUpdateTickTime = 0x5A8 # GameTime_t + m_vecPreviousTestPoint = 0x5AC # Vector + +class C_PointWorldText: + m_bForceRecreateNextUpdate = 0xCC8 # bool + m_messageText = 0xCD8 # char[512] + m_FontName = 0xED8 # char[64] + m_bEnabled = 0xF18 # bool + m_bFullbright = 0xF19 # bool + m_flWorldUnitsPerPx = 0xF1C # float + m_flFontSize = 0xF20 # float + m_flDepthOffset = 0xF24 # float + m_Color = 0xF28 # Color + m_nJustifyHorizontal = 0xF2C # PointWorldTextJustifyHorizontal_t + m_nJustifyVertical = 0xF30 # PointWorldTextJustifyVertical_t + m_nReorientMode = 0xF34 # PointWorldTextReorientMode_t + +class C_PostProcessingVolume: + m_hPostSettings = 0xCD8 # CStrongHandle + m_flFadeDuration = 0xCE0 # float + m_flMinLogExposure = 0xCE4 # float + m_flMaxLogExposure = 0xCE8 # float + m_flMinExposure = 0xCEC # float + m_flMaxExposure = 0xCF0 # float + m_flExposureCompensation = 0xCF4 # float + m_flExposureFadeSpeedUp = 0xCF8 # float + m_flExposureFadeSpeedDown = 0xCFC # float + m_flTonemapEVSmoothingRange = 0xD00 # float + m_bMaster = 0xD04 # bool + m_bExposureControl = 0xD05 # bool + m_flRate = 0xD08 # float + m_flTonemapPercentTarget = 0xD0C # float + m_flTonemapPercentBrightPixels = 0xD10 # float + m_flTonemapMinAvgLum = 0xD14 # float + +class C_Precipitation: + m_flDensity = 0xCC8 # float + m_flParticleInnerDist = 0xCD8 # float + m_pParticleDef = 0xCE0 # char* + m_tParticlePrecipTraceTimer = 0xD08 # TimedEvent[1] + m_bActiveParticlePrecipEmitter = 0xD10 # bool[1] + m_bParticlePrecipInitialized = 0xD11 # bool + m_bHasSimulatedSinceLastSceneObjectUpdate = 0xD12 # bool + m_nAvailableSheetSequencesMaxIndex = 0xD14 # int32_t + +class C_PredictedViewModel: + m_LagAnglesHistory = 0xEE8 # QAngle + m_vPredictedOffset = 0xF00 # Vector + +class C_RagdollManager: + m_iCurrentMaxRagdollCount = 0x540 # int8_t + +class C_RagdollProp: + m_ragPos = 0xE88 # C_NetworkUtlVectorBase + m_ragAngles = 0xEA0 # C_NetworkUtlVectorBase + m_flBlendWeight = 0xEB8 # float + m_hRagdollSource = 0xEBC # CHandle + m_iEyeAttachment = 0xEC0 # AttachmentHandle_t + m_flBlendWeightCurrent = 0xEC4 # float + m_parentPhysicsBoneIndices = 0xEC8 # CUtlVector + m_worldSpaceBoneComputationOrder = 0xEE0 # CUtlVector + +class C_RagdollPropAttached: + m_boneIndexAttached = 0xEF8 # uint32_t + m_ragdollAttachedObjectIndex = 0xEFC # uint32_t + m_attachmentPointBoneSpace = 0xF00 # Vector + m_attachmentPointRagdollSpace = 0xF0C # Vector + m_vecOffset = 0xF18 # Vector + m_parentTime = 0xF24 # float + m_bHasParent = 0xF28 # bool + +class C_RectLight: + m_bShowLight = 0xF08 # bool + +class C_RetakeGameRules: + m_nMatchSeed = 0xF8 # int32_t + m_bBlockersPresent = 0xFC # bool + m_bRoundInProgress = 0xFD # bool + m_iFirstSecondHalfRound = 0x100 # int32_t + m_iBombSite = 0x104 # int32_t + +class C_RopeKeyframe: + m_LinksTouchingSomething = 0xCC8 # CBitVec<10> + m_nLinksTouchingSomething = 0xCCC # int32_t + m_bApplyWind = 0xCD0 # bool + m_fPrevLockedPoints = 0xCD4 # int32_t + m_iForcePointMoveCounter = 0xCD8 # int32_t + m_bPrevEndPointPos = 0xCDC # bool[2] + m_vPrevEndPointPos = 0xCE0 # Vector[2] + m_flCurScroll = 0xCF8 # float + m_flScrollSpeed = 0xCFC # float + m_RopeFlags = 0xD00 # uint16_t + m_iRopeMaterialModelIndex = 0xD08 # CStrongHandle + m_LightValues = 0xF80 # Vector[10] + m_nSegments = 0xFF8 # uint8_t + m_hStartPoint = 0xFFC # CHandle + m_hEndPoint = 0x1000 # CHandle + m_iStartAttachment = 0x1004 # AttachmentHandle_t + m_iEndAttachment = 0x1005 # AttachmentHandle_t + m_Subdiv = 0x1006 # uint8_t + m_RopeLength = 0x1008 # int16_t + m_Slack = 0x100A # int16_t + m_TextureScale = 0x100C # float + m_fLockedPoints = 0x1010 # uint8_t + m_nChangeCount = 0x1011 # uint8_t + m_Width = 0x1014 # float + m_PhysicsDelegate = 0x1018 # C_RopeKeyframe::CPhysicsDelegate + m_hMaterial = 0x1028 # CStrongHandle + m_TextureHeight = 0x1030 # int32_t + m_vecImpulse = 0x1034 # Vector + m_vecPreviousImpulse = 0x1040 # Vector + m_flCurrentGustTimer = 0x104C # float + m_flCurrentGustLifetime = 0x1050 # float + m_flTimeToNextGust = 0x1054 # float + m_vWindDir = 0x1058 # Vector + m_vColorMod = 0x1064 # Vector + m_vCachedEndPointAttachmentPos = 0x1070 # Vector[2] + m_vCachedEndPointAttachmentAngle = 0x1088 # QAngle[2] + m_bConstrainBetweenEndpoints = 0x10A0 # bool + m_bEndPointAttachmentPositionsDirty = 0x0 # bitfield:1 + m_bEndPointAttachmentAnglesDirty = 0x0 # bitfield:1 + m_bNewDataThisFrame = 0x0 # bitfield:1 + m_bPhysicsInitted = 0x0 # bitfield:1 + +class C_RopeKeyframe_CPhysicsDelegate: + m_pKeyframe = 0x8 # C_RopeKeyframe* + +class C_SceneEntity: + m_bIsPlayingBack = 0x548 # bool + m_bPaused = 0x549 # bool + m_bMultiplayer = 0x54A # bool + m_bAutogenerated = 0x54B # bool + m_flForceClientTime = 0x54C # float + m_nSceneStringIndex = 0x550 # uint16_t + m_bClientOnly = 0x552 # bool + m_hOwner = 0x554 # CHandle + m_hActorList = 0x558 # C_NetworkUtlVectorBase> + m_bWasPlaying = 0x570 # bool + m_QueuedEvents = 0x580 # CUtlVector + m_flCurrentTime = 0x598 # float + +class C_SceneEntity_QueuedEvents_t: + starttime = 0x0 # float + +class C_ShatterGlassShardPhysics: + m_ShardDesc = 0xFE0 # shard_model_desc_t + +class C_SkyCamera: + m_skyboxData = 0x540 # sky3dparams_t + m_skyboxSlotToken = 0x5D0 # CUtlStringToken + m_bUseAngles = 0x5D4 # bool + m_pNext = 0x5D8 # C_SkyCamera* + +class C_SmokeGrenadeProjectile: + m_nSmokeEffectTickBegin = 0x10F8 # int32_t + m_bDidSmokeEffect = 0x10FC # bool + m_nRandomSeed = 0x1100 # int32_t + m_vSmokeColor = 0x1104 # Vector + m_vSmokeDetonationPos = 0x1110 # Vector + m_VoxelFrameData = 0x1120 # CUtlVector + m_bSmokeVolumeDataReceived = 0x1138 # bool + m_bSmokeEffectSpawned = 0x1139 # bool + +class C_SoundAreaEntityBase: + m_bDisabled = 0x540 # bool + m_bWasEnabled = 0x548 # bool + m_iszSoundAreaType = 0x550 # CUtlSymbolLarge + m_vPos = 0x558 # Vector + +class C_SoundAreaEntityOrientedBox: + m_vMin = 0x568 # Vector + m_vMax = 0x574 # Vector + +class C_SoundAreaEntitySphere: + m_flRadius = 0x568 # float + +class C_SoundOpvarSetPointBase: + m_iszStackName = 0x540 # CUtlSymbolLarge + m_iszOperatorName = 0x548 # CUtlSymbolLarge + m_iszOpvarName = 0x550 # CUtlSymbolLarge + m_iOpvarIndex = 0x558 # int32_t + m_bUseAutoCompare = 0x55C # bool + +class C_SpotlightEnd: + m_flLightScale = 0xCC0 # float + m_Radius = 0xCC4 # float + +class C_Sprite: + m_hSpriteMaterial = 0xCD8 # CStrongHandle + m_hAttachedToEntity = 0xCE0 # CHandle + m_nAttachment = 0xCE4 # AttachmentHandle_t + m_flSpriteFramerate = 0xCE8 # float + m_flFrame = 0xCEC # float + m_flDieTime = 0xCF0 # GameTime_t + m_nBrightness = 0xD00 # uint32_t + m_flBrightnessDuration = 0xD04 # float + m_flSpriteScale = 0xD08 # float + m_flScaleDuration = 0xD0C # float + m_bWorldSpaceScale = 0xD10 # bool + m_flGlowProxySize = 0xD14 # float + m_flHDRColorScale = 0xD18 # float + m_flLastTime = 0xD1C # GameTime_t + m_flMaxFrame = 0xD20 # float + m_flStartScale = 0xD24 # float + m_flDestScale = 0xD28 # float + m_flScaleTimeStart = 0xD2C # GameTime_t + m_nStartBrightness = 0xD30 # int32_t + m_nDestBrightness = 0xD34 # int32_t + m_flBrightnessTimeStart = 0xD38 # GameTime_t + m_hOldSpriteMaterial = 0xD40 # CWeakHandle + m_nSpriteWidth = 0xDE8 # int32_t + m_nSpriteHeight = 0xDEC # int32_t + +class C_Sun: + m_fxSSSunFlareEffectIndex = 0xCC0 # ParticleIndex_t + m_fxSunFlareEffectIndex = 0xCC4 # ParticleIndex_t + m_fdistNormalize = 0xCC8 # float + m_vSunPos = 0xCCC # Vector + m_vDirection = 0xCD8 # Vector + m_iszEffectName = 0xCE8 # CUtlSymbolLarge + m_iszSSEffectName = 0xCF0 # CUtlSymbolLarge + m_clrOverlay = 0xCF8 # Color + m_bOn = 0xCFC # bool + m_bmaxColor = 0xCFD # bool + m_flSize = 0xD00 # float + m_flHazeScale = 0xD04 # float + m_flRotation = 0xD08 # float + m_flHDRColorScale = 0xD0C # float + m_flAlphaHaze = 0xD10 # float + m_flAlphaScale = 0xD14 # float + m_flAlphaHdr = 0xD18 # float + m_flFarZScale = 0xD1C # float + +class C_SunGlowOverlay: + m_bModulateByDot = 0xD0 # bool + +class C_Team: + m_aPlayerControllers = 0x540 # C_NetworkUtlVectorBase> + m_aPlayers = 0x558 # C_NetworkUtlVectorBase> + m_iScore = 0x570 # int32_t + m_szTeamname = 0x574 # char[129] + +class C_TeamRoundTimer: + m_bTimerPaused = 0x540 # bool + m_flTimeRemaining = 0x544 # float + m_flTimerEndTime = 0x548 # GameTime_t + m_bIsDisabled = 0x54C # bool + m_bShowInHUD = 0x54D # bool + m_nTimerLength = 0x550 # int32_t + m_nTimerInitialLength = 0x554 # int32_t + m_nTimerMaxLength = 0x558 # int32_t + m_bAutoCountdown = 0x55C # bool + m_nSetupTimeLength = 0x560 # int32_t + m_nState = 0x564 # int32_t + m_bStartPaused = 0x568 # bool + m_bInCaptureWatchState = 0x569 # bool + m_flTotalTime = 0x56C # float + m_bStopWatchTimer = 0x570 # bool + m_bFireFinished = 0x571 # bool + m_bFire5MinRemain = 0x572 # bool + m_bFire4MinRemain = 0x573 # bool + m_bFire3MinRemain = 0x574 # bool + m_bFire2MinRemain = 0x575 # bool + m_bFire1MinRemain = 0x576 # bool + m_bFire30SecRemain = 0x577 # bool + m_bFire10SecRemain = 0x578 # bool + m_bFire5SecRemain = 0x579 # bool + m_bFire4SecRemain = 0x57A # bool + m_bFire3SecRemain = 0x57B # bool + m_bFire2SecRemain = 0x57C # bool + m_bFire1SecRemain = 0x57D # bool + m_nOldTimerLength = 0x580 # int32_t + m_nOldTimerState = 0x584 # int32_t + +class C_TextureBasedAnimatable: + m_bLoop = 0xCC0 # bool + m_flFPS = 0xCC4 # float + m_hPositionKeys = 0xCC8 # CStrongHandle + m_hRotationKeys = 0xCD0 # CStrongHandle + m_vAnimationBoundsMin = 0xCD8 # Vector + m_vAnimationBoundsMax = 0xCE4 # Vector + m_flStartTime = 0xCF0 # float + m_flStartFrame = 0xCF4 # float + +class C_TonemapController2: + m_flAutoExposureMin = 0x540 # float + m_flAutoExposureMax = 0x544 # float + m_flTonemapPercentTarget = 0x548 # float + m_flTonemapPercentBrightPixels = 0x54C # float + m_flTonemapMinAvgLum = 0x550 # float + m_flExposureAdaptationSpeedUp = 0x554 # float + m_flExposureAdaptationSpeedDown = 0x558 # float + m_flTonemapEVSmoothingRange = 0x55C # float + +class C_TriggerBuoyancy: + m_BuoyancyHelper = 0xCC8 # CBuoyancyHelper + m_flFluidDensity = 0xCE8 # float + +class C_ViewmodelWeapon: + m_worldModel = 0xE80 # char* + +class C_VoteController: + m_iActiveIssueIndex = 0x550 # int32_t + m_iOnlyTeamToVote = 0x554 # int32_t + m_nVoteOptionCount = 0x558 # int32_t[5] + m_nPotentialVotes = 0x56C # int32_t + m_bVotesDirty = 0x570 # bool + m_bTypeDirty = 0x571 # bool + m_bIsYesNoVote = 0x572 # bool + +class C_WeaponBaseItem: + m_SequenceCompleteTimer = 0x1940 # CountdownTimer + m_bRedraw = 0x1958 # bool + +class C_WeaponShield: + m_flDisplayHealth = 0x1960 # float + +class C_WeaponTaser: + m_fFireTime = 0x1960 # GameTime_t + +class C_fogplayerparams_t: + m_hCtrl = 0x8 # CHandle + m_flTransitionTime = 0xC # float + m_OldColor = 0x10 # Color + m_flOldStart = 0x14 # float + m_flOldEnd = 0x18 # float + m_flOldMaxDensity = 0x1C # float + m_flOldHDRColorScale = 0x20 # float + m_flOldFarZ = 0x24 # float + m_NewColor = 0x28 # Color + m_flNewStart = 0x2C # float + m_flNewEnd = 0x30 # float + m_flNewMaxDensity = 0x34 # float + m_flNewHDRColorScale = 0x38 # float + m_flNewFarZ = 0x3C # float + +class CompMatMutatorCondition_t: + m_nMutatorCondition = 0x0 # CompMatPropertyMutatorConditionType_t + m_strMutatorConditionContainerName = 0x8 # CUtlString + m_strMutatorConditionContainerVarName = 0x10 # CUtlString + m_strMutatorConditionContainerVarValue = 0x18 # CUtlString + m_bPassWhenTrue = 0x20 # bool + +class CompMatPropertyMutator_t: + m_bEnabled = 0x0 # bool + m_nMutatorCommandType = 0x4 # CompMatPropertyMutatorType_t + m_strInitWith_Container = 0x8 # CUtlString + m_strCopyProperty_InputContainerSrc = 0x10 # CUtlString + m_strCopyProperty_InputContainerProperty = 0x18 # CUtlString + m_strCopyProperty_TargetProperty = 0x20 # CUtlString + m_strRandomRollInputVars_SeedInputVar = 0x28 # CUtlString + m_vecRandomRollInputVars_InputVarsToRoll = 0x30 # CUtlVector + m_strCopyMatchingKeys_InputContainerSrc = 0x48 # CUtlString + m_strCopyKeysWithSuffix_InputContainerSrc = 0x50 # CUtlString + m_strCopyKeysWithSuffix_FindSuffix = 0x58 # CUtlString + m_strCopyKeysWithSuffix_ReplaceSuffix = 0x60 # CUtlString + m_nSetValue_Value = 0x68 # CompositeMaterialInputLooseVariable_t + m_strGenerateTexture_TargetParam = 0x2D8 # CUtlString + m_strGenerateTexture_InitialContainer = 0x2E0 # CUtlString + m_nResolution = 0x2E8 # int32_t + m_bIsScratchTarget = 0x2EC # bool + m_bSplatDebugInfo = 0x2ED # bool + m_bCaptureInRenderDoc = 0x2EE # bool + m_vecTexGenInstructions = 0x2F0 # CUtlVector + m_vecConditionalMutators = 0x308 # CUtlVector + m_strPopInputQueue_Container = 0x320 # CUtlString + m_strDrawText_InputContainerSrc = 0x328 # CUtlString + m_strDrawText_InputContainerProperty = 0x330 # CUtlString + m_vecDrawText_Position = 0x338 # Vector2D + m_colDrawText_Color = 0x340 # Color + m_strDrawText_Font = 0x348 # CUtlString + m_vecConditions = 0x350 # CUtlVector + +class CompositeMaterialAssemblyProcedure_t: + m_vecCompMatIncludes = 0x0 # CUtlVector + m_vecMatchFilters = 0x18 # CUtlVector + m_vecCompositeInputContainers = 0x30 # CUtlVector + m_vecPropertyMutators = 0x48 # CUtlVector + +class CompositeMaterialEditorPoint_t: + m_ModelName = 0x0 # CResourceName + m_nSequenceIndex = 0xE0 # int32_t + m_flCycle = 0xE4 # float + m_KVModelStateChoices = 0xE8 # KeyValues3 + m_bEnableChildModel = 0xF8 # bool + m_ChildModelName = 0x100 # CResourceName + m_vecCompositeMaterialAssemblyProcedures = 0x1E0 # CUtlVector + m_vecCompositeMaterials = 0x1F8 # CUtlVector + +class CompositeMaterialInputContainer_t: + m_bEnabled = 0x0 # bool + m_nCompositeMaterialInputContainerSourceType = 0x4 # CompositeMaterialInputContainerSourceType_t + m_strSpecificContainerMaterial = 0x8 # CResourceName + m_strAttrName = 0xE8 # CUtlString + m_strAlias = 0xF0 # CUtlString + m_vecLooseVariables = 0xF8 # CUtlVector + m_strAttrNameForVar = 0x110 # CUtlString + m_bExposeExternally = 0x118 # bool + +class CompositeMaterialInputLooseVariable_t: + m_strName = 0x0 # CUtlString + m_bExposeExternally = 0x8 # bool + m_strExposedFriendlyName = 0x10 # CUtlString + m_strExposedFriendlyGroupName = 0x18 # CUtlString + m_bExposedVariableIsFixedRange = 0x20 # bool + m_strExposedVisibleWhenTrue = 0x28 # CUtlString + m_strExposedHiddenWhenTrue = 0x30 # CUtlString + m_nVariableType = 0x38 # CompositeMaterialInputLooseVariableType_t + m_bValueBoolean = 0x3C # bool + m_nValueIntX = 0x40 # int32_t + m_nValueIntY = 0x44 # int32_t + m_nValueIntZ = 0x48 # int32_t + m_nValueIntW = 0x4C # int32_t + m_bHasFloatBounds = 0x50 # bool + m_flValueFloatX = 0x54 # float + m_flValueFloatX_Min = 0x58 # float + m_flValueFloatX_Max = 0x5C # float + m_flValueFloatY = 0x60 # float + m_flValueFloatY_Min = 0x64 # float + m_flValueFloatY_Max = 0x68 # float + m_flValueFloatZ = 0x6C # float + m_flValueFloatZ_Min = 0x70 # float + m_flValueFloatZ_Max = 0x74 # float + m_flValueFloatW = 0x78 # float + m_flValueFloatW_Min = 0x7C # float + m_flValueFloatW_Max = 0x80 # float + m_cValueColor4 = 0x84 # Color + m_nValueSystemVar = 0x88 # CompositeMaterialVarSystemVar_t + m_strResourceMaterial = 0x90 # CResourceName + m_strTextureContentAssetPath = 0x170 # CUtlString + m_strTextureRuntimeResourcePath = 0x178 # CResourceName + m_strTextureCompilationVtexTemplate = 0x258 # CUtlString + m_nTextureType = 0x260 # CompositeMaterialInputTextureType_t + m_strString = 0x268 # CUtlString + +class CompositeMaterialMatchFilter_t: + m_nCompositeMaterialMatchFilterType = 0x0 # CompositeMaterialMatchFilterType_t + m_strMatchFilter = 0x8 # CUtlString + m_strMatchValue = 0x10 # CUtlString + m_bPassWhenTrue = 0x18 # bool + +class CompositeMaterial_t: + m_TargetKVs = 0x8 # KeyValues3 + m_PreGenerationKVs = 0x18 # KeyValues3 + m_FinalKVs = 0x28 # KeyValues3 + m_vecGeneratedTextures = 0x40 # CUtlVector + +class CountdownTimer: + m_duration = 0x8 # float + m_timestamp = 0xC # GameTime_t + m_timescale = 0x10 # float + m_nWorldGroupId = 0x14 # WorldGroupId_t + +class EngineCountdownTimer: + m_duration = 0x8 # float + m_timestamp = 0xC # float + m_timescale = 0x10 # float + +class EntityRenderAttribute_t: + m_ID = 0x30 # CUtlStringToken + m_Values = 0x34 # Vector4D + +class EntitySpottedState_t: + m_bSpotted = 0x8 # bool + m_bSpottedByMask = 0xC # uint32_t[2] + +class GeneratedTextureHandle_t: + m_strBitmapName = 0x0 # CUtlString + +class IntervalTimer: + m_timestamp = 0x8 # GameTime_t + m_nWorldGroupId = 0xC # WorldGroupId_t + +class PhysicsRagdollPose_t: + __m_pChainEntity = 0x8 # CNetworkVarChainer + m_Transforms = 0x30 # C_NetworkUtlVectorBase + m_hOwner = 0x48 # CHandle + m_bDirty = 0x68 # bool + +class SellbackPurchaseEntry_t: + m_unDefIdx = 0x30 # uint16_t + m_nCost = 0x34 # int32_t + m_nPrevArmor = 0x38 # int32_t + m_bPrevHelmet = 0x3C # bool + m_hItem = 0x40 # CEntityHandle + +class ServerAuthoritativeWeaponSlot_t: + unClass = 0x28 # uint16_t + unSlot = 0x2A # uint16_t + unItemDefIdx = 0x2C # uint16_t + +class TimedEvent: + m_TimeBetweenEvents = 0x0 # float + m_fNextEvent = 0x4 # float + +class VPhysicsCollisionAttribute_t: + m_nInteractsAs = 0x8 # uint64_t + m_nInteractsWith = 0x10 # uint64_t + m_nInteractsExclude = 0x18 # uint64_t + m_nEntityId = 0x20 # uint32_t + m_nOwnerId = 0x24 # uint32_t + m_nHierarchyId = 0x28 # uint16_t + m_nCollisionGroup = 0x2A # uint8_t + m_nCollisionFunctionMask = 0x2B # uint8_t + +class ViewAngleServerChange_t: + nType = 0x30 # FixAngleSet_t + qAngle = 0x34 # QAngle + nIndex = 0x40 # uint32_t + +class WeaponPurchaseCount_t: + m_nItemDefIndex = 0x30 # uint16_t + m_nCount = 0x32 # uint16_t + +class WeaponPurchaseTracker_t: + m_weaponPurchases = 0x8 # C_UtlVectorEmbeddedNetworkVar + +class audioparams_t: + localSound = 0x8 # Vector[8] + soundscapeIndex = 0x68 # int32_t + localBits = 0x6C # uint8_t + soundscapeEntityListIndex = 0x70 # int32_t + soundEventHash = 0x74 # uint32_t + +class fogparams_t: + dirPrimary = 0x8 # Vector + colorPrimary = 0x14 # Color + colorSecondary = 0x18 # Color + colorPrimaryLerpTo = 0x1C # Color + colorSecondaryLerpTo = 0x20 # Color + start = 0x24 # float + end = 0x28 # float + farz = 0x2C # float + maxdensity = 0x30 # float + exponent = 0x34 # float + HDRColorScale = 0x38 # float + skyboxFogFactor = 0x3C # float + skyboxFogFactorLerpTo = 0x40 # float + startLerpTo = 0x44 # float + endLerpTo = 0x48 # float + maxdensityLerpTo = 0x4C # float + lerptime = 0x50 # GameTime_t + duration = 0x54 # float + blendtobackground = 0x58 # float + scattering = 0x5C # float + locallightscale = 0x60 # float + enable = 0x64 # bool + blend = 0x65 # bool + m_bNoReflectionFog = 0x66 # bool + m_bPadding = 0x67 # bool + +class shard_model_desc_t: + m_nModelID = 0x8 # int32_t + m_hMaterial = 0x10 # CStrongHandle + m_solid = 0x18 # ShardSolid_t + m_ShatterPanelMode = 0x19 # ShatterPanelMode + m_vecPanelSize = 0x1C # Vector2D + m_vecStressPositionA = 0x24 # Vector2D + m_vecStressPositionB = 0x2C # Vector2D + m_vecPanelVertices = 0x38 # C_NetworkUtlVectorBase + m_flGlassHalfThickness = 0x50 # float + m_bHasParent = 0x54 # bool + m_bParentFrozen = 0x55 # bool + m_SurfacePropStringToken = 0x58 # CUtlStringToken + m_LightGroup = 0x5C # CUtlStringToken + +class sky3dparams_t: + scale = 0x8 # int16_t + origin = 0xC # Vector + bClip3DSkyBoxNearToWorldFar = 0x18 # bool + flClip3DSkyBoxNearToWorldFarOffset = 0x1C # float + fog = 0x20 # fogparams_t + m_nWorldGroupID = 0x88 # WorldGroupId_t diff --git a/generated/client.dll.rs b/generated/client.dll.rs index 4693a06..e35892a 100644 --- a/generated/client.dll.rs +++ b/generated/client.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:32.927109500 UTC + * 2023-10-17 02:04:51.467219600 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod ActiveModelConfig_t { pub const m_Handle: usize = 0x28; // ModelConfigHandle_t pub const m_Name: usize = 0x30; // CUtlSymbolLarge diff --git a/generated/engine2.dll.cs b/generated/engine2.dll.cs index 659e720..1d49378 100644 --- a/generated/engine2.dll.cs +++ b/generated/engine2.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.375847600 UTC + * 2023-10-17 02:04:49.696799500 UTC */ public static class CEntityComponentHelper { diff --git a/generated/engine2.dll.hpp b/generated/engine2.dll.hpp index 035bb4e..3582f15 100644 --- a/generated/engine2.dll.hpp +++ b/generated/engine2.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:49.694823800 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.373798700 UTC - */ - namespace CEntityComponentHelper { constexpr std::ptrdiff_t m_flags = 0x8; // uint32_t constexpr std::ptrdiff_t m_pInfo = 0x10; // EntComponentInfo_t* diff --git a/generated/engine2.dll.py b/generated/engine2.dll.py new file mode 100644 index 0000000..f32cd4a --- /dev/null +++ b/generated/engine2.dll.py @@ -0,0 +1,149 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:49.699141900 UTC +''' + +class CEntityComponentHelper: + m_flags = 0x8 # uint32_t + m_pInfo = 0x10 # EntComponentInfo_t* + m_nPriority = 0x18 # int32_t + m_pNext = 0x20 # CEntityComponentHelper* + +class CEntityIOOutput: + m_Value = 0x18 # CVariantBase + +class CEntityIdentity: + m_nameStringableIndex = 0x14 # int32_t + m_name = 0x18 # CUtlSymbolLarge + m_designerName = 0x20 # CUtlSymbolLarge + m_flags = 0x30 # uint32_t + m_worldGroupId = 0x38 # WorldGroupId_t + m_fDataObjectTypes = 0x3C # uint32_t + m_PathIndex = 0x40 # ChangeAccessorFieldPathIndex_t + m_pPrev = 0x58 # CEntityIdentity* + m_pNext = 0x60 # CEntityIdentity* + m_pPrevByClass = 0x68 # CEntityIdentity* + m_pNextByClass = 0x70 # CEntityIdentity* + +class CEntityInstance: + m_iszPrivateVScripts = 0x8 # CUtlSymbolLarge + m_pEntity = 0x10 # CEntityIdentity* + m_CScriptComponent = 0x28 # CScriptComponent* + +class CNetworkVarChainer: + m_PathIndex = 0x20 # ChangeAccessorFieldPathIndex_t + +class CScriptComponent: + m_scriptClassName = 0x30 # CUtlSymbolLarge + +class EngineLoopState_t: + m_nPlatWindowWidth = 0x18 # int32_t + m_nPlatWindowHeight = 0x1C # int32_t + m_nRenderWidth = 0x20 # int32_t + m_nRenderHeight = 0x24 # int32_t + +class EntComponentInfo_t: + m_pName = 0x0 # char* + m_pCPPClassname = 0x8 # char* + m_pNetworkDataReferencedDescription = 0x10 # char* + m_pNetworkDataReferencedPtrPropDescription = 0x18 # char* + m_nRuntimeIndex = 0x20 # int32_t + m_nFlags = 0x24 # uint32_t + m_pBaseClassComponentHelper = 0x60 # CEntityComponentHelper* + +class EventAdvanceTick_t: + m_nCurrentTick = 0x30 # int32_t + m_nCurrentTickThisFrame = 0x34 # int32_t + m_nTotalTicksThisFrame = 0x38 # int32_t + m_nTotalTicks = 0x3C # int32_t + +class EventAppShutdown_t: + m_nDummy0 = 0x0 # int32_t + +class EventClientFrameSimulate_t: + m_LoopState = 0x0 # EngineLoopState_t + m_flRealTime = 0x28 # float + m_flFrameTime = 0x2C # float + +class EventClientOutput_t: + m_LoopState = 0x0 # EngineLoopState_t + m_flRenderTime = 0x28 # float + m_flRealTime = 0x2C # float + m_flRenderFrameTimeUnbounded = 0x30 # float + m_bRenderOnly = 0x34 # bool + +class EventClientPollInput_t: + m_LoopState = 0x0 # EngineLoopState_t + m_flRealTime = 0x28 # float + +class EventClientPollNetworking_t: + m_nTickCount = 0x0 # int32_t + +class EventClientPostOutput_t: + m_LoopState = 0x0 # EngineLoopState_t + m_flRenderTime = 0x28 # double + m_flRenderFrameTime = 0x30 # float + m_flRenderFrameTimeUnbounded = 0x34 # float + m_bRenderOnly = 0x38 # bool + +class EventClientPreOutput_t: + m_LoopState = 0x0 # EngineLoopState_t + m_flRenderTime = 0x28 # double + m_flRenderFrameTime = 0x30 # double + m_flRenderFrameTimeUnbounded = 0x38 # double + m_flRealTime = 0x40 # float + m_bRenderOnly = 0x44 # bool + +class EventClientProcessGameInput_t: + m_LoopState = 0x0 # EngineLoopState_t + m_flRealTime = 0x28 # float + m_flFrameTime = 0x2C # float + +class EventClientProcessInput_t: + m_LoopState = 0x0 # EngineLoopState_t + m_flRealTime = 0x28 # float + +class EventClientSceneSystemThreadStateChange_t: + m_bThreadsActive = 0x0 # bool + +class EventClientSendInput_t: + m_bFinalClientCommandTick = 0x0 # bool + m_nAdditionalClientCommandsToCreate = 0x4 # int32_t + +class EventFrameBoundary_t: + m_flFrameTime = 0x0 # float + +class EventPostAdvanceTick_t: + m_nCurrentTick = 0x30 # int32_t + m_nCurrentTickThisFrame = 0x34 # int32_t + m_nTotalTicksThisFrame = 0x38 # int32_t + m_nTotalTicks = 0x3C # int32_t + +class EventPostDataUpdate_t: + m_nCount = 0x0 # int32_t + +class EventPreDataUpdate_t: + m_nCount = 0x0 # int32_t + +class EventProfileStorageAvailable_t: + m_nSplitScreenSlot = 0x0 # CSplitScreenSlot + +class EventSetTime_t: + m_LoopState = 0x0 # EngineLoopState_t + m_nClientOutputFrames = 0x28 # int32_t + m_flRealTime = 0x30 # double + m_flRenderTime = 0x38 # double + m_flRenderFrameTime = 0x40 # double + m_flRenderFrameTimeUnbounded = 0x48 # double + m_flRenderFrameTimeUnscaled = 0x50 # double + m_flTickRemainder = 0x58 # double + +class EventSimpleLoopFrameUpdate_t: + m_LoopState = 0x0 # EngineLoopState_t + m_flRealTime = 0x28 # float + m_flFrameTime = 0x2C # float + +class EventSimulate_t: + m_LoopState = 0x0 # EngineLoopState_t + m_bFirstTick = 0x28 # bool + m_bLastTick = 0x29 # bool diff --git a/generated/engine2.dll.rs b/generated/engine2.dll.rs index 06e39b6..6825c78 100644 --- a/generated/engine2.dll.rs +++ b/generated/engine2.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.378512600 UTC + * 2023-10-17 02:04:49.701434300 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod CEntityComponentHelper { pub const m_flags: usize = 0x8; // uint32_t pub const m_pInfo: usize = 0x10; // EntComponentInfo_t* diff --git a/generated/host.dll.cs b/generated/host.dll.cs index c71d373..6047b76 100644 --- a/generated/host.dll.cs +++ b/generated/host.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:32.969358100 UTC + * 2023-10-17 02:04:51.510044200 UTC */ public static class CAnimScriptBase { diff --git a/generated/host.dll.hpp b/generated/host.dll.hpp index 942e6bc..35bea3d 100644 --- a/generated/host.dll.hpp +++ b/generated/host.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:51.509650200 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:32.968868800 UTC - */ - namespace CAnimScriptBase { constexpr std::ptrdiff_t m_bIsValid = 0x8; // bool } diff --git a/generated/host.dll.py b/generated/host.dll.py new file mode 100644 index 0000000..9e1f349 --- /dev/null +++ b/generated/host.dll.py @@ -0,0 +1,10 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:51.510616600 UTC +''' + +class CAnimScriptBase: + m_bIsValid = 0x8 # bool + +class EmptyTestScript: + m_hTest = 0x10 # CAnimScriptParam diff --git a/generated/host.dll.rs b/generated/host.dll.rs index 281e3cd..1ca2e4a 100644 --- a/generated/host.dll.rs +++ b/generated/host.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:32.970197200 UTC + * 2023-10-17 02:04:51.511077100 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod CAnimScriptBase { pub const m_bIsValid: usize = 0x8; // bool } diff --git a/generated/interfaces.cs b/generated/interfaces.cs index 182ca1f..b36a567 100644 --- a/generated/interfaces.cs +++ b/generated/interfaces.cs @@ -1,14 +1,14 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:33.222923700 UTC + * 2023-10-17 02:04:51.720428600 UTC */ -public static class animationsystem_dll { +public static class AnimationsystemDll { public const nint AnimationSystemUtils_001 = 0x64670; public const nint AnimationSystem_001 = 0x5F1D0; } -public static class client_dll { +public static class ClientDll { public const nint LegacyGameUI001 = 0x88F360; public const nint Source2ClientUI001 = 0x87DE00; public const nint Source2ClientPrediction001 = 0x79B660; @@ -19,7 +19,7 @@ public static class client_dll { public const nint Source2ClientConfig001 = 0x4721F0; } -public static class engine2_dll { +public static class Engine2Dll { public const nint SimpleEngineLoopService_001 = 0x1E1C70; public const nint ClientServerEngineLoopService_001 = 0x1D7940; public const nint KeyValueCache001 = 0x1D3F80; @@ -54,12 +54,12 @@ public static class engine2_dll { public const nint Source2EngineToClient001 = 0x5A1B0; } -public static class filesystem_stdio_dll { +public static class FilesystemStdioDll { public const nint VAsyncFileSystem2_001 = 0x66D30; public const nint VFileSystem017 = 0x66D20; } -public static class host_dll { +public static class HostDll { public const nint Source2Host001 = 0x18E10; public const nint SinglePlayerSharedMemory001 = 0x18A90; public const nint SaveRestoreDataVersion001 = 0x18A80; @@ -70,25 +70,25 @@ public static class host_dll { public const nint DebugDrawQueueManager001 = 0x11710; } -public static class imemanager_dll { +public static class ImemanagerDll { public const nint IMEManager001 = 0xC470; } -public static class inputsystem_dll { +public static class InputsystemDll { public const nint InputSystemVersion001 = 0x28D0; public const nint InputStackSystemVersion001 = 0x16F0; } -public static class localize_dll { +public static class LocalizeDll { public const nint Localize_001 = 0x3830; } -public static class matchmaking_dll { +public static class MatchmakingDll { public const nint GameTypes001 = 0x50270; public const nint MATCHFRAMEWORK_001 = 0x101030; } -public static class materialsystem2_dll { +public static class Materialsystem2Dll { public const nint MaterialUtils_001 = 0x4DB80; public const nint TextLayout_001 = 0x4A2D0; public const nint PostProcessingSystem_001 = 0x42A50; @@ -96,67 +96,67 @@ public static class materialsystem2_dll { public const nint VMaterialSystem2_001 = 0x25EB0; } -public static class meshsystem_dll { +public static class MeshsystemDll { public const nint MeshSystem001 = 0x7270; } -public static class navsystem_dll { +public static class NavsystemDll { public const nint NavSystem001 = 0x76F0; } -public static class networksystem_dll { +public static class NetworksystemDll { public const nint SerializedEntitiesVersion001 = 0xD1A60; public const nint NetworkSystemVersion001 = 0xBBF70; public const nint NetworkMessagesVersion001 = 0x9C010; public const nint FlattenedSerializersVersion001 = 0x7B890; } -public static class panorama_dll { +public static class PanoramaDll { public const nint PanoramaUIEngine001 = 0x57EE0; } -public static class panorama_text_pango_dll { +public static class PanoramaTextPangoDll { public const nint PanoramaTextServices001 = 0x4CBD0; } -public static class panoramauiclient_dll { +public static class PanoramauiclientDll { public const nint PanoramaUIClient001 = 0x12780; } -public static class particles_dll { +public static class ParticlesDll { public const nint ParticleSystemMgr003 = 0x52D20; } -public static class pulse_system_dll { +public static class PulseSystemDll { public const nint IPulseSystem_001 = 0x5B80; } -public static class rendersystemdx11_dll { +public static class Rendersystemdx11Dll { public const nint RenderUtils_001 = 0x52C90; public const nint VRenderDeviceMgrBackdoor001 = 0x4A3A0; public const nint RenderDeviceMgr001 = 0x4A390; } -public static class resourcesystem_dll { +public static class ResourcesystemDll { public const nint ResourceSystem013 = 0x10650; } -public static class scenefilecache_dll { +public static class ScenefilecacheDll { public const nint SceneFileCache002 = 0x68E0; public const nint ResponseRulesCache001 = 0x3190; } -public static class scenesystem_dll { +public static class ScenesystemDll { public const nint SceneUtils_001 = 0x13D030; public const nint SceneSystem_002 = 0xCAE10; public const nint RenderingPipelines_001 = 0x8EED0; } -public static class schemasystem_dll { +public static class SchemasystemDll { public const nint SchemaSystem_001 = 0xA930; } -public static class server_dll { +public static class ServerDll { public const nint NavGameTest001 = 0xA2C470; public const nint ServerToolsInfo_001 = 0x830DE0; public const nint Source2GameClients001 = 0x830DF0; @@ -169,18 +169,18 @@ public static class server_dll { public const nint Source2GameDirector001 = 0x13EAB0; } -public static class soundsystem_dll { +public static class SoundsystemDll { public const nint SoundOpSystem001 = 0x156160; public const nint SoundOpSystemEdit001 = 0x8B540; public const nint VMixEditTool001 = 0x71740; public const nint SoundSystem001 = 0x46540; } -public static class steamaudio_dll { +public static class SteamaudioDll { public const nint SteamAudio001 = 0x12EE0; } -public static class steamclient64_dll { +public static class Steamclient64Dll { public const nint IVALIDATE001 = 0x833640; public const nint CLIENTENGINE_INTERFACE_VERSION005 = 0x82F4C0; public const nint SteamClient020 = 0x62CAF0; @@ -202,39 +202,39 @@ public static class steamclient64_dll { public const nint p2pvoicesingleton002 = 0xD5840; } -public static class tier0_dll { +public static class Tier0Dll { public const nint VStringTokenSystem001 = 0x18C390; public const nint TestScriptMgr001 = 0x13F6F0; public const nint VProcessUtils002 = 0x12F870; public const nint VEngineCvar007 = 0x61C50; } -public static class v8system_dll { +public static class V8SystemDll { public const nint Source2V8System001 = 0x1670; } -public static class valve_avi_dll { +public static class ValveAviDll { public const nint VAvi001 = 0x2F90; } -public static class valve_wmf_dll { +public static class ValveWmfDll { public const nint VMediaFoundation001 = 0x12D0; } -public static class vphysics2_dll { +public static class Vphysics2Dll { public const nint VPhysics2_Handle_Interface_001 = 0x5FA50; public const nint VPhysics2_Interface_001 = 0x5B7F0; } -public static class vscript_dll { +public static class VscriptDll { public const nint VScriptManager010 = 0x31DA0; } -public static class vstdlib_s64_dll { +public static class VstdlibS64Dll { public const nint IVALIDATE001 = 0x24FF0; public const nint VEngineCvar002 = 0x5750; } -public static class worldrenderer_dll { +public static class WorldrendererDll { public const nint WorldRendererMgr001 = 0x21530; } \ No newline at end of file diff --git a/generated/interfaces.hpp b/generated/interfaces.hpp index c97b3b1..708c9da 100644 --- a/generated/interfaces.hpp +++ b/generated/interfaces.hpp @@ -1,18 +1,18 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:51.718050700 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:33.220433600 UTC - */ - -namespace animationsystem_dll { +namespace AnimationsystemDll { constexpr std::ptrdiff_t AnimationSystemUtils_001 = 0x64670; constexpr std::ptrdiff_t AnimationSystem_001 = 0x5F1D0; } -namespace client_dll { +namespace ClientDll { constexpr std::ptrdiff_t LegacyGameUI001 = 0x88F360; constexpr std::ptrdiff_t Source2ClientUI001 = 0x87DE00; constexpr std::ptrdiff_t Source2ClientPrediction001 = 0x79B660; @@ -23,7 +23,7 @@ namespace client_dll { constexpr std::ptrdiff_t Source2ClientConfig001 = 0x4721F0; } -namespace engine2_dll { +namespace Engine2Dll { constexpr std::ptrdiff_t SimpleEngineLoopService_001 = 0x1E1C70; constexpr std::ptrdiff_t ClientServerEngineLoopService_001 = 0x1D7940; constexpr std::ptrdiff_t KeyValueCache001 = 0x1D3F80; @@ -58,12 +58,12 @@ namespace engine2_dll { constexpr std::ptrdiff_t Source2EngineToClient001 = 0x5A1B0; } -namespace filesystem_stdio_dll { +namespace FilesystemStdioDll { constexpr std::ptrdiff_t VAsyncFileSystem2_001 = 0x66D30; constexpr std::ptrdiff_t VFileSystem017 = 0x66D20; } -namespace host_dll { +namespace HostDll { constexpr std::ptrdiff_t Source2Host001 = 0x18E10; constexpr std::ptrdiff_t SinglePlayerSharedMemory001 = 0x18A90; constexpr std::ptrdiff_t SaveRestoreDataVersion001 = 0x18A80; @@ -74,25 +74,25 @@ namespace host_dll { constexpr std::ptrdiff_t DebugDrawQueueManager001 = 0x11710; } -namespace imemanager_dll { +namespace ImemanagerDll { constexpr std::ptrdiff_t IMEManager001 = 0xC470; } -namespace inputsystem_dll { +namespace InputsystemDll { constexpr std::ptrdiff_t InputSystemVersion001 = 0x28D0; constexpr std::ptrdiff_t InputStackSystemVersion001 = 0x16F0; } -namespace localize_dll { +namespace LocalizeDll { constexpr std::ptrdiff_t Localize_001 = 0x3830; } -namespace matchmaking_dll { +namespace MatchmakingDll { constexpr std::ptrdiff_t GameTypes001 = 0x50270; constexpr std::ptrdiff_t MATCHFRAMEWORK_001 = 0x101030; } -namespace materialsystem2_dll { +namespace Materialsystem2Dll { constexpr std::ptrdiff_t MaterialUtils_001 = 0x4DB80; constexpr std::ptrdiff_t TextLayout_001 = 0x4A2D0; constexpr std::ptrdiff_t PostProcessingSystem_001 = 0x42A50; @@ -100,67 +100,67 @@ namespace materialsystem2_dll { constexpr std::ptrdiff_t VMaterialSystem2_001 = 0x25EB0; } -namespace meshsystem_dll { +namespace MeshsystemDll { constexpr std::ptrdiff_t MeshSystem001 = 0x7270; } -namespace navsystem_dll { +namespace NavsystemDll { constexpr std::ptrdiff_t NavSystem001 = 0x76F0; } -namespace networksystem_dll { +namespace NetworksystemDll { constexpr std::ptrdiff_t SerializedEntitiesVersion001 = 0xD1A60; constexpr std::ptrdiff_t NetworkSystemVersion001 = 0xBBF70; constexpr std::ptrdiff_t NetworkMessagesVersion001 = 0x9C010; constexpr std::ptrdiff_t FlattenedSerializersVersion001 = 0x7B890; } -namespace panorama_dll { +namespace PanoramaDll { constexpr std::ptrdiff_t PanoramaUIEngine001 = 0x57EE0; } -namespace panorama_text_pango_dll { +namespace PanoramaTextPangoDll { constexpr std::ptrdiff_t PanoramaTextServices001 = 0x4CBD0; } -namespace panoramauiclient_dll { +namespace PanoramauiclientDll { constexpr std::ptrdiff_t PanoramaUIClient001 = 0x12780; } -namespace particles_dll { +namespace ParticlesDll { constexpr std::ptrdiff_t ParticleSystemMgr003 = 0x52D20; } -namespace pulse_system_dll { +namespace PulseSystemDll { constexpr std::ptrdiff_t IPulseSystem_001 = 0x5B80; } -namespace rendersystemdx11_dll { +namespace Rendersystemdx11Dll { constexpr std::ptrdiff_t RenderUtils_001 = 0x52C90; constexpr std::ptrdiff_t VRenderDeviceMgrBackdoor001 = 0x4A3A0; constexpr std::ptrdiff_t RenderDeviceMgr001 = 0x4A390; } -namespace resourcesystem_dll { +namespace ResourcesystemDll { constexpr std::ptrdiff_t ResourceSystem013 = 0x10650; } -namespace scenefilecache_dll { +namespace ScenefilecacheDll { constexpr std::ptrdiff_t SceneFileCache002 = 0x68E0; constexpr std::ptrdiff_t ResponseRulesCache001 = 0x3190; } -namespace scenesystem_dll { +namespace ScenesystemDll { constexpr std::ptrdiff_t SceneUtils_001 = 0x13D030; constexpr std::ptrdiff_t SceneSystem_002 = 0xCAE10; constexpr std::ptrdiff_t RenderingPipelines_001 = 0x8EED0; } -namespace schemasystem_dll { +namespace SchemasystemDll { constexpr std::ptrdiff_t SchemaSystem_001 = 0xA930; } -namespace server_dll { +namespace ServerDll { constexpr std::ptrdiff_t NavGameTest001 = 0xA2C470; constexpr std::ptrdiff_t ServerToolsInfo_001 = 0x830DE0; constexpr std::ptrdiff_t Source2GameClients001 = 0x830DF0; @@ -173,18 +173,18 @@ namespace server_dll { constexpr std::ptrdiff_t Source2GameDirector001 = 0x13EAB0; } -namespace soundsystem_dll { +namespace SoundsystemDll { constexpr std::ptrdiff_t SoundOpSystem001 = 0x156160; constexpr std::ptrdiff_t SoundOpSystemEdit001 = 0x8B540; constexpr std::ptrdiff_t VMixEditTool001 = 0x71740; constexpr std::ptrdiff_t SoundSystem001 = 0x46540; } -namespace steamaudio_dll { +namespace SteamaudioDll { constexpr std::ptrdiff_t SteamAudio001 = 0x12EE0; } -namespace steamclient64_dll { +namespace Steamclient64Dll { constexpr std::ptrdiff_t IVALIDATE001 = 0x833640; constexpr std::ptrdiff_t CLIENTENGINE_INTERFACE_VERSION005 = 0x82F4C0; constexpr std::ptrdiff_t SteamClient020 = 0x62CAF0; @@ -206,39 +206,39 @@ namespace steamclient64_dll { constexpr std::ptrdiff_t p2pvoicesingleton002 = 0xD5840; } -namespace tier0_dll { +namespace Tier0Dll { constexpr std::ptrdiff_t VStringTokenSystem001 = 0x18C390; constexpr std::ptrdiff_t TestScriptMgr001 = 0x13F6F0; constexpr std::ptrdiff_t VProcessUtils002 = 0x12F870; constexpr std::ptrdiff_t VEngineCvar007 = 0x61C50; } -namespace v8system_dll { +namespace V8SystemDll { constexpr std::ptrdiff_t Source2V8System001 = 0x1670; } -namespace valve_avi_dll { +namespace ValveAviDll { constexpr std::ptrdiff_t VAvi001 = 0x2F90; } -namespace valve_wmf_dll { +namespace ValveWmfDll { constexpr std::ptrdiff_t VMediaFoundation001 = 0x12D0; } -namespace vphysics2_dll { +namespace Vphysics2Dll { constexpr std::ptrdiff_t VPhysics2_Handle_Interface_001 = 0x5FA50; constexpr std::ptrdiff_t VPhysics2_Interface_001 = 0x5B7F0; } -namespace vscript_dll { +namespace VscriptDll { constexpr std::ptrdiff_t VScriptManager010 = 0x31DA0; } -namespace vstdlib_s64_dll { +namespace VstdlibS64Dll { constexpr std::ptrdiff_t IVALIDATE001 = 0x24FF0; constexpr std::ptrdiff_t VEngineCvar002 = 0x5750; } -namespace worldrenderer_dll { +namespace WorldrendererDll { constexpr std::ptrdiff_t WorldRendererMgr001 = 0x21530; } \ No newline at end of file diff --git a/generated/interfaces.json b/generated/interfaces.json index 38b7b96..5e6267e 100644 --- a/generated/interfaces.json +++ b/generated/interfaces.json @@ -1,9 +1,9 @@ { - "animationsystem_dll": { + "AnimationsystemDll": { "AnimationSystemUtils_001": 411248, "AnimationSystem_001": 389584 }, - "client_dll": { + "ClientDll": { "ClientToolsInfo_001": 7501168, "EmptyWorldService001_Client": 4764128, "GameClientExports001": 7501184, @@ -13,7 +13,7 @@ "Source2ClientPrediction001": 7976544, "Source2ClientUI001": 8904192 }, - "engine2_dll": { + "Engine2Dll": { "BenchmarkService001": 1476576, "BugService001": 1482768, "ClientServerEngineLoopService_001": 1931584, @@ -47,11 +47,11 @@ "VENGINE_GAMEUIFUNCS_VERSION005": 1139648, "VProfService_001": 1796112 }, - "filesystem_stdio_dll": { + "FilesystemStdioDll": { "VAsyncFileSystem2_001": 421168, "VFileSystem017": 421152 }, - "host_dll": { + "HostDll": { "DebugDrawQueueManager001": 71440, "GameModelInfo001": 72896, "GameSystem2HostHook": 73120, @@ -61,75 +61,75 @@ "SinglePlayerSharedMemory001": 101008, "Source2Host001": 101904 }, - "imemanager_dll": { + "ImemanagerDll": { "IMEManager001": 50288 }, - "inputsystem_dll": { + "InputsystemDll": { "InputStackSystemVersion001": 5872, "InputSystemVersion001": 10448 }, - "localize_dll": { + "LocalizeDll": { "Localize_001": 14384 }, - "matchmaking_dll": { + "MatchmakingDll": { "GameTypes001": 328304, "MATCHFRAMEWORK_001": 1052720 }, - "materialsystem2_dll": { + "Materialsystem2Dll": { "FontManager_001": 227568, "MaterialUtils_001": 318336, "PostProcessingSystem_001": 272976, "TextLayout_001": 303824, "VMaterialSystem2_001": 155312 }, - "meshsystem_dll": { + "MeshsystemDll": { "MeshSystem001": 29296 }, - "navsystem_dll": { + "NavsystemDll": { "NavSystem001": 30448 }, - "networksystem_dll": { + "NetworksystemDll": { "FlattenedSerializersVersion001": 506000, "NetworkMessagesVersion001": 638992, "NetworkSystemVersion001": 769904, "SerializedEntitiesVersion001": 858720 }, - "panorama_dll": { + "PanoramaDll": { "PanoramaUIEngine001": 360160 }, - "panorama_text_pango_dll": { + "PanoramaTextPangoDll": { "PanoramaTextServices001": 314320 }, - "panoramauiclient_dll": { + "PanoramauiclientDll": { "PanoramaUIClient001": 75648 }, - "particles_dll": { + "ParticlesDll": { "ParticleSystemMgr003": 339232 }, - "pulse_system_dll": { + "PulseSystemDll": { "IPulseSystem_001": 23424 }, - "rendersystemdx11_dll": { + "Rendersystemdx11Dll": { "RenderDeviceMgr001": 304016, "RenderUtils_001": 339088, "VRenderDeviceMgrBackdoor001": 304032 }, - "resourcesystem_dll": { + "ResourcesystemDll": { "ResourceSystem013": 67152 }, - "scenefilecache_dll": { + "ScenefilecacheDll": { "ResponseRulesCache001": 12688, "SceneFileCache002": 26848 }, - "scenesystem_dll": { + "ScenesystemDll": { "RenderingPipelines_001": 585424, "SceneSystem_002": 830992, "SceneUtils_001": 1298480 }, - "schemasystem_dll": { + "SchemasystemDll": { "SchemaSystem_001": 43312 }, - "server_dll": { + "ServerDll": { "EmptyWorldService001_Server": 5798064, "EntitySubclassUtilsV001": 2916880, "NavGameTest001": 10667120, @@ -141,16 +141,16 @@ "Source2ServerConfig001": 5666992, "customnavsystem001": 2379184 }, - "soundsystem_dll": { + "SoundsystemDll": { "SoundOpSystem001": 1401184, "SoundOpSystemEdit001": 570688, "SoundSystem001": 288064, "VMixEditTool001": 464704 }, - "steamaudio_dll": { + "SteamaudioDll": { "SteamAudio001": 77536 }, - "steamclient64_dll": { + "Steamclient64Dll": { "CLIENTENGINE_INTERFACE_VERSION005": 8582336, "IVALIDATE001": 8599104, "SteamClient006": 6474256, @@ -171,33 +171,33 @@ "p2pvoice002": 888480, "p2pvoicesingleton002": 874560 }, - "tier0_dll": { + "Tier0Dll": { "TestScriptMgr001": 1308400, "VEngineCvar007": 400464, "VProcessUtils002": 1243248, "VStringTokenSystem001": 1622928 }, - "v8system_dll": { + "V8SystemDll": { "Source2V8System001": 5744 }, - "valve_avi_dll": { + "ValveAviDll": { "VAvi001": 12176 }, - "valve_wmf_dll": { + "ValveWmfDll": { "VMediaFoundation001": 4816 }, - "vphysics2_dll": { + "Vphysics2Dll": { "VPhysics2_Handle_Interface_001": 391760, "VPhysics2_Interface_001": 374768 }, - "vscript_dll": { + "VscriptDll": { "VScriptManager010": 204192 }, - "vstdlib_s64_dll": { + "VstdlibS64Dll": { "IVALIDATE001": 151536, "VEngineCvar002": 22352 }, - "worldrenderer_dll": { + "WorldrendererDll": { "WorldRendererMgr001": 136496 } } \ No newline at end of file diff --git a/generated/interfaces.py b/generated/interfaces.py new file mode 100644 index 0000000..e65e520 --- /dev/null +++ b/generated/interfaces.py @@ -0,0 +1,205 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:51.722997500 UTC +''' + +class AnimationsystemDll: + AnimationSystemUtils_001 = 0x64670 + AnimationSystem_001 = 0x5F1D0 + +class ClientDll: + LegacyGameUI001 = 0x88F360 + Source2ClientUI001 = 0x87DE00 + Source2ClientPrediction001 = 0x79B660 + ClientToolsInfo_001 = 0x727570 + Source2Client002 = 0x727590 + GameClientExports001 = 0x727580 + EmptyWorldService001_Client = 0x48B1E0 + Source2ClientConfig001 = 0x4721F0 + +class Engine2Dll: + SimpleEngineLoopService_001 = 0x1E1C70 + ClientServerEngineLoopService_001 = 0x1D7940 + KeyValueCache001 = 0x1D3F80 + HostStateMgr001 = 0x1D1990 + GameEventSystemServerV001 = 0x1CD050 + GameEventSystemClientV001 = 0x1CD040 + EngineServiceMgr001 = 0x1C8D30 + VProfService_001 = 0x1B6810 + ToolService_001 = 0x1B5560 + StatsService_001 = 0x1B07E0 + SplitScreenService_001 = 0x1ADA50 + SoundService_001 = 0x1A85A0 + ScreenshotService001 = 0x1A4470 + RenderService_001 = 0x1A17D0 + NetworkService_001 = 0x1A12E0 + NetworkServerService_001 = 0x19C380 + NetworkP2PService_001 = 0x197D90 + NetworkClientService_001 = 0x1919C0 + MapListService_001 = 0x18A990 + InputService_001 = 0x1787D0 + GameUIService_001 = 0x173290 + GameResourceServiceServerV001 = 0x170FF0 + GameResourceServiceClientV001 = 0x170FE0 + BugService001 = 0x16A010 + BenchmarkService001 = 0x1687E0 + VENGINE_GAMEUIFUNCS_VERSION005 = 0x1163C0 + EngineGameUI001 = 0x115750 + INETSUPPORT_001 = 0xE59D0 + Source2EngineToServerStringTable001 = 0xA0B50 + Source2EngineToServer001 = 0x8AA40 + Source2EngineToClientStringTable001 = 0x83760 + Source2EngineToClient001 = 0x5A1B0 + +class FilesystemStdioDll: + VAsyncFileSystem2_001 = 0x66D30 + VFileSystem017 = 0x66D20 + +class HostDll: + Source2Host001 = 0x18E10 + SinglePlayerSharedMemory001 = 0x18A90 + SaveRestoreDataVersion001 = 0x18A80 + PredictionDiffManager001 = 0x16E20 + HostUtils001 = 0x12550 + GameSystem2HostHook = 0x11DA0 + GameModelInfo001 = 0x11CC0 + DebugDrawQueueManager001 = 0x11710 + +class ImemanagerDll: + IMEManager001 = 0xC470 + +class InputsystemDll: + InputSystemVersion001 = 0x28D0 + InputStackSystemVersion001 = 0x16F0 + +class LocalizeDll: + Localize_001 = 0x3830 + +class MatchmakingDll: + GameTypes001 = 0x50270 + MATCHFRAMEWORK_001 = 0x101030 + +class Materialsystem2Dll: + MaterialUtils_001 = 0x4DB80 + TextLayout_001 = 0x4A2D0 + PostProcessingSystem_001 = 0x42A50 + FontManager_001 = 0x378F0 + VMaterialSystem2_001 = 0x25EB0 + +class MeshsystemDll: + MeshSystem001 = 0x7270 + +class NavsystemDll: + NavSystem001 = 0x76F0 + +class NetworksystemDll: + SerializedEntitiesVersion001 = 0xD1A60 + NetworkSystemVersion001 = 0xBBF70 + NetworkMessagesVersion001 = 0x9C010 + FlattenedSerializersVersion001 = 0x7B890 + +class PanoramaDll: + PanoramaUIEngine001 = 0x57EE0 + +class PanoramaTextPangoDll: + PanoramaTextServices001 = 0x4CBD0 + +class PanoramauiclientDll: + PanoramaUIClient001 = 0x12780 + +class ParticlesDll: + ParticleSystemMgr003 = 0x52D20 + +class PulseSystemDll: + IPulseSystem_001 = 0x5B80 + +class Rendersystemdx11Dll: + RenderUtils_001 = 0x52C90 + VRenderDeviceMgrBackdoor001 = 0x4A3A0 + RenderDeviceMgr001 = 0x4A390 + +class ResourcesystemDll: + ResourceSystem013 = 0x10650 + +class ScenefilecacheDll: + SceneFileCache002 = 0x68E0 + ResponseRulesCache001 = 0x3190 + +class ScenesystemDll: + SceneUtils_001 = 0x13D030 + SceneSystem_002 = 0xCAE10 + RenderingPipelines_001 = 0x8EED0 + +class SchemasystemDll: + SchemaSystem_001 = 0xA930 + +class ServerDll: + NavGameTest001 = 0xA2C470 + ServerToolsInfo_001 = 0x830DE0 + Source2GameClients001 = 0x830DF0 + Source2GameEntities001 = 0x830E00 + Source2Server001 = 0x830E10 + EmptyWorldService001_Server = 0x5878B0 + Source2ServerConfig001 = 0x5678B0 + EntitySubclassUtilsV001 = 0x2C8210 + customnavsystem001 = 0x244DB0 + Source2GameDirector001 = 0x13EAB0 + +class SoundsystemDll: + SoundOpSystem001 = 0x156160 + SoundOpSystemEdit001 = 0x8B540 + VMixEditTool001 = 0x71740 + SoundSystem001 = 0x46540 + +class SteamaudioDll: + SteamAudio001 = 0x12EE0 + +class Steamclient64Dll: + IVALIDATE001 = 0x833640 + CLIENTENGINE_INTERFACE_VERSION005 = 0x82F4C0 + SteamClient020 = 0x62CAF0 + SteamClient019 = 0x62CAE0 + SteamClient018 = 0x62CAD0 + SteamClient017 = 0x62CAC0 + SteamClient016 = 0x62CAB0 + SteamClient015 = 0x62CAA0 + SteamClient014 = 0x62CA90 + SteamClient013 = 0x62CA80 + SteamClient012 = 0x62CA70 + SteamClient011 = 0x62CA60 + SteamClient010 = 0x62CA50 + SteamClient009 = 0x62CA40 + SteamClient008 = 0x62CA30 + SteamClient007 = 0x62CA20 + SteamClient006 = 0x62CA10 + p2pvoice002 = 0xD8EA0 + p2pvoicesingleton002 = 0xD5840 + +class Tier0Dll: + VStringTokenSystem001 = 0x18C390 + TestScriptMgr001 = 0x13F6F0 + VProcessUtils002 = 0x12F870 + VEngineCvar007 = 0x61C50 + +class V8SystemDll: + Source2V8System001 = 0x1670 + +class ValveAviDll: + VAvi001 = 0x2F90 + +class ValveWmfDll: + VMediaFoundation001 = 0x12D0 + +class Vphysics2Dll: + VPhysics2_Handle_Interface_001 = 0x5FA50 + VPhysics2_Interface_001 = 0x5B7F0 + +class VscriptDll: + VScriptManager010 = 0x31DA0 + +class VstdlibS64Dll: + IVALIDATE001 = 0x24FF0 + VEngineCvar002 = 0x5750 + +class WorldrendererDll: + WorldRendererMgr001 = 0x21530 diff --git a/generated/interfaces.rs b/generated/interfaces.rs index aa09b80..7a3668c 100644 --- a/generated/interfaces.rs +++ b/generated/interfaces.rs @@ -1,16 +1,16 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:33.225495 UTC + * 2023-10-17 02:04:51.725351400 UTC */ -pub mod animationsystem_dll { +#![allow(non_snake_case, non_upper_case_globals)] + +pub mod AnimationsystemDll { pub const AnimationSystemUtils_001: usize = 0x64670; pub const AnimationSystem_001: usize = 0x5F1D0; } -pub mod client_dll { +pub mod ClientDll { pub const LegacyGameUI001: usize = 0x88F360; pub const Source2ClientUI001: usize = 0x87DE00; pub const Source2ClientPrediction001: usize = 0x79B660; @@ -21,7 +21,7 @@ pub mod client_dll { pub const Source2ClientConfig001: usize = 0x4721F0; } -pub mod engine2_dll { +pub mod Engine2Dll { pub const SimpleEngineLoopService_001: usize = 0x1E1C70; pub const ClientServerEngineLoopService_001: usize = 0x1D7940; pub const KeyValueCache001: usize = 0x1D3F80; @@ -56,12 +56,12 @@ pub mod engine2_dll { pub const Source2EngineToClient001: usize = 0x5A1B0; } -pub mod filesystem_stdio_dll { +pub mod FilesystemStdioDll { pub const VAsyncFileSystem2_001: usize = 0x66D30; pub const VFileSystem017: usize = 0x66D20; } -pub mod host_dll { +pub mod HostDll { pub const Source2Host001: usize = 0x18E10; pub const SinglePlayerSharedMemory001: usize = 0x18A90; pub const SaveRestoreDataVersion001: usize = 0x18A80; @@ -72,25 +72,25 @@ pub mod host_dll { pub const DebugDrawQueueManager001: usize = 0x11710; } -pub mod imemanager_dll { +pub mod ImemanagerDll { pub const IMEManager001: usize = 0xC470; } -pub mod inputsystem_dll { +pub mod InputsystemDll { pub const InputSystemVersion001: usize = 0x28D0; pub const InputStackSystemVersion001: usize = 0x16F0; } -pub mod localize_dll { +pub mod LocalizeDll { pub const Localize_001: usize = 0x3830; } -pub mod matchmaking_dll { +pub mod MatchmakingDll { pub const GameTypes001: usize = 0x50270; pub const MATCHFRAMEWORK_001: usize = 0x101030; } -pub mod materialsystem2_dll { +pub mod Materialsystem2Dll { pub const MaterialUtils_001: usize = 0x4DB80; pub const TextLayout_001: usize = 0x4A2D0; pub const PostProcessingSystem_001: usize = 0x42A50; @@ -98,67 +98,67 @@ pub mod materialsystem2_dll { pub const VMaterialSystem2_001: usize = 0x25EB0; } -pub mod meshsystem_dll { +pub mod MeshsystemDll { pub const MeshSystem001: usize = 0x7270; } -pub mod navsystem_dll { +pub mod NavsystemDll { pub const NavSystem001: usize = 0x76F0; } -pub mod networksystem_dll { +pub mod NetworksystemDll { pub const SerializedEntitiesVersion001: usize = 0xD1A60; pub const NetworkSystemVersion001: usize = 0xBBF70; pub const NetworkMessagesVersion001: usize = 0x9C010; pub const FlattenedSerializersVersion001: usize = 0x7B890; } -pub mod panorama_dll { +pub mod PanoramaDll { pub const PanoramaUIEngine001: usize = 0x57EE0; } -pub mod panorama_text_pango_dll { +pub mod PanoramaTextPangoDll { pub const PanoramaTextServices001: usize = 0x4CBD0; } -pub mod panoramauiclient_dll { +pub mod PanoramauiclientDll { pub const PanoramaUIClient001: usize = 0x12780; } -pub mod particles_dll { +pub mod ParticlesDll { pub const ParticleSystemMgr003: usize = 0x52D20; } -pub mod pulse_system_dll { +pub mod PulseSystemDll { pub const IPulseSystem_001: usize = 0x5B80; } -pub mod rendersystemdx11_dll { +pub mod Rendersystemdx11Dll { pub const RenderUtils_001: usize = 0x52C90; pub const VRenderDeviceMgrBackdoor001: usize = 0x4A3A0; pub const RenderDeviceMgr001: usize = 0x4A390; } -pub mod resourcesystem_dll { +pub mod ResourcesystemDll { pub const ResourceSystem013: usize = 0x10650; } -pub mod scenefilecache_dll { +pub mod ScenefilecacheDll { pub const SceneFileCache002: usize = 0x68E0; pub const ResponseRulesCache001: usize = 0x3190; } -pub mod scenesystem_dll { +pub mod ScenesystemDll { pub const SceneUtils_001: usize = 0x13D030; pub const SceneSystem_002: usize = 0xCAE10; pub const RenderingPipelines_001: usize = 0x8EED0; } -pub mod schemasystem_dll { +pub mod SchemasystemDll { pub const SchemaSystem_001: usize = 0xA930; } -pub mod server_dll { +pub mod ServerDll { pub const NavGameTest001: usize = 0xA2C470; pub const ServerToolsInfo_001: usize = 0x830DE0; pub const Source2GameClients001: usize = 0x830DF0; @@ -171,18 +171,18 @@ pub mod server_dll { pub const Source2GameDirector001: usize = 0x13EAB0; } -pub mod soundsystem_dll { +pub mod SoundsystemDll { pub const SoundOpSystem001: usize = 0x156160; pub const SoundOpSystemEdit001: usize = 0x8B540; pub const VMixEditTool001: usize = 0x71740; pub const SoundSystem001: usize = 0x46540; } -pub mod steamaudio_dll { +pub mod SteamaudioDll { pub const SteamAudio001: usize = 0x12EE0; } -pub mod steamclient64_dll { +pub mod Steamclient64Dll { pub const IVALIDATE001: usize = 0x833640; pub const CLIENTENGINE_INTERFACE_VERSION005: usize = 0x82F4C0; pub const SteamClient020: usize = 0x62CAF0; @@ -204,39 +204,39 @@ pub mod steamclient64_dll { pub const p2pvoicesingleton002: usize = 0xD5840; } -pub mod tier0_dll { +pub mod Tier0Dll { pub const VStringTokenSystem001: usize = 0x18C390; pub const TestScriptMgr001: usize = 0x13F6F0; pub const VProcessUtils002: usize = 0x12F870; pub const VEngineCvar007: usize = 0x61C50; } -pub mod v8system_dll { +pub mod V8SystemDll { pub const Source2V8System001: usize = 0x1670; } -pub mod valve_avi_dll { +pub mod ValveAviDll { pub const VAvi001: usize = 0x2F90; } -pub mod valve_wmf_dll { +pub mod ValveWmfDll { pub const VMediaFoundation001: usize = 0x12D0; } -pub mod vphysics2_dll { +pub mod Vphysics2Dll { pub const VPhysics2_Handle_Interface_001: usize = 0x5FA50; pub const VPhysics2_Interface_001: usize = 0x5B7F0; } -pub mod vscript_dll { +pub mod VscriptDll { pub const VScriptManager010: usize = 0x31DA0; } -pub mod vstdlib_s64_dll { +pub mod VstdlibS64Dll { pub const IVALIDATE001: usize = 0x24FF0; pub const VEngineCvar002: usize = 0x5750; } -pub mod worldrenderer_dll { +pub mod WorldrendererDll { pub const WorldRendererMgr001: usize = 0x21530; } \ No newline at end of file diff --git a/generated/materialsystem2.dll.cs b/generated/materialsystem2.dll.cs index b98b752..299f3ba 100644 --- a/generated/materialsystem2.dll.cs +++ b/generated/materialsystem2.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.387776500 UTC + * 2023-10-17 02:04:49.710835800 UTC */ public static class MaterialParamBuffer_t { diff --git a/generated/materialsystem2.dll.hpp b/generated/materialsystem2.dll.hpp index 0af5442..ded1be2 100644 --- a/generated/materialsystem2.dll.hpp +++ b/generated/materialsystem2.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:49.709221 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.386044300 UTC - */ - namespace MaterialParamBuffer_t { constexpr std::ptrdiff_t m_value = 0x8; // CUtlBinaryBlock } diff --git a/generated/materialsystem2.dll.py b/generated/materialsystem2.dll.py new file mode 100644 index 0000000..13200f8 --- /dev/null +++ b/generated/materialsystem2.dll.py @@ -0,0 +1,98 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:49.712772400 UTC +''' + +class MaterialParamBuffer_t: + m_value = 0x8 # CUtlBinaryBlock + +class MaterialParamFloat_t: + m_flValue = 0x8 # float + +class MaterialParamInt_t: + m_nValue = 0x8 # int32_t + +class MaterialParamString_t: + m_value = 0x8 # CUtlString + +class MaterialParamTexture_t: + m_pValue = 0x8 # CStrongHandle + +class MaterialParamVector_t: + m_value = 0x8 # Vector4D + +class MaterialParam_t: + m_name = 0x0 # CUtlString + +class MaterialResourceData_t: + m_materialName = 0x0 # CUtlString + m_shaderName = 0x8 # CUtlString + m_intParams = 0x10 # CUtlVector + m_floatParams = 0x28 # CUtlVector + m_vectorParams = 0x40 # CUtlVector + m_textureParams = 0x58 # CUtlVector + m_dynamicParams = 0x70 # CUtlVector + m_dynamicTextureParams = 0x88 # CUtlVector + m_intAttributes = 0xA0 # CUtlVector + m_floatAttributes = 0xB8 # CUtlVector + m_vectorAttributes = 0xD0 # CUtlVector + m_textureAttributes = 0xE8 # CUtlVector + m_stringAttributes = 0x100 # CUtlVector + m_renderAttributesUsed = 0x118 # CUtlVector + +class PostProcessingBloomParameters_t: + m_blendMode = 0x0 # BloomBlendMode_t + m_flBloomStrength = 0x4 # float + m_flScreenBloomStrength = 0x8 # float + m_flBlurBloomStrength = 0xC # float + m_flBloomThreshold = 0x10 # float + m_flBloomThresholdWidth = 0x14 # float + m_flSkyboxBloomStrength = 0x18 # float + m_flBloomStartValue = 0x1C # float + m_flBlurWeight = 0x20 # float[5] + m_vBlurTint = 0x34 # Vector[5] + +class PostProcessingLocalContrastParameters_t: + m_flLocalContrastStrength = 0x0 # float + m_flLocalContrastEdgeStrength = 0x4 # float + m_flLocalContrastVignetteStart = 0x8 # float + m_flLocalContrastVignetteEnd = 0xC # float + m_flLocalContrastVignetteBlur = 0x10 # float + +class PostProcessingResource_t: + m_bHasTonemapParams = 0x0 # bool + m_toneMapParams = 0x4 # PostProcessingTonemapParameters_t + m_bHasBloomParams = 0x40 # bool + m_bloomParams = 0x44 # PostProcessingBloomParameters_t + m_bHasVignetteParams = 0xB4 # bool + m_vignetteParams = 0xB8 # PostProcessingVignetteParameters_t + m_bHasLocalContrastParams = 0xDC # bool + m_localConstrastParams = 0xE0 # PostProcessingLocalContrastParameters_t + m_nColorCorrectionVolumeDim = 0xF4 # int32_t + m_colorCorrectionVolumeData = 0xF8 # CUtlBinaryBlock + m_bHasColorCorrection = 0x110 # bool + +class PostProcessingTonemapParameters_t: + m_flExposureBias = 0x0 # float + m_flShoulderStrength = 0x4 # float + m_flLinearStrength = 0x8 # float + m_flLinearAngle = 0xC # float + m_flToeStrength = 0x10 # float + m_flToeNum = 0x14 # float + m_flToeDenom = 0x18 # float + m_flWhitePoint = 0x1C # float + m_flLuminanceSource = 0x20 # float + m_flExposureBiasShadows = 0x24 # float + m_flExposureBiasHighlights = 0x28 # float + m_flMinShadowLum = 0x2C # float + m_flMaxShadowLum = 0x30 # float + m_flMinHighlightLum = 0x34 # float + m_flMaxHighlightLum = 0x38 # float + +class PostProcessingVignetteParameters_t: + m_flVignetteStrength = 0x0 # float + m_vCenter = 0x4 # Vector2D + m_flRadius = 0xC # float + m_flRoundness = 0x10 # float + m_flFeather = 0x14 # float + m_vColorTint = 0x18 # Vector diff --git a/generated/materialsystem2.dll.rs b/generated/materialsystem2.dll.rs index 36c8682..511670d 100644 --- a/generated/materialsystem2.dll.rs +++ b/generated/materialsystem2.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.389748900 UTC + * 2023-10-17 02:04:49.714514100 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod MaterialParamBuffer_t { pub const m_value: usize = 0x8; // CUtlBinaryBlock } diff --git a/generated/networksystem.dll.cs b/generated/networksystem.dll.cs index ddc64cf..0b3f610 100644 --- a/generated/networksystem.dll.cs +++ b/generated/networksystem.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.392118600 UTC + * 2023-10-17 02:04:49.716792200 UTC */ public static class ChangeAccessorFieldPathIndex_t { diff --git a/generated/networksystem.dll.hpp b/generated/networksystem.dll.hpp index 9a2013b..0a32e4e 100644 --- a/generated/networksystem.dll.hpp +++ b/generated/networksystem.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:49.716408300 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.391722300 UTC - */ - namespace ChangeAccessorFieldPathIndex_t { constexpr std::ptrdiff_t m_Value = 0x0; // int16_t } \ No newline at end of file diff --git a/generated/networksystem.dll.py b/generated/networksystem.dll.py new file mode 100644 index 0000000..baa28c9 --- /dev/null +++ b/generated/networksystem.dll.py @@ -0,0 +1,7 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:49.717532700 UTC +''' + +class ChangeAccessorFieldPathIndex_t: + m_Value = 0x0 # int16_t diff --git a/generated/networksystem.dll.rs b/generated/networksystem.dll.rs index 2abff74..f2c2d31 100644 --- a/generated/networksystem.dll.rs +++ b/generated/networksystem.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.392830500 UTC + * 2023-10-17 02:04:49.717926 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod ChangeAccessorFieldPathIndex_t { pub const m_Value: usize = 0x0; // int16_t } \ No newline at end of file diff --git a/generated/offsets.cs b/generated/offsets.cs index bb36b25..8054e1f 100644 --- a/generated/offsets.cs +++ b/generated/offsets.cs @@ -1,9 +1,9 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:33.672128500 UTC + * 2023-10-17 02:04:52.170660100 UTC */ -public static class client_dll { +public static class ClientDll { public const nint dwEntityList = 0x178FC88; public const nint dwForceAttack = 0x1696DF0; public const nint dwForceAttack2 = 0x1696E80; @@ -25,7 +25,7 @@ public static class client_dll { public const nint dwViewRender = 0x187E4A8; } -public static class engine2_dll { +public static class Engine2Dll { public const nint dwBuildNumber = 0x487514; public const nint dwNetworkGameClient = 0x486AB0; public const nint dwNetworkGameClient_getLocalPlayer = 0xF0; diff --git a/generated/offsets.hpp b/generated/offsets.hpp index 5d4b2e6..b6bfa9b 100644 --- a/generated/offsets.hpp +++ b/generated/offsets.hpp @@ -1,13 +1,13 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:52.169744400 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:33.670867800 UTC - */ - -namespace client_dll { +namespace ClientDll { constexpr std::ptrdiff_t dwEntityList = 0x178FC88; constexpr std::ptrdiff_t dwForceAttack = 0x1696DF0; constexpr std::ptrdiff_t dwForceAttack2 = 0x1696E80; @@ -29,7 +29,7 @@ namespace client_dll { constexpr std::ptrdiff_t dwViewRender = 0x187E4A8; } -namespace engine2_dll { +namespace Engine2Dll { constexpr std::ptrdiff_t dwBuildNumber = 0x487514; constexpr std::ptrdiff_t dwNetworkGameClient = 0x486AB0; constexpr std::ptrdiff_t dwNetworkGameClient_getLocalPlayer = 0xF0; diff --git a/generated/offsets.json b/generated/offsets.json index 285f5d8..2a83cf0 100644 --- a/generated/offsets.json +++ b/generated/offsets.json @@ -1,5 +1,5 @@ { - "client_dll": { + "ClientDll": { "dwEntityList": 24706184, "dwForceAttack": 23686640, "dwForceAttack2": 23686784, @@ -20,7 +20,7 @@ "dwViewMatrix": 25680560, "dwViewRender": 25683112 }, - "engine2_dll": { + "Engine2Dll": { "dwBuildNumber": 4748564, "dwNetworkGameClient": 4745904, "dwNetworkGameClient_getLocalPlayer": 240, diff --git a/generated/offsets.py b/generated/offsets.py new file mode 100644 index 0000000..0cd6fba --- /dev/null +++ b/generated/offsets.py @@ -0,0 +1,34 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:52.171902400 UTC +''' + +class ClientDll: + dwEntityList = 0x178FC88 + dwForceAttack = 0x1696DF0 + dwForceAttack2 = 0x1696E80 + dwForceBackward = 0x16970C0 + dwForceCrouch = 0x1697390 + dwForceForward = 0x1697030 + dwForceJump = 0x1697300 + dwForceLeft = 0x1697150 + dwForceRight = 0x16971E0 + dwGameRules = 0x17EB818 + dwGlobalVars = 0x1692EE8 + dwGlowManager = 0x17EAF98 + dwInterfaceLinkList = 0x1976138 + dwLocalPlayerController = 0x17DE508 + dwLocalPlayerPawn = 0x187CFC8 + dwPlantedC4 = 0x18838C0 + dwViewAngles = 0x18DCAF0 + dwViewMatrix = 0x187DAB0 + dwViewRender = 0x187E4A8 + +class Engine2Dll: + dwBuildNumber = 0x487514 + dwNetworkGameClient = 0x486AB0 + dwNetworkGameClient_getLocalPlayer = 0xF0 + dwNetworkGameClient_maxClients = 0x250 + dwNetworkGameClient_signOnState = 0x240 + dwWindowHeight = 0x538674 + dwWindowWidth = 0x538670 diff --git a/generated/offsets.rs b/generated/offsets.rs index 391c882..fcfb97d 100644 --- a/generated/offsets.rs +++ b/generated/offsets.rs @@ -1,11 +1,11 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:33.673543400 UTC + * 2023-10-17 02:04:52.173110500 UTC */ -pub mod client_dll { +#![allow(non_snake_case, non_upper_case_globals)] + +pub mod ClientDll { pub const dwEntityList: usize = 0x178FC88; pub const dwForceAttack: usize = 0x1696DF0; pub const dwForceAttack2: usize = 0x1696E80; @@ -27,7 +27,7 @@ pub mod client_dll { pub const dwViewRender: usize = 0x187E4A8; } -pub mod engine2_dll { +pub mod Engine2Dll { pub const dwBuildNumber: usize = 0x487514; pub const dwNetworkGameClient: usize = 0x486AB0; pub const dwNetworkGameClient_getLocalPlayer: usize = 0xF0; diff --git a/generated/particles.dll.cs b/generated/particles.dll.cs index 5709f13..535ba59 100644 --- a/generated/particles.dll.cs +++ b/generated/particles.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.967344 UTC + * 2023-10-17 02:04:50.348555300 UTC */ public static class CBaseRendererSource2 { diff --git a/generated/particles.dll.hpp b/generated/particles.dll.hpp index 869e3e1..6ad6d99 100644 --- a/generated/particles.dll.hpp +++ b/generated/particles.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:50.309640 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.927930 UTC - */ - namespace CBaseRendererSource2 { constexpr std::ptrdiff_t m_flRadiusScale = 0x200; // CParticleCollectionRendererFloatInput constexpr std::ptrdiff_t m_flAlphaScale = 0x358; // CParticleCollectionRendererFloatInput diff --git a/generated/particles.dll.py b/generated/particles.dll.py new file mode 100644 index 0000000..004a2fb --- /dev/null +++ b/generated/particles.dll.py @@ -0,0 +1,3506 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:50.389547900 UTC +''' + +class CBaseRendererSource2: + m_flRadiusScale = 0x200 # CParticleCollectionRendererFloatInput + m_flAlphaScale = 0x358 # CParticleCollectionRendererFloatInput + m_flRollScale = 0x4B0 # CParticleCollectionRendererFloatInput + m_nAlpha2Field = 0x608 # ParticleAttributeIndex_t + m_vecColorScale = 0x610 # CParticleCollectionRendererVecInput + m_nColorBlendType = 0xC68 # ParticleColorBlendType_t + m_nShaderType = 0xC6C # SpriteCardShaderType_t + m_strShaderOverride = 0xC70 # CUtlString + m_flCenterXOffset = 0xC78 # CParticleCollectionRendererFloatInput + m_flCenterYOffset = 0xDD0 # CParticleCollectionRendererFloatInput + m_flBumpStrength = 0xF28 # float + m_nCropTextureOverride = 0xF2C # ParticleSequenceCropOverride_t + m_vecTexturesInput = 0xF30 # CUtlVector + m_flAnimationRate = 0xF48 # float + m_nAnimationType = 0xF4C # AnimationType_t + m_bAnimateInFPS = 0xF50 # bool + m_flSelfIllumAmount = 0xF58 # CParticleCollectionRendererFloatInput + m_flDiffuseAmount = 0x10B0 # CParticleCollectionRendererFloatInput + m_nLightingControlPoint = 0x1208 # int32_t + m_nSelfIllumPerParticle = 0x120C # ParticleAttributeIndex_t + m_nOutputBlendMode = 0x1210 # ParticleOutputBlendMode_t + m_bGammaCorrectVertexColors = 0x1214 # bool + m_bSaturateColorPreAlphaBlend = 0x1215 # bool + m_flAddSelfAmount = 0x1218 # CParticleCollectionRendererFloatInput + m_flDesaturation = 0x1370 # CParticleCollectionRendererFloatInput + m_flOverbrightFactor = 0x14C8 # CParticleCollectionRendererFloatInput + m_nHSVShiftControlPoint = 0x1620 # int32_t + m_nFogType = 0x1624 # ParticleFogType_t + m_flFogAmount = 0x1628 # CParticleCollectionRendererFloatInput + m_bTintByFOW = 0x1780 # bool + m_bTintByGlobalLight = 0x1781 # bool + m_nPerParticleAlphaReference = 0x1784 # SpriteCardPerParticleScale_t + m_nPerParticleAlphaRefWindow = 0x1788 # SpriteCardPerParticleScale_t + m_nAlphaReferenceType = 0x178C # ParticleAlphaReferenceType_t + m_flAlphaReferenceSoftness = 0x1790 # CParticleCollectionRendererFloatInput + m_flSourceAlphaValueToMapToZero = 0x18E8 # CParticleCollectionRendererFloatInput + m_flSourceAlphaValueToMapToOne = 0x1A40 # CParticleCollectionRendererFloatInput + m_bRefract = 0x1B98 # bool + m_bRefractSolid = 0x1B99 # bool + m_flRefractAmount = 0x1BA0 # CParticleCollectionRendererFloatInput + m_nRefractBlurRadius = 0x1CF8 # int32_t + m_nRefractBlurType = 0x1CFC # BlurFilterType_t + m_bOnlyRenderInEffectsBloomPass = 0x1D00 # bool + m_bOnlyRenderInEffectsWaterPass = 0x1D01 # bool + m_bUseMixedResolutionRendering = 0x1D02 # bool + m_bOnlyRenderInEffecsGameOverlay = 0x1D03 # bool + m_stencilTestID = 0x1D04 # char[128] + m_bStencilTestExclude = 0x1D84 # bool + m_stencilWriteID = 0x1D85 # char[128] + m_bWriteStencilOnDepthPass = 0x1E05 # bool + m_bWriteStencilOnDepthFail = 0x1E06 # bool + m_bReverseZBuffering = 0x1E07 # bool + m_bDisableZBuffering = 0x1E08 # bool + m_nFeatheringMode = 0x1E0C # ParticleDepthFeatheringMode_t + m_flFeatheringMinDist = 0x1E10 # CParticleCollectionRendererFloatInput + m_flFeatheringMaxDist = 0x1F68 # CParticleCollectionRendererFloatInput + m_flFeatheringFilter = 0x20C0 # CParticleCollectionRendererFloatInput + m_flDepthBias = 0x2218 # float + m_nSortMethod = 0x221C # ParticleSortingChoiceList_t + m_bBlendFramesSeq0 = 0x2220 # bool + m_bMaxLuminanceBlendingSequence0 = 0x2221 # bool + +class CBaseTrailRenderer: + m_nOrientationType = 0x2470 # ParticleOrientationChoiceList_t + m_nOrientationControlPoint = 0x2474 # int32_t + m_flMinSize = 0x2478 # float + m_flMaxSize = 0x247C # float + m_flStartFadeSize = 0x2480 # CParticleCollectionRendererFloatInput + m_flEndFadeSize = 0x25D8 # CParticleCollectionRendererFloatInput + m_bClampV = 0x2730 # bool + +class CGeneralRandomRotation: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flDegrees = 0x1C4 # float + m_flDegreesMin = 0x1C8 # float + m_flDegreesMax = 0x1CC # float + m_flRotationRandExponent = 0x1D0 # float + m_bRandomlyFlipDirection = 0x1D4 # bool + +class CGeneralSpin: + m_nSpinRateDegrees = 0x1C0 # int32_t + m_nSpinRateMinDegrees = 0x1C4 # int32_t + m_fSpinRateStopTime = 0x1CC # float + +class CNewParticleEffect: + m_pNext = 0x10 # CNewParticleEffect* + m_pPrev = 0x18 # CNewParticleEffect* + m_pParticles = 0x20 # IParticleCollection* + m_pDebugName = 0x28 # char* + m_bDontRemove = 0x0 # bitfield:1 + m_bRemove = 0x0 # bitfield:1 + m_bNeedsBBoxUpdate = 0x0 # bitfield:1 + m_bIsFirstFrame = 0x0 # bitfield:1 + m_bAutoUpdateBBox = 0x0 # bitfield:1 + m_bAllocated = 0x0 # bitfield:1 + m_bSimulate = 0x0 # bitfield:1 + m_bShouldPerformCullCheck = 0x0 # bitfield:1 + m_bForceNoDraw = 0x0 # bitfield:1 + m_bShouldSave = 0x0 # bitfield:1 + m_bDisableAggregation = 0x0 # bitfield:1 + m_bShouldSimulateDuringGamePaused = 0x0 # bitfield:1 + m_bShouldCheckFoW = 0x0 # bitfield:1 + m_vSortOrigin = 0x40 # Vector + m_flScale = 0x4C # float + m_hOwner = 0x50 # PARTICLE_EHANDLE__* + m_pOwningParticleProperty = 0x58 # CParticleProperty* + m_flFreezeTransitionStart = 0x70 # float + m_flFreezeTransitionDuration = 0x74 # float + m_flFreezeTransitionOverride = 0x78 # float + m_bFreezeTransitionActive = 0x7C # bool + m_bFreezeTargetState = 0x7D # bool + m_bCanFreeze = 0x7E # bool + m_LastMin = 0x80 # Vector + m_LastMax = 0x8C # Vector + m_nSplitScreenUser = 0x98 # CSplitScreenSlot + m_vecAggregationCenter = 0x9C # Vector + m_RefCount = 0xC0 # int32_t + +class CParticleFloatInput: + m_nType = 0x10 # ParticleFloatType_t + m_nMapType = 0x14 # ParticleFloatMapType_t + m_flLiteralValue = 0x18 # float + m_NamedValue = 0x20 # CParticleNamedValueRef + m_nControlPoint = 0x60 # int32_t + m_nScalarAttribute = 0x64 # ParticleAttributeIndex_t + m_nVectorAttribute = 0x68 # ParticleAttributeIndex_t + m_nVectorComponent = 0x6C # int32_t + m_flRandomMin = 0x70 # float + m_flRandomMax = 0x74 # float + m_bHasRandomSignFlip = 0x78 # bool + m_nRandomSeed = 0x7C # int32_t + m_nRandomMode = 0x80 # ParticleFloatRandomMode_t + m_flLOD0 = 0x88 # float + m_flLOD1 = 0x8C # float + m_flLOD2 = 0x90 # float + m_flLOD3 = 0x94 # float + m_nNoiseInputVectorAttribute = 0x98 # ParticleAttributeIndex_t + m_flNoiseOutputMin = 0x9C # float + m_flNoiseOutputMax = 0xA0 # float + m_flNoiseScale = 0xA4 # float + m_vecNoiseOffsetRate = 0xA8 # Vector + m_flNoiseOffset = 0xB4 # float + m_nNoiseOctaves = 0xB8 # int32_t + m_nNoiseTurbulence = 0xBC # PFNoiseTurbulence_t + m_nNoiseType = 0xC0 # PFNoiseType_t + m_nNoiseModifier = 0xC4 # PFNoiseModifier_t + m_flNoiseTurbulenceScale = 0xC8 # float + m_flNoiseTurbulenceMix = 0xCC # float + m_flNoiseImgPreviewScale = 0xD0 # float + m_bNoiseImgPreviewLive = 0xD4 # bool + m_flNoCameraFallback = 0xE0 # float + m_bUseBoundsCenter = 0xE4 # bool + m_nInputMode = 0xE8 # ParticleFloatInputMode_t + m_flMultFactor = 0xEC # float + m_flInput0 = 0xF0 # float + m_flInput1 = 0xF4 # float + m_flOutput0 = 0xF8 # float + m_flOutput1 = 0xFC # float + m_flNotchedRangeMin = 0x100 # float + m_flNotchedRangeMax = 0x104 # float + m_flNotchedOutputOutside = 0x108 # float + m_flNotchedOutputInside = 0x10C # float + m_nBiasType = 0x110 # ParticleFloatBiasType_t + m_flBiasParameter = 0x114 # float + m_Curve = 0x118 # CPiecewiseCurve + +class CParticleFunction: + m_flOpStrength = 0x8 # CParticleCollectionFloatInput + m_nOpEndCapState = 0x160 # ParticleEndcapMode_t + m_flOpStartFadeInTime = 0x164 # float + m_flOpEndFadeInTime = 0x168 # float + m_flOpStartFadeOutTime = 0x16C # float + m_flOpEndFadeOutTime = 0x170 # float + m_flOpFadeOscillatePeriod = 0x174 # float + m_bNormalizeToStopTime = 0x178 # bool + m_flOpTimeOffsetMin = 0x17C # float + m_flOpTimeOffsetMax = 0x180 # float + m_nOpTimeOffsetSeed = 0x184 # int32_t + m_nOpTimeScaleSeed = 0x188 # int32_t + m_flOpTimeScaleMin = 0x18C # float + m_flOpTimeScaleMax = 0x190 # float + m_bDisableOperator = 0x196 # bool + m_Notes = 0x198 # CUtlString + +class CParticleFunctionEmitter: + m_nEmitterIndex = 0x1B8 # int32_t + +class CParticleFunctionInitializer: + m_nAssociatedEmitterIndex = 0x1B8 # int32_t + +class CParticleFunctionPreEmission: + m_bRunOnce = 0x1C0 # bool + +class CParticleFunctionRenderer: + VisibilityInputs = 0x1B8 # CParticleVisibilityInputs + m_bCannotBeRefracted = 0x1FC # bool + m_bSkipRenderingOnMobile = 0x1FD # bool + +class CParticleModelInput: + m_nType = 0x10 # ParticleModelType_t + m_NamedValue = 0x18 # CParticleNamedValueRef + m_nControlPoint = 0x58 # int32_t + +class CParticleSystemDefinition: + m_nBehaviorVersion = 0x8 # int32_t + m_PreEmissionOperators = 0x10 # CUtlVector + m_Emitters = 0x28 # CUtlVector + m_Initializers = 0x40 # CUtlVector + m_Operators = 0x58 # CUtlVector + m_ForceGenerators = 0x70 # CUtlVector + m_Constraints = 0x88 # CUtlVector + m_Renderers = 0xA0 # CUtlVector + m_Children = 0xB8 # CUtlVector + m_nFirstMultipleOverride_BackwardCompat = 0x178 # int32_t + m_nInitialParticles = 0x210 # int32_t + m_nMaxParticles = 0x214 # int32_t + m_nGroupID = 0x218 # int32_t + m_BoundingBoxMin = 0x21C # Vector + m_BoundingBoxMax = 0x228 # Vector + m_flDepthSortBias = 0x234 # float + m_nSortOverridePositionCP = 0x238 # int32_t + m_bInfiniteBounds = 0x23C # bool + m_bEnableNamedValues = 0x23D # bool + m_NamedValueDomain = 0x240 # CUtlString + m_NamedValueLocals = 0x248 # CUtlVector + m_ConstantColor = 0x260 # Color + m_ConstantNormal = 0x264 # Vector + m_flConstantRadius = 0x270 # float + m_flConstantRotation = 0x274 # float + m_flConstantRotationSpeed = 0x278 # float + m_flConstantLifespan = 0x27C # float + m_nConstantSequenceNumber = 0x280 # int32_t + m_nConstantSequenceNumber1 = 0x284 # int32_t + m_nSnapshotControlPoint = 0x288 # int32_t + m_hSnapshot = 0x290 # CStrongHandle + m_pszCullReplacementName = 0x298 # CStrongHandle + m_flCullRadius = 0x2A0 # float + m_flCullFillCost = 0x2A4 # float + m_nCullControlPoint = 0x2A8 # int32_t + m_hFallback = 0x2B0 # CStrongHandle + m_nFallbackMaxCount = 0x2B8 # int32_t + m_hLowViolenceDef = 0x2C0 # CStrongHandle + m_hReferenceReplacement = 0x2C8 # CStrongHandle + m_flPreSimulationTime = 0x2D0 # float + m_flStopSimulationAfterTime = 0x2D4 # float + m_flMaximumTimeStep = 0x2D8 # float + m_flMaximumSimTime = 0x2DC # float + m_flMinimumSimTime = 0x2E0 # float + m_flMinimumTimeStep = 0x2E4 # float + m_nMinimumFrames = 0x2E8 # int32_t + m_nMinCPULevel = 0x2EC # int32_t + m_nMinGPULevel = 0x2F0 # int32_t + m_flNoDrawTimeToGoToSleep = 0x2F4 # float + m_flMaxDrawDistance = 0x2F8 # float + m_flStartFadeDistance = 0x2FC # float + m_flMaxCreationDistance = 0x300 # float + m_nAggregationMinAvailableParticles = 0x304 # int32_t + m_flAggregateRadius = 0x308 # float + m_bShouldBatch = 0x30C # bool + m_bShouldHitboxesFallbackToRenderBounds = 0x30D # bool + m_bShouldHitboxesFallbackToSnapshot = 0x30E # bool + m_nViewModelEffect = 0x310 # InheritableBoolType_t + m_bScreenSpaceEffect = 0x314 # bool + m_pszTargetLayerID = 0x318 # CUtlSymbolLarge + m_nSkipRenderControlPoint = 0x320 # int32_t + m_nAllowRenderControlPoint = 0x324 # int32_t + m_bShouldSort = 0x328 # bool + m_controlPointConfigurations = 0x370 # CUtlVector + +class CParticleTransformInput: + m_nType = 0x10 # ParticleTransformType_t + m_NamedValue = 0x18 # CParticleNamedValueRef + m_bFollowNamedValue = 0x58 # bool + m_bSupportsDisabled = 0x59 # bool + m_bUseOrientation = 0x5A # bool + m_nControlPoint = 0x5C # int32_t + m_nControlPointRangeMax = 0x60 # int32_t + m_flEndCPGrowthTime = 0x64 # float + +class CParticleVariableRef: + m_variableName = 0x0 # CKV3MemberNameWithStorage + m_variableType = 0x38 # PulseValueType_t + +class CParticleVecInput: + m_nType = 0x10 # ParticleVecType_t + m_vLiteralValue = 0x14 # Vector + m_LiteralColor = 0x20 # Color + m_NamedValue = 0x28 # CParticleNamedValueRef + m_bFollowNamedValue = 0x68 # bool + m_nVectorAttribute = 0x6C # ParticleAttributeIndex_t + m_vVectorAttributeScale = 0x70 # Vector + m_nControlPoint = 0x7C # int32_t + m_nDeltaControlPoint = 0x80 # int32_t + m_vCPValueScale = 0x84 # Vector + m_vCPRelativePosition = 0x90 # Vector + m_vCPRelativeDir = 0x9C # Vector + m_FloatComponentX = 0xA8 # CParticleFloatInput + m_FloatComponentY = 0x200 # CParticleFloatInput + m_FloatComponentZ = 0x358 # CParticleFloatInput + m_FloatInterp = 0x4B0 # CParticleFloatInput + m_flInterpInput0 = 0x608 # float + m_flInterpInput1 = 0x60C # float + m_vInterpOutput0 = 0x610 # Vector + m_vInterpOutput1 = 0x61C # Vector + m_Gradient = 0x628 # CColorGradient + m_vRandomMin = 0x640 # Vector + m_vRandomMax = 0x64C # Vector + +class CParticleVisibilityInputs: + m_flCameraBias = 0x0 # float + m_nCPin = 0x4 # int32_t + m_flProxyRadius = 0x8 # float + m_flInputMin = 0xC # float + m_flInputMax = 0x10 # float + m_flNoPixelVisibilityFallback = 0x14 # float + m_flDistanceInputMin = 0x18 # float + m_flDistanceInputMax = 0x1C # float + m_flDotInputMin = 0x20 # float + m_flDotInputMax = 0x24 # float + m_bDotCPAngles = 0x28 # bool + m_bDotCameraAngles = 0x29 # bool + m_flAlphaScaleMin = 0x2C # float + m_flAlphaScaleMax = 0x30 # float + m_flRadiusScaleMin = 0x34 # float + m_flRadiusScaleMax = 0x38 # float + m_flRadiusScaleFOVBase = 0x3C # float + m_bRightEye = 0x40 # bool + +class CPathParameters: + m_nStartControlPointNumber = 0x0 # int32_t + m_nEndControlPointNumber = 0x4 # int32_t + m_nBulgeControl = 0x8 # int32_t + m_flBulge = 0xC # float + m_flMidPoint = 0x10 # float + m_vStartPointOffset = 0x14 # Vector + m_vMidPointOffset = 0x20 # Vector + m_vEndOffset = 0x2C # Vector + +class CRandomNumberGeneratorParameters: + m_bDistributeEvenly = 0x0 # bool + m_nSeed = 0x4 # int32_t + +class C_INIT_AddVectorToVector: + m_vecScale = 0x1C0 # Vector + m_nFieldOutput = 0x1CC # ParticleAttributeIndex_t + m_nFieldInput = 0x1D0 # ParticleAttributeIndex_t + m_vOffsetMin = 0x1D4 # Vector + m_vOffsetMax = 0x1E0 # Vector + m_randomnessParameters = 0x1EC # CRandomNumberGeneratorParameters + +class C_INIT_AgeNoise: + m_bAbsVal = 0x1C0 # bool + m_bAbsValInv = 0x1C1 # bool + m_flOffset = 0x1C4 # float + m_flAgeMin = 0x1C8 # float + m_flAgeMax = 0x1CC # float + m_flNoiseScale = 0x1D0 # float + m_flNoiseScaleLoc = 0x1D4 # float + m_vecOffsetLoc = 0x1D8 # Vector + +class C_INIT_ChaoticAttractor: + m_flAParm = 0x1C0 # float + m_flBParm = 0x1C4 # float + m_flCParm = 0x1C8 # float + m_flDParm = 0x1CC # float + m_flScale = 0x1D0 # float + m_flSpeedMin = 0x1D4 # float + m_flSpeedMax = 0x1D8 # float + m_nBaseCP = 0x1DC # int32_t + m_bUniformSpeed = 0x1E0 # bool + +class C_INIT_ColorLitPerParticle: + m_ColorMin = 0x1D8 # Color + m_ColorMax = 0x1DC # Color + m_TintMin = 0x1E0 # Color + m_TintMax = 0x1E4 # Color + m_flTintPerc = 0x1E8 # float + m_nTintBlendMode = 0x1EC # ParticleColorBlendMode_t + m_flLightAmplification = 0x1F0 # float + +class C_INIT_CreateAlongPath: + m_fMaxDistance = 0x1C0 # float + m_PathParams = 0x1D0 # CPathParameters + m_bUseRandomCPs = 0x210 # bool + m_vEndOffset = 0x214 # Vector + m_bSaveOffset = 0x220 # bool + +class C_INIT_CreateFromCPs: + m_nIncrement = 0x1C0 # int32_t + m_nMinCP = 0x1C4 # int32_t + m_nMaxCP = 0x1C8 # int32_t + m_nDynamicCPCount = 0x1D0 # CParticleCollectionFloatInput + +class C_INIT_CreateFromParentParticles: + m_flVelocityScale = 0x1C0 # float + m_flIncrement = 0x1C4 # float + m_bRandomDistribution = 0x1C8 # bool + m_nRandomSeed = 0x1CC # int32_t + m_bSubFrame = 0x1D0 # bool + +class C_INIT_CreateFromPlaneCache: + m_vecOffsetMin = 0x1C0 # Vector + m_vecOffsetMax = 0x1CC # Vector + m_bUseNormal = 0x1D9 # bool + +class C_INIT_CreateInEpitrochoid: + m_nComponent1 = 0x1C0 # int32_t + m_nComponent2 = 0x1C4 # int32_t + m_TransformInput = 0x1C8 # CParticleTransformInput + m_flParticleDensity = 0x230 # CPerParticleFloatInput + m_flOffset = 0x388 # CPerParticleFloatInput + m_flRadius1 = 0x4E0 # CPerParticleFloatInput + m_flRadius2 = 0x638 # CPerParticleFloatInput + m_bUseCount = 0x790 # bool + m_bUseLocalCoords = 0x791 # bool + m_bOffsetExistingPos = 0x792 # bool + +class C_INIT_CreateOnGrid: + m_nXCount = 0x1C0 # CParticleCollectionFloatInput + m_nYCount = 0x318 # CParticleCollectionFloatInput + m_nZCount = 0x470 # CParticleCollectionFloatInput + m_nXSpacing = 0x5C8 # CParticleCollectionFloatInput + m_nYSpacing = 0x720 # CParticleCollectionFloatInput + m_nZSpacing = 0x878 # CParticleCollectionFloatInput + m_nControlPointNumber = 0x9D0 # int32_t + m_bLocalSpace = 0x9D4 # bool + m_bCenter = 0x9D5 # bool + m_bHollow = 0x9D6 # bool + +class C_INIT_CreateOnModel: + m_modelInput = 0x1C0 # CParticleModelInput + m_transformInput = 0x220 # CParticleTransformInput + m_nForceInModel = 0x288 # int32_t + m_nDesiredHitbox = 0x28C # int32_t + m_nHitboxValueFromControlPointIndex = 0x290 # int32_t + m_vecHitBoxScale = 0x298 # CParticleCollectionVecInput + m_flBoneVelocity = 0x8F0 # float + m_flMaxBoneVelocity = 0x8F4 # float + m_vecDirectionBias = 0x8F8 # CParticleCollectionVecInput + m_HitboxSetName = 0xF50 # char[128] + m_bLocalCoords = 0xFD0 # bool + m_bUseBones = 0xFD1 # bool + m_flShellSize = 0xFD8 # CParticleCollectionFloatInput + +class C_INIT_CreateOnModelAtHeight: + m_bUseBones = 0x1C0 # bool + m_bForceZ = 0x1C1 # bool + m_nControlPointNumber = 0x1C4 # int32_t + m_nHeightCP = 0x1C8 # int32_t + m_bUseWaterHeight = 0x1CC # bool + m_flDesiredHeight = 0x1D0 # CParticleCollectionFloatInput + m_vecHitBoxScale = 0x328 # CParticleCollectionVecInput + m_vecDirectionBias = 0x980 # CParticleCollectionVecInput + m_nBiasType = 0xFD8 # ParticleHitboxBiasType_t + m_bLocalCoords = 0xFDC # bool + m_bPreferMovingBoxes = 0xFDD # bool + m_HitboxSetName = 0xFDE # char[128] + m_flHitboxVelocityScale = 0x1060 # CParticleCollectionFloatInput + m_flMaxBoneVelocity = 0x11B8 # CParticleCollectionFloatInput + +class C_INIT_CreateParticleImpulse: + m_InputRadius = 0x1C0 # CPerParticleFloatInput + m_InputMagnitude = 0x318 # CPerParticleFloatInput + m_nFalloffFunction = 0x470 # ParticleFalloffFunction_t + m_InputFalloffExp = 0x478 # CPerParticleFloatInput + m_nImpulseType = 0x5D0 # ParticleImpulseType_t + +class C_INIT_CreatePhyllotaxis: + m_nControlPointNumber = 0x1C0 # int32_t + m_nScaleCP = 0x1C4 # int32_t + m_nComponent = 0x1C8 # int32_t + m_fRadCentCore = 0x1CC # float + m_fRadPerPoint = 0x1D0 # float + m_fRadPerPointTo = 0x1D4 # float + m_fpointAngle = 0x1D8 # float + m_fsizeOverall = 0x1DC # float + m_fRadBias = 0x1E0 # float + m_fMinRad = 0x1E4 # float + m_fDistBias = 0x1E8 # float + m_bUseLocalCoords = 0x1EC # bool + m_bUseWithContEmit = 0x1ED # bool + m_bUseOrigRadius = 0x1EE # bool + +class C_INIT_CreateSequentialPath: + m_fMaxDistance = 0x1C0 # float + m_flNumToAssign = 0x1C4 # float + m_bLoop = 0x1C8 # bool + m_bCPPairs = 0x1C9 # bool + m_bSaveOffset = 0x1CA # bool + m_PathParams = 0x1D0 # CPathParameters + +class C_INIT_CreateSequentialPathV2: + m_fMaxDistance = 0x1C0 # CPerParticleFloatInput + m_flNumToAssign = 0x318 # CParticleCollectionFloatInput + m_bLoop = 0x470 # bool + m_bCPPairs = 0x471 # bool + m_bSaveOffset = 0x472 # bool + m_PathParams = 0x480 # CPathParameters + +class C_INIT_CreateSpiralSphere: + m_nControlPointNumber = 0x1C0 # int32_t + m_nOverrideCP = 0x1C4 # int32_t + m_nDensity = 0x1C8 # int32_t + m_flInitialRadius = 0x1CC # float + m_flInitialSpeedMin = 0x1D0 # float + m_flInitialSpeedMax = 0x1D4 # float + m_bUseParticleCount = 0x1D8 # bool + +class C_INIT_CreateWithinBox: + m_vecMin = 0x1C0 # CPerParticleVecInput + m_vecMax = 0x818 # CPerParticleVecInput + m_nControlPointNumber = 0xE70 # int32_t + m_bLocalSpace = 0xE74 # bool + m_randomnessParameters = 0xE78 # CRandomNumberGeneratorParameters + +class C_INIT_CreateWithinSphereTransform: + m_fRadiusMin = 0x1C0 # CPerParticleFloatInput + m_fRadiusMax = 0x318 # CPerParticleFloatInput + m_vecDistanceBias = 0x470 # CPerParticleVecInput + m_vecDistanceBiasAbs = 0xAC8 # Vector + m_TransformInput = 0xAD8 # CParticleTransformInput + m_fSpeedMin = 0xB40 # CPerParticleFloatInput + m_fSpeedMax = 0xC98 # CPerParticleFloatInput + m_fSpeedRandExp = 0xDF0 # float + m_bLocalCoords = 0xDF4 # bool + m_flEndCPGrowthTime = 0xDF8 # float + m_LocalCoordinateSystemSpeedMin = 0xE00 # CPerParticleVecInput + m_LocalCoordinateSystemSpeedMax = 0x1458 # CPerParticleVecInput + m_nFieldOutput = 0x1AB0 # ParticleAttributeIndex_t + m_nFieldVelocity = 0x1AB4 # ParticleAttributeIndex_t + +class C_INIT_CreationNoise: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_bAbsVal = 0x1C4 # bool + m_bAbsValInv = 0x1C5 # bool + m_flOffset = 0x1C8 # float + m_flOutputMin = 0x1CC # float + m_flOutputMax = 0x1D0 # float + m_flNoiseScale = 0x1D4 # float + m_flNoiseScaleLoc = 0x1D8 # float + m_vecOffsetLoc = 0x1DC # Vector + m_flWorldTimeScale = 0x1E8 # float + +class C_INIT_DistanceCull: + m_nControlPoint = 0x1C0 # int32_t + m_flDistance = 0x1C8 # CParticleCollectionFloatInput + m_bCullInside = 0x320 # bool + +class C_INIT_DistanceToCPInit: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # CPerParticleFloatInput + m_flInputMax = 0x320 # CPerParticleFloatInput + m_flOutputMin = 0x478 # CPerParticleFloatInput + m_flOutputMax = 0x5D0 # CPerParticleFloatInput + m_nStartCP = 0x728 # int32_t + m_bLOS = 0x72C # bool + m_CollisionGroupName = 0x72D # char[128] + m_nTraceSet = 0x7B0 # ParticleTraceSet_t + m_flMaxTraceLength = 0x7B8 # CPerParticleFloatInput + m_flLOSScale = 0x910 # float + m_nSetMethod = 0x914 # ParticleSetMethod_t + m_bActiveRange = 0x918 # bool + m_vecDistanceScale = 0x91C # Vector + m_flRemapBias = 0x928 # float + +class C_INIT_DistanceToNeighborCull: + m_flDistance = 0x1C0 # CPerParticleFloatInput + +class C_INIT_GlobalScale: + m_flScale = 0x1C0 # float + m_nScaleControlPointNumber = 0x1C4 # int32_t + m_nControlPointNumber = 0x1C8 # int32_t + m_bScaleRadius = 0x1CC # bool + m_bScalePosition = 0x1CD # bool + m_bScaleVelocity = 0x1CE # bool + +class C_INIT_InheritFromParentParticles: + m_flScale = 0x1C0 # float + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nIncrement = 0x1C8 # int32_t + m_bRandomDistribution = 0x1CC # bool + m_nRandomSeed = 0x1D0 # int32_t + +class C_INIT_InheritVelocity: + m_nControlPointNumber = 0x1C0 # int32_t + m_flVelocityScale = 0x1C4 # float + +class C_INIT_InitFloat: + m_InputValue = 0x1C0 # CPerParticleFloatInput + m_nOutputField = 0x318 # ParticleAttributeIndex_t + m_nSetMethod = 0x31C # ParticleSetMethod_t + m_InputStrength = 0x320 # CPerParticleFloatInput + +class C_INIT_InitFloatCollection: + m_InputValue = 0x1C0 # CParticleCollectionFloatInput + m_nOutputField = 0x318 # ParticleAttributeIndex_t + +class C_INIT_InitFromCPSnapshot: + m_nControlPointNumber = 0x1C0 # int32_t + m_nAttributeToRead = 0x1C4 # ParticleAttributeIndex_t + m_nAttributeToWrite = 0x1C8 # ParticleAttributeIndex_t + m_nLocalSpaceCP = 0x1CC # int32_t + m_bRandom = 0x1D0 # bool + m_bReverse = 0x1D1 # bool + m_nSnapShotIncrement = 0x1D8 # CParticleCollectionFloatInput + m_nManualSnapshotIndex = 0x330 # CPerParticleFloatInput + m_nRandomSeed = 0x488 # int32_t + m_bLocalSpaceAngles = 0x48C # bool + +class C_INIT_InitFromParentKilled: + m_nAttributeToCopy = 0x1C0 # ParticleAttributeIndex_t + +class C_INIT_InitFromVectorFieldSnapshot: + m_nControlPointNumber = 0x1C0 # int32_t + m_nLocalSpaceCP = 0x1C4 # int32_t + m_nWeightUpdateCP = 0x1C8 # int32_t + m_bUseVerticalVelocity = 0x1CC # bool + m_vecScale = 0x1D0 # CPerParticleVecInput + +class C_INIT_InitSkinnedPositionFromCPSnapshot: + m_nSnapshotControlPointNumber = 0x1C0 # int32_t + m_nControlPointNumber = 0x1C4 # int32_t + m_bRandom = 0x1C8 # bool + m_nRandomSeed = 0x1CC # int32_t + m_bRigid = 0x1D0 # bool + m_bSetNormal = 0x1D1 # bool + m_bIgnoreDt = 0x1D2 # bool + m_flMinNormalVelocity = 0x1D4 # float + m_flMaxNormalVelocity = 0x1D8 # float + m_flIncrement = 0x1DC # float + m_nFullLoopIncrement = 0x1E0 # int32_t + m_nSnapShotStartPoint = 0x1E4 # int32_t + m_flBoneVelocity = 0x1E8 # float + m_flBoneVelocityMax = 0x1EC # float + m_bCopyColor = 0x1F0 # bool + m_bCopyAlpha = 0x1F1 # bool + m_bSetRadius = 0x1F2 # bool + +class C_INIT_InitVec: + m_InputValue = 0x1C0 # CPerParticleVecInput + m_nOutputField = 0x818 # ParticleAttributeIndex_t + m_nSetMethod = 0x81C # ParticleSetMethod_t + m_bNormalizedOutput = 0x820 # bool + m_bWritePreviousPosition = 0x821 # bool + +class C_INIT_InitVecCollection: + m_InputValue = 0x1C0 # CParticleCollectionVecInput + m_nOutputField = 0x818 # ParticleAttributeIndex_t + +class C_INIT_InitialRepulsionVelocity: + m_CollisionGroupName = 0x1C0 # char[128] + m_nTraceSet = 0x240 # ParticleTraceSet_t + m_vecOutputMin = 0x244 # Vector + m_vecOutputMax = 0x250 # Vector + m_nControlPointNumber = 0x25C # int32_t + m_bPerParticle = 0x260 # bool + m_bTranslate = 0x261 # bool + m_bProportional = 0x262 # bool + m_flTraceLength = 0x264 # float + m_bPerParticleTR = 0x268 # bool + m_bInherit = 0x269 # bool + m_nChildCP = 0x26C # int32_t + m_nChildGroupID = 0x270 # int32_t + +class C_INIT_InitialSequenceFromModel: + m_nControlPointNumber = 0x1C0 # int32_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nFieldOutputAnim = 0x1C8 # ParticleAttributeIndex_t + m_flInputMin = 0x1CC # float + m_flInputMax = 0x1D0 # float + m_flOutputMin = 0x1D4 # float + m_flOutputMax = 0x1D8 # float + m_nSetMethod = 0x1DC # ParticleSetMethod_t + +class C_INIT_InitialVelocityFromHitbox: + m_flVelocityMin = 0x1C0 # float + m_flVelocityMax = 0x1C4 # float + m_nControlPointNumber = 0x1C8 # int32_t + m_HitboxSetName = 0x1CC # char[128] + m_bUseBones = 0x24C # bool + +class C_INIT_InitialVelocityNoise: + m_vecAbsVal = 0x1C0 # Vector + m_vecAbsValInv = 0x1CC # Vector + m_vecOffsetLoc = 0x1D8 # CPerParticleVecInput + m_flOffset = 0x830 # CPerParticleFloatInput + m_vecOutputMin = 0x988 # CPerParticleVecInput + m_vecOutputMax = 0xFE0 # CPerParticleVecInput + m_flNoiseScale = 0x1638 # CPerParticleFloatInput + m_flNoiseScaleLoc = 0x1790 # CPerParticleFloatInput + m_TransformInput = 0x18E8 # CParticleTransformInput + m_bIgnoreDt = 0x1950 # bool + +class C_INIT_LifespanFromVelocity: + m_vecComponentScale = 0x1C0 # Vector + m_flTraceOffset = 0x1CC # float + m_flMaxTraceLength = 0x1D0 # float + m_flTraceTolerance = 0x1D4 # float + m_nMaxPlanes = 0x1D8 # int32_t + m_CollisionGroupName = 0x1E0 # char[128] + m_nTraceSet = 0x260 # ParticleTraceSet_t + m_bIncludeWater = 0x270 # bool + +class C_INIT_ModelCull: + m_nControlPointNumber = 0x1C0 # int32_t + m_bBoundBox = 0x1C4 # bool + m_bCullOutside = 0x1C5 # bool + m_bUseBones = 0x1C6 # bool + m_HitboxSetName = 0x1C7 # char[128] + +class C_INIT_MoveBetweenPoints: + m_flSpeedMin = 0x1C0 # CPerParticleFloatInput + m_flSpeedMax = 0x318 # CPerParticleFloatInput + m_flEndSpread = 0x470 # CPerParticleFloatInput + m_flStartOffset = 0x5C8 # CPerParticleFloatInput + m_flEndOffset = 0x720 # CPerParticleFloatInput + m_nEndControlPointNumber = 0x878 # int32_t + m_bTrailBias = 0x87C # bool + +class C_INIT_NormalAlignToCP: + m_transformInput = 0x1C0 # CParticleTransformInput + m_nControlPointAxis = 0x228 # ParticleControlPointAxis_t + +class C_INIT_NormalOffset: + m_OffsetMin = 0x1C0 # Vector + m_OffsetMax = 0x1CC # Vector + m_nControlPointNumber = 0x1D8 # int32_t + m_bLocalCoords = 0x1DC # bool + m_bNormalize = 0x1DD # bool + +class C_INIT_OffsetVectorToVector: + m_nFieldInput = 0x1C0 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_vecOutputMin = 0x1C8 # Vector + m_vecOutputMax = 0x1D4 # Vector + m_randomnessParameters = 0x1E0 # CRandomNumberGeneratorParameters + +class C_INIT_Orient2DRelToCP: + m_nCP = 0x1C0 # int32_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flRotOffset = 0x1C8 # float + +class C_INIT_PlaneCull: + m_nControlPoint = 0x1C0 # int32_t + m_flDistance = 0x1C8 # CParticleCollectionFloatInput + m_bCullInside = 0x320 # bool + +class C_INIT_PointList: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_pointList = 0x1C8 # CUtlVector + m_bPlaceAlongPath = 0x1E0 # bool + m_bClosedLoop = 0x1E1 # bool + m_nNumPointsAlongPath = 0x1E4 # int32_t + +class C_INIT_PositionOffset: + m_OffsetMin = 0x1C0 # CPerParticleVecInput + m_OffsetMax = 0x818 # CPerParticleVecInput + m_TransformInput = 0xE70 # CParticleTransformInput + m_bLocalCoords = 0xED8 # bool + m_bProportional = 0xED9 # bool + m_randomnessParameters = 0xEDC # CRandomNumberGeneratorParameters + +class C_INIT_PositionOffsetToCP: + m_nControlPointNumberStart = 0x1C0 # int32_t + m_nControlPointNumberEnd = 0x1C4 # int32_t + m_bLocalCoords = 0x1C8 # bool + +class C_INIT_PositionPlaceOnGround: + m_flOffset = 0x1C0 # CPerParticleFloatInput + m_flMaxTraceLength = 0x318 # CPerParticleFloatInput + m_CollisionGroupName = 0x470 # char[128] + m_nTraceSet = 0x4F0 # ParticleTraceSet_t + m_nTraceMissBehavior = 0x500 # ParticleTraceMissBehavior_t + m_bIncludeWater = 0x504 # bool + m_bSetNormal = 0x505 # bool + m_bSetPXYZOnly = 0x506 # bool + m_bTraceAlongNormal = 0x507 # bool + m_bOffsetonColOnly = 0x508 # bool + m_flOffsetByRadiusFactor = 0x50C # float + m_nPreserveOffsetCP = 0x510 # int32_t + m_nIgnoreCP = 0x514 # int32_t + +class C_INIT_PositionWarp: + m_vecWarpMin = 0x1C0 # CParticleCollectionVecInput + m_vecWarpMax = 0x818 # CParticleCollectionVecInput + m_nScaleControlPointNumber = 0xE70 # int32_t + m_nControlPointNumber = 0xE74 # int32_t + m_nRadiusComponent = 0xE78 # int32_t + m_flWarpTime = 0xE7C # float + m_flWarpStartTime = 0xE80 # float + m_flPrevPosScale = 0xE84 # float + m_bInvertWarp = 0xE88 # bool + m_bUseCount = 0xE89 # bool + +class C_INIT_PositionWarpScalar: + m_vecWarpMin = 0x1C0 # Vector + m_vecWarpMax = 0x1CC # Vector + m_InputValue = 0x1D8 # CPerParticleFloatInput + m_flPrevPosScale = 0x330 # float + m_nScaleControlPointNumber = 0x334 # int32_t + m_nControlPointNumber = 0x338 # int32_t + +class C_INIT_QuantizeFloat: + m_InputValue = 0x1C0 # CPerParticleFloatInput + m_nOutputField = 0x318 # ParticleAttributeIndex_t + +class C_INIT_RadiusFromCPObject: + m_nControlPoint = 0x1C0 # int32_t + +class C_INIT_RandomAlpha: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_nAlphaMin = 0x1C4 # int32_t + m_nAlphaMax = 0x1C8 # int32_t + m_flAlphaRandExponent = 0x1D4 # float + +class C_INIT_RandomAlphaWindowThreshold: + m_flMin = 0x1C0 # float + m_flMax = 0x1C4 # float + m_flExponent = 0x1C8 # float + +class C_INIT_RandomColor: + m_ColorMin = 0x1DC # Color + m_ColorMax = 0x1E0 # Color + m_TintMin = 0x1E4 # Color + m_TintMax = 0x1E8 # Color + m_flTintPerc = 0x1EC # float + m_flUpdateThreshold = 0x1F0 # float + m_nTintCP = 0x1F4 # int32_t + m_nFieldOutput = 0x1F8 # ParticleAttributeIndex_t + m_nTintBlendMode = 0x1FC # ParticleColorBlendMode_t + m_flLightAmplification = 0x200 # float + +class C_INIT_RandomLifeTime: + m_fLifetimeMin = 0x1C0 # float + m_fLifetimeMax = 0x1C4 # float + m_fLifetimeRandExponent = 0x1C8 # float + +class C_INIT_RandomModelSequence: + m_ActivityName = 0x1C0 # char[256] + m_SequenceName = 0x2C0 # char[256] + m_hModel = 0x3C0 # CStrongHandle + +class C_INIT_RandomNamedModelElement: + m_hModel = 0x1C0 # CStrongHandle + m_names = 0x1C8 # CUtlVector + m_bShuffle = 0x1E0 # bool + m_bLinear = 0x1E1 # bool + m_bModelFromRenderer = 0x1E2 # bool + m_nFieldOutput = 0x1E4 # ParticleAttributeIndex_t + +class C_INIT_RandomRadius: + m_flRadiusMin = 0x1C0 # float + m_flRadiusMax = 0x1C4 # float + m_flRadiusRandExponent = 0x1C8 # float + +class C_INIT_RandomScalar: + m_flMin = 0x1C0 # float + m_flMax = 0x1C4 # float + m_flExponent = 0x1C8 # float + m_nFieldOutput = 0x1CC # ParticleAttributeIndex_t + +class C_INIT_RandomSecondSequence: + m_nSequenceMin = 0x1C0 # int32_t + m_nSequenceMax = 0x1C4 # int32_t + +class C_INIT_RandomSequence: + m_nSequenceMin = 0x1C0 # int32_t + m_nSequenceMax = 0x1C4 # int32_t + m_bShuffle = 0x1C8 # bool + m_bLinear = 0x1C9 # bool + m_WeightedList = 0x1D0 # CUtlVector + +class C_INIT_RandomTrailLength: + m_flMinLength = 0x1C0 # float + m_flMaxLength = 0x1C4 # float + m_flLengthRandExponent = 0x1C8 # float + +class C_INIT_RandomVector: + m_vecMin = 0x1C0 # Vector + m_vecMax = 0x1CC # Vector + m_nFieldOutput = 0x1D8 # ParticleAttributeIndex_t + m_randomnessParameters = 0x1DC # CRandomNumberGeneratorParameters + +class C_INIT_RandomVectorComponent: + m_flMin = 0x1C0 # float + m_flMax = 0x1C4 # float + m_nFieldOutput = 0x1C8 # ParticleAttributeIndex_t + m_nComponent = 0x1CC # int32_t + +class C_INIT_RandomYawFlip: + m_flPercent = 0x1C0 # float + +class C_INIT_RemapCPtoScalar: + m_nCPInput = 0x1C0 # int32_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nField = 0x1C8 # int32_t + m_flInputMin = 0x1CC # float + m_flInputMax = 0x1D0 # float + m_flOutputMin = 0x1D4 # float + m_flOutputMax = 0x1D8 # float + m_flStartTime = 0x1DC # float + m_flEndTime = 0x1E0 # float + m_nSetMethod = 0x1E4 # ParticleSetMethod_t + m_flRemapBias = 0x1E8 # float + +class C_INIT_RemapInitialDirectionToTransformToVector: + m_TransformInput = 0x1C0 # CParticleTransformInput + m_nFieldOutput = 0x228 # ParticleAttributeIndex_t + m_flScale = 0x22C # float + m_flOffsetRot = 0x230 # float + m_vecOffsetAxis = 0x234 # Vector + m_bNormalize = 0x240 # bool + +class C_INIT_RemapInitialTransformDirectionToRotation: + m_TransformInput = 0x1C0 # CParticleTransformInput + m_nFieldOutput = 0x228 # ParticleAttributeIndex_t + m_flOffsetRot = 0x22C # float + m_nComponent = 0x230 # int32_t + +class C_INIT_RemapInitialVisibilityScalar: + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # float + m_flInputMax = 0x1CC # float + m_flOutputMin = 0x1D0 # float + m_flOutputMax = 0x1D4 # float + +class C_INIT_RemapNamedModelElementToScalar: + m_hModel = 0x1C0 # CStrongHandle + m_names = 0x1C8 # CUtlVector + m_values = 0x1E0 # CUtlVector + m_nFieldInput = 0x1F8 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1FC # ParticleAttributeIndex_t + m_nSetMethod = 0x200 # ParticleSetMethod_t + m_bModelFromRenderer = 0x204 # bool + +class C_INIT_RemapParticleCountToNamedModelElementScalar: + m_hModel = 0x1F0 # CStrongHandle + m_outputMinName = 0x1F8 # CUtlString + m_outputMaxName = 0x200 # CUtlString + m_bModelFromRenderer = 0x208 # bool + +class C_INIT_RemapParticleCountToScalar: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_nInputMin = 0x1C4 # int32_t + m_nInputMax = 0x1C8 # int32_t + m_nScaleControlPoint = 0x1CC # int32_t + m_nScaleControlPointField = 0x1D0 # int32_t + m_flOutputMin = 0x1D4 # float + m_flOutputMax = 0x1D8 # float + m_nSetMethod = 0x1DC # ParticleSetMethod_t + m_bActiveRange = 0x1E0 # bool + m_bInvert = 0x1E1 # bool + m_bWrap = 0x1E2 # bool + m_flRemapBias = 0x1E4 # float + +class C_INIT_RemapQAnglesToRotation: + m_TransformInput = 0x1C0 # CParticleTransformInput + +class C_INIT_RemapScalar: + m_nFieldInput = 0x1C0 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # float + m_flInputMax = 0x1CC # float + m_flOutputMin = 0x1D0 # float + m_flOutputMax = 0x1D4 # float + m_flStartTime = 0x1D8 # float + m_flEndTime = 0x1DC # float + m_nSetMethod = 0x1E0 # ParticleSetMethod_t + m_bActiveRange = 0x1E4 # bool + m_flRemapBias = 0x1E8 # float + +class C_INIT_RemapScalarToVector: + m_nFieldInput = 0x1C0 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # float + m_flInputMax = 0x1CC # float + m_vecOutputMin = 0x1D0 # Vector + m_vecOutputMax = 0x1DC # Vector + m_flStartTime = 0x1E8 # float + m_flEndTime = 0x1EC # float + m_nSetMethod = 0x1F0 # ParticleSetMethod_t + m_nControlPointNumber = 0x1F4 # int32_t + m_bLocalCoords = 0x1F8 # bool + m_flRemapBias = 0x1FC # float + +class C_INIT_RemapSpeedToScalar: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_nControlPointNumber = 0x1C4 # int32_t + m_flStartTime = 0x1C8 # float + m_flEndTime = 0x1CC # float + m_flInputMin = 0x1D0 # float + m_flInputMax = 0x1D4 # float + m_flOutputMin = 0x1D8 # float + m_flOutputMax = 0x1DC # float + m_nSetMethod = 0x1E0 # ParticleSetMethod_t + m_bPerParticle = 0x1E4 # bool + +class C_INIT_RemapTransformOrientationToRotations: + m_TransformInput = 0x1C0 # CParticleTransformInput + m_vecRotation = 0x228 # Vector + m_bUseQuat = 0x234 # bool + m_bWriteNormal = 0x235 # bool + +class C_INIT_RemapTransformToVector: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_vInputMin = 0x1C4 # Vector + m_vInputMax = 0x1D0 # Vector + m_vOutputMin = 0x1DC # Vector + m_vOutputMax = 0x1E8 # Vector + m_TransformInput = 0x1F8 # CParticleTransformInput + m_LocalSpaceTransform = 0x260 # CParticleTransformInput + m_flStartTime = 0x2C8 # float + m_flEndTime = 0x2CC # float + m_nSetMethod = 0x2D0 # ParticleSetMethod_t + m_bOffset = 0x2D4 # bool + m_bAccelerate = 0x2D5 # bool + m_flRemapBias = 0x2D8 # float + +class C_INIT_RingWave: + m_TransformInput = 0x1C0 # CParticleTransformInput + m_flParticlesPerOrbit = 0x228 # CParticleCollectionFloatInput + m_flInitialRadius = 0x380 # CPerParticleFloatInput + m_flThickness = 0x4D8 # CPerParticleFloatInput + m_flInitialSpeedMin = 0x630 # CPerParticleFloatInput + m_flInitialSpeedMax = 0x788 # CPerParticleFloatInput + m_flRoll = 0x8E0 # CPerParticleFloatInput + m_flPitch = 0xA38 # CPerParticleFloatInput + m_flYaw = 0xB90 # CPerParticleFloatInput + m_bEvenDistribution = 0xCE8 # bool + m_bXYVelocityOnly = 0xCE9 # bool + +class C_INIT_RtEnvCull: + m_vecTestDir = 0x1C0 # Vector + m_vecTestNormal = 0x1CC # Vector + m_bUseVelocity = 0x1D8 # bool + m_bCullOnMiss = 0x1D9 # bool + m_bLifeAdjust = 0x1DA # bool + m_RtEnvName = 0x1DB # char[128] + m_nRTEnvCP = 0x25C # int32_t + m_nComponent = 0x260 # int32_t + +class C_INIT_ScaleVelocity: + m_vecScale = 0x1C0 # CParticleCollectionVecInput + +class C_INIT_SequenceFromCP: + m_bKillUnused = 0x1C0 # bool + m_bRadiusScale = 0x1C1 # bool + m_nCP = 0x1C4 # int32_t + m_vecOffset = 0x1C8 # Vector + +class C_INIT_SequenceLifeTime: + m_flFramerate = 0x1C0 # float + +class C_INIT_SetHitboxToClosest: + m_nControlPointNumber = 0x1C0 # int32_t + m_nDesiredHitbox = 0x1C4 # int32_t + m_vecHitBoxScale = 0x1C8 # CParticleCollectionVecInput + m_HitboxSetName = 0x820 # char[128] + m_bUseBones = 0x8A0 # bool + m_bUseClosestPointOnHitbox = 0x8A1 # bool + m_nTestType = 0x8A4 # ClosestPointTestType_t + m_flHybridRatio = 0x8A8 # CParticleCollectionFloatInput + m_bUpdatePosition = 0xA00 # bool + +class C_INIT_SetHitboxToModel: + m_nControlPointNumber = 0x1C0 # int32_t + m_nForceInModel = 0x1C4 # int32_t + m_nDesiredHitbox = 0x1C8 # int32_t + m_vecHitBoxScale = 0x1D0 # CParticleCollectionVecInput + m_vecDirectionBias = 0x828 # Vector + m_bMaintainHitbox = 0x834 # bool + m_bUseBones = 0x835 # bool + m_HitboxSetName = 0x836 # char[128] + m_flShellSize = 0x8B8 # CParticleCollectionFloatInput + +class C_INIT_SetRigidAttachment: + m_nControlPointNumber = 0x1C0 # int32_t + m_nFieldInput = 0x1C4 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C8 # ParticleAttributeIndex_t + m_bLocalSpace = 0x1CC # bool + +class C_INIT_SetVectorAttributeToVectorExpression: + m_nExpression = 0x1C0 # VectorExpressionType_t + m_vInput1 = 0x1C8 # CPerParticleVecInput + m_vInput2 = 0x820 # CPerParticleVecInput + m_nOutputField = 0xE78 # ParticleAttributeIndex_t + m_nSetMethod = 0xE7C # ParticleSetMethod_t + m_bNormalizedOutput = 0xE80 # bool + +class C_INIT_StatusEffect: + m_nDetail2Combo = 0x1C0 # Detail2Combo_t + m_flDetail2Rotation = 0x1C4 # float + m_flDetail2Scale = 0x1C8 # float + m_flDetail2BlendFactor = 0x1CC # float + m_flColorWarpIntensity = 0x1D0 # float + m_flDiffuseWarpBlendToFull = 0x1D4 # float + m_flEnvMapIntensity = 0x1D8 # float + m_flAmbientScale = 0x1DC # float + m_specularColor = 0x1E0 # Color + m_flSpecularScale = 0x1E4 # float + m_flSpecularExponent = 0x1E8 # float + m_flSpecularExponentBlendToFull = 0x1EC # float + m_flSpecularBlendToFull = 0x1F0 # float + m_rimLightColor = 0x1F4 # Color + m_flRimLightScale = 0x1F8 # float + m_flReflectionsTintByBaseBlendToNone = 0x1FC # float + m_flMetalnessBlendToFull = 0x200 # float + m_flSelfIllumBlendToFull = 0x204 # float + +class C_INIT_StatusEffectCitadel: + m_flSFXColorWarpAmount = 0x1C0 # float + m_flSFXNormalAmount = 0x1C4 # float + m_flSFXMetalnessAmount = 0x1C8 # float + m_flSFXRoughnessAmount = 0x1CC # float + m_flSFXSelfIllumAmount = 0x1D0 # float + m_flSFXSScale = 0x1D4 # float + m_flSFXSScrollX = 0x1D8 # float + m_flSFXSScrollY = 0x1DC # float + m_flSFXSScrollZ = 0x1E0 # float + m_flSFXSOffsetX = 0x1E4 # float + m_flSFXSOffsetY = 0x1E8 # float + m_flSFXSOffsetZ = 0x1EC # float + m_nDetailCombo = 0x1F0 # DetailCombo_t + m_flSFXSDetailAmount = 0x1F4 # float + m_flSFXSDetailScale = 0x1F8 # float + m_flSFXSDetailScrollX = 0x1FC # float + m_flSFXSDetailScrollY = 0x200 # float + m_flSFXSDetailScrollZ = 0x204 # float + m_flSFXSUseModelUVs = 0x208 # float + +class C_INIT_VelocityFromCP: + m_velocityInput = 0x1C0 # CParticleCollectionVecInput + m_transformInput = 0x818 # CParticleTransformInput + m_flVelocityScale = 0x880 # float + m_bDirectionOnly = 0x884 # bool + +class C_INIT_VelocityFromNormal: + m_fSpeedMin = 0x1C0 # float + m_fSpeedMax = 0x1C4 # float + m_bIgnoreDt = 0x1C8 # bool + +class C_INIT_VelocityRadialRandom: + m_nControlPointNumber = 0x1C0 # int32_t + m_fSpeedMin = 0x1C4 # float + m_fSpeedMax = 0x1C8 # float + m_vecLocalCoordinateSystemSpeedScale = 0x1CC # Vector + m_bIgnoreDelta = 0x1D9 # bool + +class C_INIT_VelocityRandom: + m_nControlPointNumber = 0x1C0 # int32_t + m_fSpeedMin = 0x1C8 # CPerParticleFloatInput + m_fSpeedMax = 0x320 # CPerParticleFloatInput + m_LocalCoordinateSystemSpeedMin = 0x478 # CPerParticleVecInput + m_LocalCoordinateSystemSpeedMax = 0xAD0 # CPerParticleVecInput + m_bIgnoreDT = 0x1128 # bool + m_randomnessParameters = 0x112C # CRandomNumberGeneratorParameters + +class C_OP_AlphaDecay: + m_flMinAlpha = 0x1C0 # float + +class C_OP_AttractToControlPoint: + m_vecComponentScale = 0x1D0 # Vector + m_fForceAmount = 0x1E0 # CPerParticleFloatInput + m_fFalloffPower = 0x338 # float + m_TransformInput = 0x340 # CParticleTransformInput + m_fForceAmountMin = 0x3A8 # CPerParticleFloatInput + m_bApplyMinForce = 0x500 # bool + +class C_OP_BasicMovement: + m_Gravity = 0x1C0 # CParticleCollectionVecInput + m_fDrag = 0x818 # CParticleCollectionFloatInput + m_nMaxConstraintPasses = 0x970 # int32_t + +class C_OP_BoxConstraint: + m_vecMin = 0x1C0 # CParticleCollectionVecInput + m_vecMax = 0x818 # CParticleCollectionVecInput + m_nCP = 0xE70 # int32_t + m_bLocalSpace = 0xE74 # bool + m_bAccountForRadius = 0xE75 # bool + +class C_OP_CPOffsetToPercentageBetweenCPs: + m_flInputMin = 0x1C0 # float + m_flInputMax = 0x1C4 # float + m_flInputBias = 0x1C8 # float + m_nStartCP = 0x1CC # int32_t + m_nEndCP = 0x1D0 # int32_t + m_nOffsetCP = 0x1D4 # int32_t + m_nOuputCP = 0x1D8 # int32_t + m_nInputCP = 0x1DC # int32_t + m_bRadialCheck = 0x1E0 # bool + m_bScaleOffset = 0x1E1 # bool + m_vecOffset = 0x1E4 # Vector + +class C_OP_CPVelocityForce: + m_nControlPointNumber = 0x1D0 # int32_t + m_flScale = 0x1D8 # CPerParticleFloatInput + +class C_OP_CalculateVectorAttribute: + m_vStartValue = 0x1C0 # Vector + m_nFieldInput1 = 0x1CC # ParticleAttributeIndex_t + m_flInputScale1 = 0x1D0 # float + m_nFieldInput2 = 0x1D4 # ParticleAttributeIndex_t + m_flInputScale2 = 0x1D8 # float + m_nControlPointInput1 = 0x1DC # ControlPointReference_t + m_flControlPointScale1 = 0x1F0 # float + m_nControlPointInput2 = 0x1F4 # ControlPointReference_t + m_flControlPointScale2 = 0x208 # float + m_nFieldOutput = 0x20C # ParticleAttributeIndex_t + m_vFinalOutputScale = 0x210 # Vector + +class C_OP_ChladniWave: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # CPerParticleFloatInput + m_flInputMax = 0x320 # CPerParticleFloatInput + m_flOutputMin = 0x478 # CPerParticleFloatInput + m_flOutputMax = 0x5D0 # CPerParticleFloatInput + m_vecWaveLength = 0x728 # CPerParticleVecInput + m_vecHarmonics = 0xD80 # CPerParticleVecInput + m_nSetMethod = 0x13D8 # ParticleSetMethod_t + m_nLocalSpaceControlPoint = 0x13DC # int32_t + m_b3D = 0x13E0 # bool + +class C_OP_ChooseRandomChildrenInGroup: + m_nChildGroupID = 0x1D0 # int32_t + m_flNumberOfChildren = 0x1D8 # CParticleCollectionFloatInput + +class C_OP_ClampScalar: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flOutputMin = 0x1C8 # CPerParticleFloatInput + m_flOutputMax = 0x320 # CPerParticleFloatInput + +class C_OP_ClampVector: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_vecOutputMin = 0x1C8 # CPerParticleVecInput + m_vecOutputMax = 0x820 # CPerParticleVecInput + +class C_OP_CollideWithParentParticles: + m_flParentRadiusScale = 0x1C0 # CPerParticleFloatInput + m_flRadiusScale = 0x318 # CPerParticleFloatInput + +class C_OP_CollideWithSelf: + m_flRadiusScale = 0x1C0 # CPerParticleFloatInput + m_flMinimumSpeed = 0x318 # CPerParticleFloatInput + +class C_OP_ColorAdjustHSL: + m_flHueAdjust = 0x1C0 # CPerParticleFloatInput + m_flSaturationAdjust = 0x318 # CPerParticleFloatInput + m_flLightnessAdjust = 0x470 # CPerParticleFloatInput + +class C_OP_ColorInterpolate: + m_ColorFade = 0x1C0 # Color + m_flFadeStartTime = 0x1D0 # float + m_flFadeEndTime = 0x1D4 # float + m_nFieldOutput = 0x1D8 # ParticleAttributeIndex_t + m_bEaseInOut = 0x1DC # bool + m_bUseNewCode = 0x1DD # bool + +class C_OP_ColorInterpolateRandom: + m_ColorFadeMin = 0x1C0 # Color + m_ColorFadeMax = 0x1DC # Color + m_flFadeStartTime = 0x1EC # float + m_flFadeEndTime = 0x1F0 # float + m_nFieldOutput = 0x1F4 # ParticleAttributeIndex_t + m_bEaseInOut = 0x1F8 # bool + +class C_OP_ConnectParentParticleToNearest: + m_nFirstControlPoint = 0x1C0 # int32_t + m_nSecondControlPoint = 0x1C4 # int32_t + +class C_OP_ConstrainDistance: + m_fMinDistance = 0x1C0 # CParticleCollectionFloatInput + m_fMaxDistance = 0x318 # CParticleCollectionFloatInput + m_nControlPointNumber = 0x470 # int32_t + m_CenterOffset = 0x474 # Vector + m_bGlobalCenter = 0x480 # bool + +class C_OP_ConstrainDistanceToPath: + m_fMinDistance = 0x1C0 # float + m_flMaxDistance0 = 0x1C4 # float + m_flMaxDistanceMid = 0x1C8 # float + m_flMaxDistance1 = 0x1CC # float + m_PathParameters = 0x1D0 # CPathParameters + m_flTravelTime = 0x210 # float + m_nFieldScale = 0x214 # ParticleAttributeIndex_t + m_nManualTField = 0x218 # ParticleAttributeIndex_t + +class C_OP_ConstrainDistanceToUserSpecifiedPath: + m_fMinDistance = 0x1C0 # float + m_flMaxDistance = 0x1C4 # float + m_flTimeScale = 0x1C8 # float + m_bLoopedPath = 0x1CC # bool + m_pointList = 0x1D0 # CUtlVector + +class C_OP_ConstrainLineLength: + m_flMinDistance = 0x1C0 # float + m_flMaxDistance = 0x1C4 # float + +class C_OP_ContinuousEmitter: + m_flEmissionDuration = 0x1C0 # CParticleCollectionFloatInput + m_flStartTime = 0x318 # CParticleCollectionFloatInput + m_flEmitRate = 0x470 # CParticleCollectionFloatInput + m_flEmissionScale = 0x5C8 # float + m_flScalePerParentParticle = 0x5CC # float + m_bInitFromKilledParentParticles = 0x5D0 # bool + m_nSnapshotControlPoint = 0x5D4 # int32_t + m_nLimitPerUpdate = 0x5D8 # int32_t + m_bForceEmitOnFirstUpdate = 0x5DC # bool + m_bForceEmitOnLastUpdate = 0x5DD # bool + +class C_OP_ControlPointToRadialScreenSpace: + m_nCPIn = 0x1D0 # int32_t + m_vecCP1Pos = 0x1D4 # Vector + m_nCPOut = 0x1E0 # int32_t + m_nCPOutField = 0x1E4 # int32_t + m_nCPSSPosOut = 0x1E8 # int32_t + +class C_OP_ControlpointLight: + m_flScale = 0x1C0 # float + m_nControlPoint1 = 0x690 # int32_t + m_nControlPoint2 = 0x694 # int32_t + m_nControlPoint3 = 0x698 # int32_t + m_nControlPoint4 = 0x69C # int32_t + m_vecCPOffset1 = 0x6A0 # Vector + m_vecCPOffset2 = 0x6AC # Vector + m_vecCPOffset3 = 0x6B8 # Vector + m_vecCPOffset4 = 0x6C4 # Vector + m_LightFiftyDist1 = 0x6D0 # float + m_LightZeroDist1 = 0x6D4 # float + m_LightFiftyDist2 = 0x6D8 # float + m_LightZeroDist2 = 0x6DC # float + m_LightFiftyDist3 = 0x6E0 # float + m_LightZeroDist3 = 0x6E4 # float + m_LightFiftyDist4 = 0x6E8 # float + m_LightZeroDist4 = 0x6EC # float + m_LightColor1 = 0x6F0 # Color + m_LightColor2 = 0x6F4 # Color + m_LightColor3 = 0x6F8 # Color + m_LightColor4 = 0x6FC # Color + m_bLightType1 = 0x700 # bool + m_bLightType2 = 0x701 # bool + m_bLightType3 = 0x702 # bool + m_bLightType4 = 0x703 # bool + m_bLightDynamic1 = 0x704 # bool + m_bLightDynamic2 = 0x705 # bool + m_bLightDynamic3 = 0x706 # bool + m_bLightDynamic4 = 0x707 # bool + m_bUseNormal = 0x708 # bool + m_bUseHLambert = 0x709 # bool + m_bClampLowerRange = 0x70E # bool + m_bClampUpperRange = 0x70F # bool + +class C_OP_Cull: + m_flCullPerc = 0x1C0 # float + m_flCullStart = 0x1C4 # float + m_flCullEnd = 0x1C8 # float + m_flCullExp = 0x1CC # float + +class C_OP_CurlNoiseForce: + m_nNoiseType = 0x1D0 # ParticleDirectionNoiseType_t + m_vecNoiseFreq = 0x1D8 # CPerParticleVecInput + m_vecNoiseScale = 0x830 # CPerParticleVecInput + m_vecOffset = 0xE88 # CPerParticleVecInput + m_vecOffsetRate = 0x14E0 # CPerParticleVecInput + m_flWorleySeed = 0x1B38 # CPerParticleFloatInput + m_flWorleyJitter = 0x1C90 # CPerParticleFloatInput + +class C_OP_CycleScalar: + m_nDestField = 0x1C0 # ParticleAttributeIndex_t + m_flStartValue = 0x1C4 # float + m_flEndValue = 0x1C8 # float + m_flCycleTime = 0x1CC # float + m_bDoNotRepeatCycle = 0x1D0 # bool + m_bSynchronizeParticles = 0x1D1 # bool + m_nCPScale = 0x1D4 # int32_t + m_nCPFieldMin = 0x1D8 # int32_t + m_nCPFieldMax = 0x1DC # int32_t + m_nSetMethod = 0x1E0 # ParticleSetMethod_t + +class C_OP_CylindricalDistanceToTransform: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # CPerParticleFloatInput + m_flInputMax = 0x320 # CPerParticleFloatInput + m_flOutputMin = 0x478 # CPerParticleFloatInput + m_flOutputMax = 0x5D0 # CPerParticleFloatInput + m_TransformStart = 0x728 # CParticleTransformInput + m_TransformEnd = 0x790 # CParticleTransformInput + m_nSetMethod = 0x7F8 # ParticleSetMethod_t + m_bActiveRange = 0x7FC # bool + m_bAdditive = 0x7FD # bool + m_bCapsule = 0x7FE # bool + +class C_OP_DampenToCP: + m_nControlPointNumber = 0x1C0 # int32_t + m_flRange = 0x1C4 # float + m_flScale = 0x1C8 # float + +class C_OP_Decay: + m_bRopeDecay = 0x1C0 # bool + m_bForcePreserveParticleOrder = 0x1C1 # bool + +class C_OP_DecayClampCount: + m_nCount = 0x1C0 # CParticleCollectionFloatInput + +class C_OP_DecayMaintainCount: + m_nParticlesToMaintain = 0x1C0 # int32_t + m_flDecayDelay = 0x1C4 # float + m_nSnapshotControlPoint = 0x1C8 # int32_t + m_bLifespanDecay = 0x1CC # bool + m_flScale = 0x1D0 # CParticleCollectionFloatInput + m_bKillNewest = 0x328 # bool + +class C_OP_DecayOffscreen: + m_flOffscreenTime = 0x1C0 # CParticleCollectionFloatInput + +class C_OP_DensityForce: + m_flRadiusScale = 0x1D0 # float + m_flForceScale = 0x1D4 # float + m_flTargetDensity = 0x1D8 # float + +class C_OP_DifferencePreviousParticle: + m_nFieldInput = 0x1C0 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # float + m_flInputMax = 0x1CC # float + m_flOutputMin = 0x1D0 # float + m_flOutputMax = 0x1D4 # float + m_nSetMethod = 0x1D8 # ParticleSetMethod_t + m_bActiveRange = 0x1DC # bool + m_bSetPreviousParticle = 0x1DD # bool + +class C_OP_Diffusion: + m_flRadiusScale = 0x1C0 # float + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nVoxelGridResolution = 0x1C8 # int32_t + +class C_OP_DirectionBetweenVecsToVec: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_vecPoint1 = 0x1C8 # CPerParticleVecInput + m_vecPoint2 = 0x820 # CPerParticleVecInput + +class C_OP_DistanceBetweenCPsToCP: + m_nStartCP = 0x1D0 # int32_t + m_nEndCP = 0x1D4 # int32_t + m_nOutputCP = 0x1D8 # int32_t + m_nOutputCPField = 0x1DC # int32_t + m_bSetOnce = 0x1E0 # bool + m_flInputMin = 0x1E4 # float + m_flInputMax = 0x1E8 # float + m_flOutputMin = 0x1EC # float + m_flOutputMax = 0x1F0 # float + m_flMaxTraceLength = 0x1F4 # float + m_flLOSScale = 0x1F8 # float + m_bLOS = 0x1FC # bool + m_CollisionGroupName = 0x1FD # char[128] + m_nTraceSet = 0x280 # ParticleTraceSet_t + m_nSetParent = 0x284 # ParticleParentSetMode_t + +class C_OP_DistanceBetweenTransforms: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_TransformStart = 0x1C8 # CParticleTransformInput + m_TransformEnd = 0x230 # CParticleTransformInput + m_flInputMin = 0x298 # CPerParticleFloatInput + m_flInputMax = 0x3F0 # CPerParticleFloatInput + m_flOutputMin = 0x548 # CPerParticleFloatInput + m_flOutputMax = 0x6A0 # CPerParticleFloatInput + m_flMaxTraceLength = 0x7F8 # float + m_flLOSScale = 0x7FC # float + m_CollisionGroupName = 0x800 # char[128] + m_nTraceSet = 0x880 # ParticleTraceSet_t + m_bLOS = 0x884 # bool + m_nSetMethod = 0x888 # ParticleSetMethod_t + +class C_OP_DistanceBetweenVecs: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_vecPoint1 = 0x1C8 # CPerParticleVecInput + m_vecPoint2 = 0x820 # CPerParticleVecInput + m_flInputMin = 0xE78 # CPerParticleFloatInput + m_flInputMax = 0xFD0 # CPerParticleFloatInput + m_flOutputMin = 0x1128 # CPerParticleFloatInput + m_flOutputMax = 0x1280 # CPerParticleFloatInput + m_nSetMethod = 0x13D8 # ParticleSetMethod_t + m_bDeltaTime = 0x13DC # bool + +class C_OP_DistanceCull: + m_nControlPoint = 0x1C0 # int32_t + m_vecPointOffset = 0x1C4 # Vector + m_flDistance = 0x1D0 # float + m_bCullInside = 0x1D4 # bool + +class C_OP_DistanceToTransform: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # CPerParticleFloatInput + m_flInputMax = 0x320 # CPerParticleFloatInput + m_flOutputMin = 0x478 # CPerParticleFloatInput + m_flOutputMax = 0x5D0 # CPerParticleFloatInput + m_TransformStart = 0x728 # CParticleTransformInput + m_bLOS = 0x790 # bool + m_CollisionGroupName = 0x791 # char[128] + m_nTraceSet = 0x814 # ParticleTraceSet_t + m_flMaxTraceLength = 0x818 # float + m_flLOSScale = 0x81C # float + m_nSetMethod = 0x820 # ParticleSetMethod_t + m_bActiveRange = 0x824 # bool + m_bAdditive = 0x825 # bool + m_vecComponentScale = 0x828 # CPerParticleVecInput + +class C_OP_DragRelativeToPlane: + m_flDragAtPlane = 0x1C0 # CParticleCollectionFloatInput + m_flFalloff = 0x318 # CParticleCollectionFloatInput + m_bDirectional = 0x470 # bool + m_vecPlaneNormal = 0x478 # CParticleCollectionVecInput + m_nControlPointNumber = 0xAD0 # int32_t + +class C_OP_DriveCPFromGlobalSoundFloat: + m_nOutputControlPoint = 0x1D0 # int32_t + m_nOutputField = 0x1D4 # int32_t + m_flInputMin = 0x1D8 # float + m_flInputMax = 0x1DC # float + m_flOutputMin = 0x1E0 # float + m_flOutputMax = 0x1E4 # float + m_StackName = 0x1E8 # CUtlString + m_OperatorName = 0x1F0 # CUtlString + m_FieldName = 0x1F8 # CUtlString + +class C_OP_EnableChildrenFromParentParticleCount: + m_nChildGroupID = 0x1D0 # int32_t + m_nFirstChild = 0x1D4 # int32_t + m_nNumChildrenToEnable = 0x1D8 # CParticleCollectionFloatInput + m_bDisableChildren = 0x330 # bool + m_bPlayEndcapOnStop = 0x331 # bool + m_bDestroyImmediately = 0x332 # bool + +class C_OP_EndCapTimedDecay: + m_flDecayTime = 0x1C0 # float + +class C_OP_EndCapTimedFreeze: + m_flFreezeTime = 0x1C0 # CParticleCollectionFloatInput + +class C_OP_ExternalGameImpulseForce: + m_flForceScale = 0x1D0 # CPerParticleFloatInput + m_bRopes = 0x328 # bool + m_bRopesZOnly = 0x329 # bool + m_bExplosions = 0x32A # bool + m_bParticles = 0x32B # bool + +class C_OP_ExternalWindForce: + m_vecSamplePosition = 0x1D0 # CPerParticleVecInput + m_vecScale = 0x828 # CPerParticleVecInput + m_bSampleWind = 0xE80 # bool + m_bSampleWater = 0xE81 # bool + m_bDampenNearWaterPlane = 0xE82 # bool + m_bSampleGravity = 0xE83 # bool + m_vecGravityForce = 0xE88 # CPerParticleVecInput + m_bUseBasicMovementGravity = 0x14E0 # bool + m_flLocalGravityScale = 0x14E8 # CPerParticleFloatInput + m_flLocalBuoyancyScale = 0x1640 # CPerParticleFloatInput + m_vecBuoyancyForce = 0x1798 # CPerParticleVecInput + +class C_OP_FadeAndKill: + m_flStartFadeInTime = 0x1C0 # float + m_flEndFadeInTime = 0x1C4 # float + m_flStartFadeOutTime = 0x1C8 # float + m_flEndFadeOutTime = 0x1CC # float + m_flStartAlpha = 0x1D0 # float + m_flEndAlpha = 0x1D4 # float + m_bForcePreserveParticleOrder = 0x1D8 # bool + +class C_OP_FadeAndKillForTracers: + m_flStartFadeInTime = 0x1C0 # float + m_flEndFadeInTime = 0x1C4 # float + m_flStartFadeOutTime = 0x1C8 # float + m_flEndFadeOutTime = 0x1CC # float + m_flStartAlpha = 0x1D0 # float + m_flEndAlpha = 0x1D4 # float + +class C_OP_FadeIn: + m_flFadeInTimeMin = 0x1C0 # float + m_flFadeInTimeMax = 0x1C4 # float + m_flFadeInTimeExp = 0x1C8 # float + m_bProportional = 0x1CC # bool + +class C_OP_FadeInSimple: + m_flFadeInTime = 0x1C0 # float + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + +class C_OP_FadeOut: + m_flFadeOutTimeMin = 0x1C0 # float + m_flFadeOutTimeMax = 0x1C4 # float + m_flFadeOutTimeExp = 0x1C8 # float + m_flFadeBias = 0x1CC # float + m_bProportional = 0x200 # bool + m_bEaseInAndOut = 0x201 # bool + +class C_OP_FadeOutSimple: + m_flFadeOutTime = 0x1C0 # float + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + +class C_OP_ForceBasedOnDistanceToPlane: + m_flMinDist = 0x1D0 # float + m_vecForceAtMinDist = 0x1D4 # Vector + m_flMaxDist = 0x1E0 # float + m_vecForceAtMaxDist = 0x1E4 # Vector + m_vecPlaneNormal = 0x1F0 # Vector + m_nControlPointNumber = 0x1FC # int32_t + m_flExponent = 0x200 # float + +class C_OP_ForceControlPointStub: + m_ControlPoint = 0x1D0 # int32_t + +class C_OP_GlobalLight: + m_flScale = 0x1C0 # float + m_bClampLowerRange = 0x1C4 # bool + m_bClampUpperRange = 0x1C5 # bool + +class C_OP_HSVShiftToCP: + m_nColorCP = 0x1D0 # int32_t + m_nColorGemEnableCP = 0x1D4 # int32_t + m_nOutputCP = 0x1D8 # int32_t + m_DefaultHSVColor = 0x1DC # Color + +class C_OP_InheritFromParentParticles: + m_flScale = 0x1C0 # float + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nIncrement = 0x1C8 # int32_t + m_bRandomDistribution = 0x1CC # bool + +class C_OP_InheritFromParentParticlesV2: + m_flScale = 0x1C0 # float + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nIncrement = 0x1C8 # int32_t + m_bRandomDistribution = 0x1CC # bool + m_nMissingParentBehavior = 0x1D0 # MissingParentInheritBehavior_t + +class C_OP_InheritFromPeerSystem: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_nFieldInput = 0x1C4 # ParticleAttributeIndex_t + m_nIncrement = 0x1C8 # int32_t + m_nGroupID = 0x1CC # int32_t + +class C_OP_InstantaneousEmitter: + m_nParticlesToEmit = 0x1C0 # CParticleCollectionFloatInput + m_flStartTime = 0x318 # CParticleCollectionFloatInput + m_flInitFromKilledParentParticles = 0x470 # float + m_flParentParticleScale = 0x478 # CParticleCollectionFloatInput + m_nMaxEmittedPerFrame = 0x5D0 # int32_t + m_nSnapshotControlPoint = 0x5D4 # int32_t + +class C_OP_InterpolateRadius: + m_flStartTime = 0x1C0 # float + m_flEndTime = 0x1C4 # float + m_flStartScale = 0x1C8 # float + m_flEndScale = 0x1CC # float + m_bEaseInAndOut = 0x1D0 # bool + m_flBias = 0x1D4 # float + +class C_OP_LagCompensation: + m_nDesiredVelocityCP = 0x1C0 # int32_t + m_nLatencyCP = 0x1C4 # int32_t + m_nLatencyCPField = 0x1C8 # int32_t + m_nDesiredVelocityCPField = 0x1CC # int32_t + +class C_OP_LerpEndCapScalar: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flOutput = 0x1C4 # float + m_flLerpTime = 0x1C8 # float + +class C_OP_LerpEndCapVector: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_vecOutput = 0x1C4 # Vector + m_flLerpTime = 0x1D0 # float + +class C_OP_LerpScalar: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flOutput = 0x1C8 # CPerParticleFloatInput + m_flStartTime = 0x320 # float + m_flEndTime = 0x324 # float + +class C_OP_LerpToInitialPosition: + m_nControlPointNumber = 0x1C0 # int32_t + m_flInterpolation = 0x1C8 # CPerParticleFloatInput + m_nCacheField = 0x320 # ParticleAttributeIndex_t + m_flScale = 0x328 # CParticleCollectionFloatInput + m_vecScale = 0x480 # CParticleCollectionVecInput + +class C_OP_LerpToOtherAttribute: + m_flInterpolation = 0x1C0 # CPerParticleFloatInput + m_nFieldInputFrom = 0x318 # ParticleAttributeIndex_t + m_nFieldInput = 0x31C # ParticleAttributeIndex_t + m_nFieldOutput = 0x320 # ParticleAttributeIndex_t + +class C_OP_LerpVector: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_vecOutput = 0x1C4 # Vector + m_flStartTime = 0x1D0 # float + m_flEndTime = 0x1D4 # float + m_nSetMethod = 0x1D8 # ParticleSetMethod_t + +class C_OP_LightningSnapshotGenerator: + m_nCPSnapshot = 0x1D0 # int32_t + m_nCPStartPnt = 0x1D4 # int32_t + m_nCPEndPnt = 0x1D8 # int32_t + m_flSegments = 0x1E0 # CParticleCollectionFloatInput + m_flOffset = 0x338 # CParticleCollectionFloatInput + m_flOffsetDecay = 0x490 # CParticleCollectionFloatInput + m_flRecalcRate = 0x5E8 # CParticleCollectionFloatInput + m_flUVScale = 0x740 # CParticleCollectionFloatInput + m_flUVOffset = 0x898 # CParticleCollectionFloatInput + m_flSplitRate = 0x9F0 # CParticleCollectionFloatInput + m_flBranchTwist = 0xB48 # CParticleCollectionFloatInput + m_nBranchBehavior = 0xCA0 # ParticleLightnintBranchBehavior_t + m_flRadiusStart = 0xCA8 # CParticleCollectionFloatInput + m_flRadiusEnd = 0xE00 # CParticleCollectionFloatInput + m_flDedicatedPool = 0xF58 # CParticleCollectionFloatInput + +class C_OP_LocalAccelerationForce: + m_nCP = 0x1D0 # int32_t + m_nScaleCP = 0x1D4 # int32_t + m_vecAccel = 0x1D8 # CParticleCollectionVecInput + +class C_OP_LockPoints: + m_nMinCol = 0x1C0 # int32_t + m_nMaxCol = 0x1C4 # int32_t + m_nMinRow = 0x1C8 # int32_t + m_nMaxRow = 0x1CC # int32_t + m_nControlPoint = 0x1D0 # int32_t + m_flBlendValue = 0x1D4 # float + +class C_OP_LockToBone: + m_modelInput = 0x1C0 # CParticleModelInput + m_transformInput = 0x220 # CParticleTransformInput + m_flLifeTimeFadeStart = 0x288 # float + m_flLifeTimeFadeEnd = 0x28C # float + m_flJumpThreshold = 0x290 # float + m_flPrevPosScale = 0x294 # float + m_HitboxSetName = 0x298 # char[128] + m_bRigid = 0x318 # bool + m_bUseBones = 0x319 # bool + m_nFieldOutput = 0x31C # ParticleAttributeIndex_t + m_nFieldOutputPrev = 0x320 # ParticleAttributeIndex_t + m_nRotationSetType = 0x324 # ParticleRotationLockType_t + m_bRigidRotationLock = 0x328 # bool + m_vecRotation = 0x330 # CPerParticleVecInput + m_flRotLerp = 0x988 # CPerParticleFloatInput + +class C_OP_LockToPointList: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_pointList = 0x1C8 # CUtlVector + m_bPlaceAlongPath = 0x1E0 # bool + m_bClosedLoop = 0x1E1 # bool + m_nNumPointsAlongPath = 0x1E4 # int32_t + +class C_OP_LockToSavedSequentialPath: + m_flFadeStart = 0x1C4 # float + m_flFadeEnd = 0x1C8 # float + m_bCPPairs = 0x1CC # bool + m_PathParams = 0x1D0 # CPathParameters + +class C_OP_LockToSavedSequentialPathV2: + m_flFadeStart = 0x1C0 # float + m_flFadeEnd = 0x1C4 # float + m_bCPPairs = 0x1C8 # bool + m_PathParams = 0x1D0 # CPathParameters + +class C_OP_MaintainEmitter: + m_nParticlesToMaintain = 0x1C0 # CParticleCollectionFloatInput + m_flStartTime = 0x318 # float + m_flEmissionDuration = 0x320 # CParticleCollectionFloatInput + m_flEmissionRate = 0x478 # float + m_nSnapshotControlPoint = 0x47C # int32_t + m_bEmitInstantaneously = 0x480 # bool + m_bFinalEmitOnStop = 0x481 # bool + m_flScale = 0x488 # CParticleCollectionFloatInput + +class C_OP_MaintainSequentialPath: + m_fMaxDistance = 0x1C0 # float + m_flNumToAssign = 0x1C4 # float + m_flCohesionStrength = 0x1C8 # float + m_flTolerance = 0x1CC # float + m_bLoop = 0x1D0 # bool + m_bUseParticleCount = 0x1D1 # bool + m_PathParams = 0x1E0 # CPathParameters + +class C_OP_MaxVelocity: + m_flMaxVelocity = 0x1C0 # float + m_flMinVelocity = 0x1C4 # float + m_nOverrideCP = 0x1C8 # int32_t + m_nOverrideCPField = 0x1CC # int32_t + +class C_OP_ModelCull: + m_nControlPointNumber = 0x1C0 # int32_t + m_bBoundBox = 0x1C4 # bool + m_bCullOutside = 0x1C5 # bool + m_bUseBones = 0x1C6 # bool + m_HitboxSetName = 0x1C7 # char[128] + +class C_OP_ModelDampenMovement: + m_nControlPointNumber = 0x1C0 # int32_t + m_bBoundBox = 0x1C4 # bool + m_bOutside = 0x1C5 # bool + m_bUseBones = 0x1C6 # bool + m_HitboxSetName = 0x1C7 # char[128] + m_vecPosOffset = 0x248 # CPerParticleVecInput + m_fDrag = 0x8A0 # float + +class C_OP_MoveToHitbox: + m_modelInput = 0x1C0 # CParticleModelInput + m_transformInput = 0x220 # CParticleTransformInput + m_flLifeTimeLerpStart = 0x28C # float + m_flLifeTimeLerpEnd = 0x290 # float + m_flPrevPosScale = 0x294 # float + m_HitboxSetName = 0x298 # char[128] + m_bUseBones = 0x318 # bool + m_nLerpType = 0x31C # HitboxLerpType_t + m_flInterpolation = 0x320 # CPerParticleFloatInput + +class C_OP_MovementLoopInsideSphere: + m_nCP = 0x1C0 # int32_t + m_flDistance = 0x1C8 # CParticleCollectionFloatInput + m_vecScale = 0x320 # CParticleCollectionVecInput + m_nDistSqrAttr = 0x978 # ParticleAttributeIndex_t + +class C_OP_MovementMaintainOffset: + m_vecOffset = 0x1C0 # Vector + m_nCP = 0x1CC # int32_t + m_bRadiusScale = 0x1D0 # bool + +class C_OP_MovementMoveAlongSkinnedCPSnapshot: + m_nControlPointNumber = 0x1C0 # int32_t + m_nSnapshotControlPointNumber = 0x1C4 # int32_t + m_bSetNormal = 0x1C8 # bool + m_bSetRadius = 0x1C9 # bool + m_flInterpolation = 0x1D0 # CPerParticleFloatInput + m_flTValue = 0x328 # CPerParticleFloatInput + +class C_OP_MovementPlaceOnGround: + m_flOffset = 0x1C0 # CPerParticleFloatInput + m_flMaxTraceLength = 0x318 # float + m_flTolerance = 0x31C # float + m_flTraceOffset = 0x320 # float + m_flLerpRate = 0x324 # float + m_CollisionGroupName = 0x328 # char[128] + m_nTraceSet = 0x3A8 # ParticleTraceSet_t + m_nRefCP1 = 0x3AC # int32_t + m_nRefCP2 = 0x3B0 # int32_t + m_nLerpCP = 0x3B4 # int32_t + m_nTraceMissBehavior = 0x3C0 # ParticleTraceMissBehavior_t + m_bIncludeShotHull = 0x3C4 # bool + m_bIncludeWater = 0x3C5 # bool + m_bSetNormal = 0x3C8 # bool + m_bScaleOffset = 0x3C9 # bool + m_nPreserveOffsetCP = 0x3CC # int32_t + m_nIgnoreCP = 0x3D0 # int32_t + +class C_OP_MovementRigidAttachToCP: + m_nControlPointNumber = 0x1C0 # int32_t + m_nScaleControlPoint = 0x1C4 # int32_t + m_nScaleCPField = 0x1C8 # int32_t + m_nFieldInput = 0x1CC # ParticleAttributeIndex_t + m_nFieldOutput = 0x1D0 # ParticleAttributeIndex_t + m_bOffsetLocal = 0x1D4 # bool + +class C_OP_MovementRotateParticleAroundAxis: + m_vecRotAxis = 0x1C0 # CParticleCollectionVecInput + m_flRotRate = 0x818 # CParticleCollectionFloatInput + m_TransformInput = 0x970 # CParticleTransformInput + m_bLocalSpace = 0x9D8 # bool + +class C_OP_MovementSkinnedPositionFromCPSnapshot: + m_nSnapshotControlPointNumber = 0x1C0 # int32_t + m_nControlPointNumber = 0x1C4 # int32_t + m_bRandom = 0x1C8 # bool + m_nRandomSeed = 0x1CC # int32_t + m_bSetNormal = 0x1D0 # bool + m_bSetRadius = 0x1D1 # bool + m_flIncrement = 0x1D8 # CParticleCollectionFloatInput + m_nFullLoopIncrement = 0x330 # CParticleCollectionFloatInput + m_nSnapShotStartPoint = 0x488 # CParticleCollectionFloatInput + m_flInterpolation = 0x5E0 # CPerParticleFloatInput + +class C_OP_Noise: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flOutputMin = 0x1C4 # float + m_flOutputMax = 0x1C8 # float + m_fl4NoiseScale = 0x1CC # float + m_bAdditive = 0x1D0 # bool + m_flNoiseAnimationTimeScale = 0x1D4 # float + +class C_OP_NoiseEmitter: + m_flEmissionDuration = 0x1C0 # float + m_flStartTime = 0x1C4 # float + m_flEmissionScale = 0x1C8 # float + m_nScaleControlPoint = 0x1CC # int32_t + m_nScaleControlPointField = 0x1D0 # int32_t + m_nWorldNoisePoint = 0x1D4 # int32_t + m_bAbsVal = 0x1D8 # bool + m_bAbsValInv = 0x1D9 # bool + m_flOffset = 0x1DC # float + m_flOutputMin = 0x1E0 # float + m_flOutputMax = 0x1E4 # float + m_flNoiseScale = 0x1E8 # float + m_flWorldNoiseScale = 0x1EC # float + m_vecOffsetLoc = 0x1F0 # Vector + m_flWorldTimeScale = 0x1FC # float + +class C_OP_NormalLock: + m_nControlPointNumber = 0x1C0 # int32_t + +class C_OP_NormalizeVector: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flScale = 0x1C4 # float + +class C_OP_Orient2DRelToCP: + m_flRotOffset = 0x1C0 # float + m_flSpinStrength = 0x1C4 # float + m_nCP = 0x1C8 # int32_t + m_nFieldOutput = 0x1CC # ParticleAttributeIndex_t + +class C_OP_OrientTo2dDirection: + m_flRotOffset = 0x1C0 # float + m_flSpinStrength = 0x1C4 # float + m_nFieldOutput = 0x1C8 # ParticleAttributeIndex_t + +class C_OP_OscillateScalar: + m_RateMin = 0x1C0 # float + m_RateMax = 0x1C4 # float + m_FrequencyMin = 0x1C8 # float + m_FrequencyMax = 0x1CC # float + m_nField = 0x1D0 # ParticleAttributeIndex_t + m_bProportional = 0x1D4 # bool + m_bProportionalOp = 0x1D5 # bool + m_flStartTime_min = 0x1D8 # float + m_flStartTime_max = 0x1DC # float + m_flEndTime_min = 0x1E0 # float + m_flEndTime_max = 0x1E4 # float + m_flOscMult = 0x1E8 # float + m_flOscAdd = 0x1EC # float + +class C_OP_OscillateScalarSimple: + m_Rate = 0x1C0 # float + m_Frequency = 0x1C4 # float + m_nField = 0x1C8 # ParticleAttributeIndex_t + m_flOscMult = 0x1CC # float + m_flOscAdd = 0x1D0 # float + +class C_OP_OscillateVector: + m_RateMin = 0x1C0 # Vector + m_RateMax = 0x1CC # Vector + m_FrequencyMin = 0x1D8 # Vector + m_FrequencyMax = 0x1E4 # Vector + m_nField = 0x1F0 # ParticleAttributeIndex_t + m_bProportional = 0x1F4 # bool + m_bProportionalOp = 0x1F5 # bool + m_bOffset = 0x1F6 # bool + m_flStartTime_min = 0x1F8 # float + m_flStartTime_max = 0x1FC # float + m_flEndTime_min = 0x200 # float + m_flEndTime_max = 0x204 # float + m_flOscMult = 0x208 # CPerParticleFloatInput + m_flOscAdd = 0x360 # CPerParticleFloatInput + m_flRateScale = 0x4B8 # CPerParticleFloatInput + +class C_OP_OscillateVectorSimple: + m_Rate = 0x1C0 # Vector + m_Frequency = 0x1CC # Vector + m_nField = 0x1D8 # ParticleAttributeIndex_t + m_flOscMult = 0x1DC # float + m_flOscAdd = 0x1E0 # float + m_bOffset = 0x1E4 # bool + +class C_OP_ParentVortices: + m_flForceScale = 0x1D0 # float + m_vecTwistAxis = 0x1D4 # Vector + m_bFlipBasedOnYaw = 0x1E0 # bool + +class C_OP_ParticlePhysics: + m_Gravity = 0x1C0 # CParticleCollectionVecInput + m_fDrag = 0x818 # CParticleCollectionFloatInput + m_nMaxConstraintPasses = 0x970 # int32_t + +class C_OP_PerParticleForce: + m_flForceScale = 0x1D0 # CPerParticleFloatInput + m_vForce = 0x328 # CPerParticleVecInput + m_nCP = 0x980 # int32_t + +class C_OP_PercentageBetweenTransformLerpCPs: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flInputMin = 0x1C4 # float + m_flInputMax = 0x1C8 # float + m_TransformStart = 0x1D0 # CParticleTransformInput + m_TransformEnd = 0x238 # CParticleTransformInput + m_nOutputStartCP = 0x2A0 # int32_t + m_nOutputStartField = 0x2A4 # int32_t + m_nOutputEndCP = 0x2A8 # int32_t + m_nOutputEndField = 0x2AC # int32_t + m_nSetMethod = 0x2B0 # ParticleSetMethod_t + m_bActiveRange = 0x2B4 # bool + m_bRadialCheck = 0x2B5 # bool + +class C_OP_PercentageBetweenTransforms: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flInputMin = 0x1C4 # float + m_flInputMax = 0x1C8 # float + m_flOutputMin = 0x1CC # float + m_flOutputMax = 0x1D0 # float + m_TransformStart = 0x1D8 # CParticleTransformInput + m_TransformEnd = 0x240 # CParticleTransformInput + m_nSetMethod = 0x2A8 # ParticleSetMethod_t + m_bActiveRange = 0x2AC # bool + m_bRadialCheck = 0x2AD # bool + +class C_OP_PercentageBetweenTransformsVector: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flInputMin = 0x1C4 # float + m_flInputMax = 0x1C8 # float + m_vecOutputMin = 0x1CC # Vector + m_vecOutputMax = 0x1D8 # Vector + m_TransformStart = 0x1E8 # CParticleTransformInput + m_TransformEnd = 0x250 # CParticleTransformInput + m_nSetMethod = 0x2B8 # ParticleSetMethod_t + m_bActiveRange = 0x2BC # bool + m_bRadialCheck = 0x2BD # bool + +class C_OP_PinParticleToCP: + m_nControlPointNumber = 0x1C0 # int32_t + m_vecOffset = 0x1C8 # CParticleCollectionVecInput + m_bOffsetLocal = 0x820 # bool + m_nParticleSelection = 0x824 # ParticleSelection_t + m_nParticleNumber = 0x828 # CParticleCollectionFloatInput + m_nPinBreakType = 0x980 # ParticlePinDistance_t + m_flBreakDistance = 0x988 # CParticleCollectionFloatInput + m_flBreakSpeed = 0xAE0 # CParticleCollectionFloatInput + m_flAge = 0xC38 # CParticleCollectionFloatInput + m_nBreakControlPointNumber = 0xD90 # int32_t + m_nBreakControlPointNumber2 = 0xD94 # int32_t + m_flBreakValue = 0xD98 # CParticleCollectionFloatInput + m_flInterpolation = 0xEF0 # CPerParticleFloatInput + +class C_OP_PlanarConstraint: + m_PointOnPlane = 0x1C0 # Vector + m_PlaneNormal = 0x1CC # Vector + m_nControlPointNumber = 0x1D8 # int32_t + m_bGlobalOrigin = 0x1DC # bool + m_bGlobalNormal = 0x1DD # bool + m_flRadiusScale = 0x1E0 # CPerParticleFloatInput + m_flMaximumDistanceToCP = 0x338 # CParticleCollectionFloatInput + +class C_OP_PlaneCull: + m_nPlaneControlPoint = 0x1C0 # int32_t + m_vecPlaneDirection = 0x1C4 # Vector + m_bLocalSpace = 0x1D0 # bool + m_flPlaneOffset = 0x1D4 # float + +class C_OP_PlayEndCapWhenFinished: + m_bFireOnEmissionEnd = 0x1D0 # bool + m_bIncludeChildren = 0x1D1 # bool + +class C_OP_PointVectorAtNextParticle: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flInterpolation = 0x1C8 # CPerParticleFloatInput + +class C_OP_PositionLock: + m_TransformInput = 0x1C0 # CParticleTransformInput + m_flStartTime_min = 0x228 # float + m_flStartTime_max = 0x22C # float + m_flStartTime_exp = 0x230 # float + m_flEndTime_min = 0x234 # float + m_flEndTime_max = 0x238 # float + m_flEndTime_exp = 0x23C # float + m_flRange = 0x240 # float + m_flRangeBias = 0x248 # CParticleCollectionFloatInput + m_flJumpThreshold = 0x3A0 # float + m_flPrevPosScale = 0x3A4 # float + m_bLockRot = 0x3A8 # bool + m_vecScale = 0x3B0 # CParticleCollectionVecInput + m_nFieldOutput = 0xA08 # ParticleAttributeIndex_t + m_nFieldOutputPrev = 0xA0C # ParticleAttributeIndex_t + +class C_OP_QuantizeCPComponent: + m_flInputValue = 0x1D0 # CParticleCollectionFloatInput + m_nCPOutput = 0x328 # int32_t + m_nOutVectorField = 0x32C # int32_t + m_flQuantizeValue = 0x330 # CParticleCollectionFloatInput + +class C_OP_QuantizeFloat: + m_InputValue = 0x1C0 # CPerParticleFloatInput + m_nOutputField = 0x318 # ParticleAttributeIndex_t + +class C_OP_RadiusDecay: + m_flMinRadius = 0x1C0 # float + +class C_OP_RampCPLinearRandom: + m_nOutControlPointNumber = 0x1D0 # int32_t + m_vecRateMin = 0x1D4 # Vector + m_vecRateMax = 0x1E0 # Vector + +class C_OP_RampScalarLinear: + m_RateMin = 0x1C0 # float + m_RateMax = 0x1C4 # float + m_flStartTime_min = 0x1C8 # float + m_flStartTime_max = 0x1CC # float + m_flEndTime_min = 0x1D0 # float + m_flEndTime_max = 0x1D4 # float + m_nField = 0x200 # ParticleAttributeIndex_t + m_bProportionalOp = 0x204 # bool + +class C_OP_RampScalarLinearSimple: + m_Rate = 0x1C0 # float + m_flStartTime = 0x1C4 # float + m_flEndTime = 0x1C8 # float + m_nField = 0x1F0 # ParticleAttributeIndex_t + +class C_OP_RampScalarSpline: + m_RateMin = 0x1C0 # float + m_RateMax = 0x1C4 # float + m_flStartTime_min = 0x1C8 # float + m_flStartTime_max = 0x1CC # float + m_flEndTime_min = 0x1D0 # float + m_flEndTime_max = 0x1D4 # float + m_flBias = 0x1D8 # float + m_nField = 0x200 # ParticleAttributeIndex_t + m_bProportionalOp = 0x204 # bool + m_bEaseOut = 0x205 # bool + +class C_OP_RampScalarSplineSimple: + m_Rate = 0x1C0 # float + m_flStartTime = 0x1C4 # float + m_flEndTime = 0x1C8 # float + m_nField = 0x1F0 # ParticleAttributeIndex_t + m_bEaseOut = 0x1F4 # bool + +class C_OP_RandomForce: + m_MinForce = 0x1D0 # Vector + m_MaxForce = 0x1DC # Vector + +class C_OP_ReadFromNeighboringParticle: + m_nFieldInput = 0x1C0 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nIncrement = 0x1C8 # int32_t + m_DistanceCheck = 0x1D0 # CPerParticleFloatInput + m_flInterpolation = 0x328 # CPerParticleFloatInput + +class C_OP_ReinitializeScalarEndCap: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flOutputMin = 0x1C4 # float + m_flOutputMax = 0x1C8 # float + +class C_OP_RemapAverageHitboxSpeedtoCP: + m_nInControlPointNumber = 0x1D0 # int32_t + m_nOutControlPointNumber = 0x1D4 # int32_t + m_nField = 0x1D8 # int32_t + m_nHitboxDataType = 0x1DC # ParticleHitboxDataSelection_t + m_flInputMin = 0x1E0 # CParticleCollectionFloatInput + m_flInputMax = 0x338 # CParticleCollectionFloatInput + m_flOutputMin = 0x490 # CParticleCollectionFloatInput + m_flOutputMax = 0x5E8 # CParticleCollectionFloatInput + m_nHeightControlPointNumber = 0x740 # int32_t + m_vecComparisonVelocity = 0x748 # CParticleCollectionVecInput + m_HitboxSetName = 0xDA0 # char[128] + +class C_OP_RemapAverageScalarValuetoCP: + m_nOutControlPointNumber = 0x1D0 # int32_t + m_nOutVectorField = 0x1D4 # int32_t + m_nField = 0x1D8 # ParticleAttributeIndex_t + m_flInputMin = 0x1DC # float + m_flInputMax = 0x1E0 # float + m_flOutputMin = 0x1E4 # float + m_flOutputMax = 0x1E8 # float + +class C_OP_RemapBoundingVolumetoCP: + m_nOutControlPointNumber = 0x1D0 # int32_t + m_flInputMin = 0x1D4 # float + m_flInputMax = 0x1D8 # float + m_flOutputMin = 0x1DC # float + m_flOutputMax = 0x1E0 # float + +class C_OP_RemapCPVelocityToVector: + m_nControlPoint = 0x1C0 # int32_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flScale = 0x1C8 # float + m_bNormalize = 0x1CC # bool + +class C_OP_RemapCPtoCP: + m_nInputControlPoint = 0x1D0 # int32_t + m_nOutputControlPoint = 0x1D4 # int32_t + m_nInputField = 0x1D8 # int32_t + m_nOutputField = 0x1DC # int32_t + m_flInputMin = 0x1E0 # float + m_flInputMax = 0x1E4 # float + m_flOutputMin = 0x1E8 # float + m_flOutputMax = 0x1EC # float + m_bDerivative = 0x1F0 # bool + m_flInterpRate = 0x1F4 # float + +class C_OP_RemapCPtoScalar: + m_nCPInput = 0x1C0 # int32_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nField = 0x1C8 # int32_t + m_flInputMin = 0x1CC # float + m_flInputMax = 0x1D0 # float + m_flOutputMin = 0x1D4 # float + m_flOutputMax = 0x1D8 # float + m_flStartTime = 0x1DC # float + m_flEndTime = 0x1E0 # float + m_flInterpRate = 0x1E4 # float + m_nSetMethod = 0x1E8 # ParticleSetMethod_t + +class C_OP_RemapCPtoVector: + m_nCPInput = 0x1C0 # int32_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nLocalSpaceCP = 0x1C8 # int32_t + m_vInputMin = 0x1CC # Vector + m_vInputMax = 0x1D8 # Vector + m_vOutputMin = 0x1E4 # Vector + m_vOutputMax = 0x1F0 # Vector + m_flStartTime = 0x1FC # float + m_flEndTime = 0x200 # float + m_flInterpRate = 0x204 # float + m_nSetMethod = 0x208 # ParticleSetMethod_t + m_bOffset = 0x20C # bool + m_bAccelerate = 0x20D # bool + +class C_OP_RemapControlPointDirectionToVector: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flScale = 0x1C4 # float + m_nControlPointNumber = 0x1C8 # int32_t + +class C_OP_RemapControlPointOrientationToRotation: + m_nCP = 0x1C0 # int32_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flOffsetRot = 0x1C8 # float + m_nComponent = 0x1CC # int32_t + +class C_OP_RemapCrossProductOfTwoVectorsToVector: + m_InputVec1 = 0x1C0 # CPerParticleVecInput + m_InputVec2 = 0x818 # CPerParticleVecInput + m_nFieldOutput = 0xE70 # ParticleAttributeIndex_t + m_bNormalize = 0xE74 # bool + +class C_OP_RemapDensityGradientToVectorAttribute: + m_flRadiusScale = 0x1C0 # float + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + +class C_OP_RemapDensityToVector: + m_flRadiusScale = 0x1C0 # float + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flDensityMin = 0x1C8 # float + m_flDensityMax = 0x1CC # float + m_vecOutputMin = 0x1D0 # Vector + m_vecOutputMax = 0x1DC # Vector + m_bUseParentDensity = 0x1E8 # bool + m_nVoxelGridResolution = 0x1EC # int32_t + +class C_OP_RemapDirectionToCPToVector: + m_nCP = 0x1C0 # int32_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flScale = 0x1C8 # float + m_flOffsetRot = 0x1CC # float + m_vecOffsetAxis = 0x1D0 # Vector + m_bNormalize = 0x1DC # bool + m_nFieldStrength = 0x1E0 # ParticleAttributeIndex_t + +class C_OP_RemapDistanceToLineSegmentBase: + m_nCP0 = 0x1C0 # int32_t + m_nCP1 = 0x1C4 # int32_t + m_flMinInputValue = 0x1C8 # float + m_flMaxInputValue = 0x1CC # float + m_bInfiniteLine = 0x1D0 # bool + +class C_OP_RemapDistanceToLineSegmentToScalar: + m_nFieldOutput = 0x1E0 # ParticleAttributeIndex_t + m_flMinOutputValue = 0x1E4 # float + m_flMaxOutputValue = 0x1E8 # float + +class C_OP_RemapDistanceToLineSegmentToVector: + m_nFieldOutput = 0x1E0 # ParticleAttributeIndex_t + m_vMinOutputValue = 0x1E4 # Vector + m_vMaxOutputValue = 0x1F0 # Vector + +class C_OP_RemapDotProductToCP: + m_nInputCP1 = 0x1D0 # int32_t + m_nInputCP2 = 0x1D4 # int32_t + m_nOutputCP = 0x1D8 # int32_t + m_nOutVectorField = 0x1DC # int32_t + m_flInputMin = 0x1E0 # CParticleCollectionFloatInput + m_flInputMax = 0x338 # CParticleCollectionFloatInput + m_flOutputMin = 0x490 # CParticleCollectionFloatInput + m_flOutputMax = 0x5E8 # CParticleCollectionFloatInput + +class C_OP_RemapDotProductToScalar: + m_nInputCP1 = 0x1C0 # int32_t + m_nInputCP2 = 0x1C4 # int32_t + m_nFieldOutput = 0x1C8 # ParticleAttributeIndex_t + m_flInputMin = 0x1CC # float + m_flInputMax = 0x1D0 # float + m_flOutputMin = 0x1D4 # float + m_flOutputMax = 0x1D8 # float + m_bUseParticleVelocity = 0x1DC # bool + m_nSetMethod = 0x1E0 # ParticleSetMethod_t + m_bActiveRange = 0x1E4 # bool + m_bUseParticleNormal = 0x1E5 # bool + +class C_OP_RemapExternalWindToCP: + m_nCP = 0x1D0 # int32_t + m_nCPOutput = 0x1D4 # int32_t + m_vecScale = 0x1D8 # CParticleCollectionVecInput + m_bSetMagnitude = 0x830 # bool + m_nOutVectorField = 0x834 # int32_t + +class C_OP_RemapModelVolumetoCP: + m_nBBoxType = 0x1D0 # BBoxVolumeType_t + m_nInControlPointNumber = 0x1D4 # int32_t + m_nOutControlPointNumber = 0x1D8 # int32_t + m_nOutControlPointMaxNumber = 0x1DC # int32_t + m_nField = 0x1E0 # int32_t + m_flInputMin = 0x1E4 # float + m_flInputMax = 0x1E8 # float + m_flOutputMin = 0x1EC # float + m_flOutputMax = 0x1F0 # float + +class C_OP_RemapNamedModelElementEndCap: + m_hModel = 0x1C0 # CStrongHandle + m_inNames = 0x1C8 # CUtlVector + m_outNames = 0x1E0 # CUtlVector + m_fallbackNames = 0x1F8 # CUtlVector + m_bModelFromRenderer = 0x210 # bool + m_nFieldInput = 0x214 # ParticleAttributeIndex_t + m_nFieldOutput = 0x218 # ParticleAttributeIndex_t + +class C_OP_RemapNamedModelElementOnceTimed: + m_hModel = 0x1C0 # CStrongHandle + m_inNames = 0x1C8 # CUtlVector + m_outNames = 0x1E0 # CUtlVector + m_fallbackNames = 0x1F8 # CUtlVector + m_bModelFromRenderer = 0x210 # bool + m_bProportional = 0x211 # bool + m_nFieldInput = 0x214 # ParticleAttributeIndex_t + m_nFieldOutput = 0x218 # ParticleAttributeIndex_t + m_flRemapTime = 0x21C # float + +class C_OP_RemapParticleCountOnScalarEndCap: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_nInputMin = 0x1C4 # int32_t + m_nInputMax = 0x1C8 # int32_t + m_flOutputMin = 0x1CC # float + m_flOutputMax = 0x1D0 # float + m_bBackwards = 0x1D4 # bool + m_nSetMethod = 0x1D8 # ParticleSetMethod_t + +class C_OP_RemapParticleCountToScalar: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_nInputMin = 0x1C8 # CParticleCollectionFloatInput + m_nInputMax = 0x320 # CParticleCollectionFloatInput + m_flOutputMin = 0x478 # CParticleCollectionFloatInput + m_flOutputMax = 0x5D0 # CParticleCollectionFloatInput + m_bActiveRange = 0x728 # bool + m_nSetMethod = 0x72C # ParticleSetMethod_t + +class C_OP_RemapSDFDistanceToScalarAttribute: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_nVectorFieldInput = 0x1C4 # ParticleAttributeIndex_t + m_flMinDistance = 0x1C8 # CParticleCollectionFloatInput + m_flMaxDistance = 0x320 # CParticleCollectionFloatInput + m_flValueBelowMin = 0x478 # CParticleCollectionFloatInput + m_flValueAtMin = 0x5D0 # CParticleCollectionFloatInput + m_flValueAtMax = 0x728 # CParticleCollectionFloatInput + m_flValueAboveMax = 0x880 # CParticleCollectionFloatInput + +class C_OP_RemapSDFDistanceToVectorAttribute: + m_nVectorFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_nVectorFieldInput = 0x1C4 # ParticleAttributeIndex_t + m_flMinDistance = 0x1C8 # CParticleCollectionFloatInput + m_flMaxDistance = 0x320 # CParticleCollectionFloatInput + m_vValueBelowMin = 0x478 # Vector + m_vValueAtMin = 0x484 # Vector + m_vValueAtMax = 0x490 # Vector + m_vValueAboveMax = 0x49C # Vector + +class C_OP_RemapSDFGradientToVectorAttribute: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + +class C_OP_RemapScalar: + m_nFieldInput = 0x1C0 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # float + m_flInputMax = 0x1CC # float + m_flOutputMin = 0x1D0 # float + m_flOutputMax = 0x1D4 # float + m_bOldCode = 0x1D8 # bool + +class C_OP_RemapScalarEndCap: + m_nFieldInput = 0x1C0 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # float + m_flInputMax = 0x1CC # float + m_flOutputMin = 0x1D0 # float + m_flOutputMax = 0x1D4 # float + +class C_OP_RemapScalarOnceTimed: + m_bProportional = 0x1C0 # bool + m_nFieldInput = 0x1C4 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C8 # ParticleAttributeIndex_t + m_flInputMin = 0x1CC # float + m_flInputMax = 0x1D0 # float + m_flOutputMin = 0x1D4 # float + m_flOutputMax = 0x1D8 # float + m_flRemapTime = 0x1DC # float + +class C_OP_RemapSpeed: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flInputMin = 0x1C4 # float + m_flInputMax = 0x1C8 # float + m_flOutputMin = 0x1CC # float + m_flOutputMax = 0x1D0 # float + m_nSetMethod = 0x1D4 # ParticleSetMethod_t + m_bIgnoreDelta = 0x1D8 # bool + +class C_OP_RemapSpeedtoCP: + m_nInControlPointNumber = 0x1D0 # int32_t + m_nOutControlPointNumber = 0x1D4 # int32_t + m_nField = 0x1D8 # int32_t + m_flInputMin = 0x1DC # float + m_flInputMax = 0x1E0 # float + m_flOutputMin = 0x1E4 # float + m_flOutputMax = 0x1E8 # float + m_bUseDeltaV = 0x1EC # bool + +class C_OP_RemapTransformOrientationToRotations: + m_TransformInput = 0x1C0 # CParticleTransformInput + m_vecRotation = 0x228 # Vector + m_bUseQuat = 0x234 # bool + m_bWriteNormal = 0x235 # bool + +class C_OP_RemapTransformOrientationToYaw: + m_TransformInput = 0x1C0 # CParticleTransformInput + m_nFieldOutput = 0x228 # ParticleAttributeIndex_t + m_flRotOffset = 0x22C # float + m_flSpinStrength = 0x230 # float + +class C_OP_RemapTransformToVelocity: + m_TransformInput = 0x1C0 # CParticleTransformInput + +class C_OP_RemapTransformVisibilityToScalar: + m_nSetMethod = 0x1C0 # ParticleSetMethod_t + m_TransformInput = 0x1C8 # CParticleTransformInput + m_nFieldOutput = 0x230 # ParticleAttributeIndex_t + m_flInputMin = 0x234 # float + m_flInputMax = 0x238 # float + m_flOutputMin = 0x23C # float + m_flOutputMax = 0x240 # float + m_flRadius = 0x244 # float + +class C_OP_RemapTransformVisibilityToVector: + m_nSetMethod = 0x1C0 # ParticleSetMethod_t + m_TransformInput = 0x1C8 # CParticleTransformInput + m_nFieldOutput = 0x230 # ParticleAttributeIndex_t + m_flInputMin = 0x234 # float + m_flInputMax = 0x238 # float + m_vecOutputMin = 0x23C # Vector + m_vecOutputMax = 0x248 # Vector + m_flRadius = 0x254 # float + +class C_OP_RemapVectorComponentToScalar: + m_nFieldInput = 0x1C0 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nComponent = 0x1C8 # int32_t + +class C_OP_RemapVectortoCP: + m_nOutControlPointNumber = 0x1C0 # int32_t + m_nFieldInput = 0x1C4 # ParticleAttributeIndex_t + m_nParticleNumber = 0x1C8 # int32_t + +class C_OP_RemapVelocityToVector: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_flScale = 0x1C4 # float + m_bNormalize = 0x1C8 # bool + +class C_OP_RemapVisibilityScalar: + m_nFieldInput = 0x1C0 # ParticleAttributeIndex_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_flInputMin = 0x1C8 # float + m_flInputMax = 0x1CC # float + m_flOutputMin = 0x1D0 # float + m_flOutputMax = 0x1D4 # float + m_flRadiusScale = 0x1D8 # float + +class C_OP_RenderAsModels: + m_ModelList = 0x200 # CUtlVector + m_flModelScale = 0x21C # float + m_bFitToModelSize = 0x220 # bool + m_bNonUniformScaling = 0x221 # bool + m_nXAxisScalingAttribute = 0x224 # ParticleAttributeIndex_t + m_nYAxisScalingAttribute = 0x228 # ParticleAttributeIndex_t + m_nZAxisScalingAttribute = 0x22C # ParticleAttributeIndex_t + m_nSizeCullBloat = 0x230 # int32_t + +class C_OP_RenderBlobs: + m_cubeWidth = 0x200 # CParticleCollectionRendererFloatInput + m_cutoffRadius = 0x358 # CParticleCollectionRendererFloatInput + m_renderRadius = 0x4B0 # CParticleCollectionRendererFloatInput + m_nScaleCP = 0x608 # int32_t + m_MaterialVars = 0x610 # CUtlVector + m_hMaterial = 0x640 # CStrongHandle + +class C_OP_RenderCables: + m_flRadiusScale = 0x200 # CParticleCollectionFloatInput + m_flAlphaScale = 0x358 # CParticleCollectionFloatInput + m_vecColorScale = 0x4B0 # CParticleCollectionVecInput + m_nColorBlendType = 0xB08 # ParticleColorBlendType_t + m_hMaterial = 0xB10 # CStrongHandle + m_nTextureRepetitionMode = 0xB18 # TextureRepetitionMode_t + m_flTextureRepeatsPerSegment = 0xB20 # CParticleCollectionFloatInput + m_flTextureRepeatsCircumference = 0xC78 # CParticleCollectionFloatInput + m_flColorMapOffsetV = 0xDD0 # CParticleCollectionFloatInput + m_flColorMapOffsetU = 0xF28 # CParticleCollectionFloatInput + m_flNormalMapOffsetV = 0x1080 # CParticleCollectionFloatInput + m_flNormalMapOffsetU = 0x11D8 # CParticleCollectionFloatInput + m_bDrawCableCaps = 0x1330 # bool + m_flCapRoundness = 0x1334 # float + m_flCapOffsetAmount = 0x1338 # float + m_flTessScale = 0x133C # float + m_nMinTesselation = 0x1340 # int32_t + m_nMaxTesselation = 0x1344 # int32_t + m_nRoundness = 0x1348 # int32_t + m_LightingTransform = 0x1350 # CParticleTransformInput + m_MaterialFloatVars = 0x13B8 # CUtlVector + m_MaterialVecVars = 0x13E8 # CUtlVector + +class C_OP_RenderDeferredLight: + m_bUseAlphaTestWindow = 0x200 # bool + m_bUseTexture = 0x201 # bool + m_flRadiusScale = 0x204 # float + m_flAlphaScale = 0x208 # float + m_nAlpha2Field = 0x20C # ParticleAttributeIndex_t + m_vecColorScale = 0x210 # CParticleCollectionVecInput + m_nColorBlendType = 0x868 # ParticleColorBlendType_t + m_flLightDistance = 0x86C # float + m_flStartFalloff = 0x870 # float + m_flDistanceFalloff = 0x874 # float + m_flSpotFoV = 0x878 # float + m_nAlphaTestPointField = 0x87C # ParticleAttributeIndex_t + m_nAlphaTestRangeField = 0x880 # ParticleAttributeIndex_t + m_nAlphaTestSharpnessField = 0x884 # ParticleAttributeIndex_t + m_hTexture = 0x888 # CStrongHandle + m_nHSVShiftControlPoint = 0x890 # int32_t + +class C_OP_RenderFlattenGrass: + m_flFlattenStrength = 0x200 # float + m_nStrengthFieldOverride = 0x204 # ParticleAttributeIndex_t + m_flRadiusScale = 0x208 # float + +class C_OP_RenderGpuImplicit: + m_bUsePerParticleRadius = 0x200 # bool + m_fGridSize = 0x208 # CParticleCollectionRendererFloatInput + m_fRadiusScale = 0x360 # CParticleCollectionRendererFloatInput + m_fIsosurfaceThreshold = 0x4B8 # CParticleCollectionRendererFloatInput + m_nScaleCP = 0x610 # int32_t + m_hMaterial = 0x618 # CStrongHandle + +class C_OP_RenderLightBeam: + m_vColorBlend = 0x200 # CParticleCollectionVecInput + m_nColorBlendType = 0x858 # ParticleColorBlendType_t + m_flBrightnessLumensPerMeter = 0x860 # CParticleCollectionFloatInput + m_bCastShadows = 0x9B8 # bool + m_flSkirt = 0x9C0 # CParticleCollectionFloatInput + m_flRange = 0xB18 # CParticleCollectionFloatInput + m_flThickness = 0xC70 # CParticleCollectionFloatInput + +class C_OP_RenderLights: + m_flAnimationRate = 0x210 # float + m_nAnimationType = 0x214 # AnimationType_t + m_bAnimateInFPS = 0x218 # bool + m_flMinSize = 0x21C # float + m_flMaxSize = 0x220 # float + m_flStartFadeSize = 0x224 # float + m_flEndFadeSize = 0x228 # float + +class C_OP_RenderMaterialProxy: + m_nMaterialControlPoint = 0x200 # int32_t + m_nProxyType = 0x204 # MaterialProxyType_t + m_MaterialVars = 0x208 # CUtlVector + m_hOverrideMaterial = 0x220 # CStrongHandle + m_flMaterialOverrideEnabled = 0x228 # CParticleCollectionFloatInput + m_vecColorScale = 0x380 # CParticleCollectionVecInput + m_flAlpha = 0x9D8 # CPerParticleFloatInput + m_nColorBlendType = 0xB30 # ParticleColorBlendType_t + +class C_OP_RenderModels: + m_bOnlyRenderInEffectsBloomPass = 0x200 # bool + m_bOnlyRenderInEffectsWaterPass = 0x201 # bool + m_bUseMixedResolutionRendering = 0x202 # bool + m_bOnlyRenderInEffecsGameOverlay = 0x203 # bool + m_ModelList = 0x208 # CUtlVector + m_nBodyGroupField = 0x224 # ParticleAttributeIndex_t + m_nSubModelField = 0x228 # ParticleAttributeIndex_t + m_bIgnoreNormal = 0x22C # bool + m_bOrientZ = 0x22D # bool + m_bCenterOffset = 0x22E # bool + m_vecLocalOffset = 0x230 # CPerParticleVecInput + m_vecLocalRotation = 0x888 # CPerParticleVecInput + m_bIgnoreRadius = 0xEE0 # bool + m_nModelScaleCP = 0xEE4 # int32_t + m_vecComponentScale = 0xEE8 # CPerParticleVecInput + m_bLocalScale = 0x1540 # bool + m_nSizeCullBloat = 0x1544 # int32_t + m_bAnimated = 0x1548 # bool + m_flAnimationRate = 0x154C # float + m_bScaleAnimationRate = 0x1550 # bool + m_bForceLoopingAnimation = 0x1551 # bool + m_bResetAnimOnStop = 0x1552 # bool + m_bManualAnimFrame = 0x1553 # bool + m_nAnimationScaleField = 0x1554 # ParticleAttributeIndex_t + m_nAnimationField = 0x1558 # ParticleAttributeIndex_t + m_nManualFrameField = 0x155C # ParticleAttributeIndex_t + m_ActivityName = 0x1560 # char[256] + m_SequenceName = 0x1660 # char[256] + m_bEnableClothSimulation = 0x1760 # bool + m_hOverrideMaterial = 0x1768 # CStrongHandle + m_bOverrideTranslucentMaterials = 0x1770 # bool + m_nSkin = 0x1778 # CPerParticleFloatInput + m_MaterialVars = 0x18D0 # CUtlVector + m_modelInput = 0x18E8 # CParticleModelInput + m_nLOD = 0x1948 # int32_t + m_EconSlotName = 0x194C # char[256] + m_bOriginalModel = 0x1A4C # bool + m_bSuppressTint = 0x1A4D # bool + m_bUseRawMeshGroup = 0x1A4E # bool + m_bDisableShadows = 0x1A4F # bool + m_bAcceptsDecals = 0x1A50 # bool + m_bForceDrawInterlevedWithSiblings = 0x1A51 # bool + m_bDoNotDrawInParticlePass = 0x1A52 # bool + m_szRenderAttribute = 0x1A53 # char[260] + m_flRadiusScale = 0x1B58 # CParticleCollectionFloatInput + m_flAlphaScale = 0x1CB0 # CParticleCollectionFloatInput + m_flRollScale = 0x1E08 # CParticleCollectionFloatInput + m_nAlpha2Field = 0x1F60 # ParticleAttributeIndex_t + m_vecColorScale = 0x1F68 # CParticleCollectionVecInput + m_nColorBlendType = 0x25C0 # ParticleColorBlendType_t + +class C_OP_RenderOmni2Light: + m_nLightType = 0x200 # ParticleOmni2LightTypeChoiceList_t + m_vColorBlend = 0x208 # CParticleCollectionVecInput + m_nColorBlendType = 0x860 # ParticleColorBlendType_t + m_nBrightnessUnit = 0x864 # ParticleLightUnitChoiceList_t + m_flBrightnessLumens = 0x868 # CPerParticleFloatInput + m_flBrightnessCandelas = 0x9C0 # CPerParticleFloatInput + m_bCastShadows = 0xB18 # bool + m_flLuminaireRadius = 0xB20 # CPerParticleFloatInput + m_flSkirt = 0xC78 # CPerParticleFloatInput + m_flRange = 0xDD0 # CPerParticleFloatInput + m_flInnerConeAngle = 0xF28 # CPerParticleFloatInput + m_flOuterConeAngle = 0x1080 # CPerParticleFloatInput + m_hLightCookie = 0x11D8 # CStrongHandle + m_bSphericalCookie = 0x11E0 # bool + +class C_OP_RenderPoints: + m_hMaterial = 0x200 # CStrongHandle + +class C_OP_RenderPostProcessing: + m_flPostProcessStrength = 0x200 # CPerParticleFloatInput + m_hPostTexture = 0x358 # CStrongHandle + m_nPriority = 0x360 # ParticlePostProcessPriorityGroup_t + +class C_OP_RenderProjected: + m_bProjectCharacter = 0x200 # bool + m_bProjectWorld = 0x201 # bool + m_bProjectWater = 0x202 # bool + m_bFlipHorizontal = 0x203 # bool + m_bEnableProjectedDepthControls = 0x204 # bool + m_flMinProjectionDepth = 0x208 # float + m_flMaxProjectionDepth = 0x20C # float + m_hProjectedMaterial = 0x210 # CStrongHandle + m_flAnimationTimeScale = 0x218 # float + m_bOrientToNormal = 0x21C # bool + m_MaterialVars = 0x220 # CUtlVector + +class C_OP_RenderRopes: + m_bEnableFadingAndClamping = 0x2470 # bool + m_flMinSize = 0x2474 # float + m_flMaxSize = 0x2478 # float + m_flStartFadeSize = 0x247C # float + m_flEndFadeSize = 0x2480 # float + m_flStartFadeDot = 0x2484 # float + m_flEndFadeDot = 0x2488 # float + m_flRadiusTaper = 0x248C # float + m_nMinTesselation = 0x2490 # int32_t + m_nMaxTesselation = 0x2494 # int32_t + m_flTessScale = 0x2498 # float + m_flTextureVWorldSize = 0x24A0 # CParticleCollectionRendererFloatInput + m_flTextureVScrollRate = 0x25F8 # CParticleCollectionRendererFloatInput + m_flTextureVOffset = 0x2750 # CParticleCollectionRendererFloatInput + m_nTextureVParamsCP = 0x28A8 # int32_t + m_bClampV = 0x28AC # bool + m_nScaleCP1 = 0x28B0 # int32_t + m_nScaleCP2 = 0x28B4 # int32_t + m_flScaleVSizeByControlPointDistance = 0x28B8 # float + m_flScaleVScrollByControlPointDistance = 0x28BC # float + m_flScaleVOffsetByControlPointDistance = 0x28C0 # float + m_bUseScalarForTextureCoordinate = 0x28C5 # bool + m_nScalarFieldForTextureCoordinate = 0x28C8 # ParticleAttributeIndex_t + m_flScalarAttributeTextureCoordScale = 0x28CC # float + m_bReverseOrder = 0x28D0 # bool + m_bClosedLoop = 0x28D1 # bool + m_nOrientationType = 0x28D4 # ParticleOrientationChoiceList_t + m_nVectorFieldForOrientation = 0x28D8 # ParticleAttributeIndex_t + m_bDrawAsOpaque = 0x28DC # bool + m_bGenerateNormals = 0x28DD # bool + +class C_OP_RenderScreenShake: + m_flDurationScale = 0x200 # float + m_flRadiusScale = 0x204 # float + m_flFrequencyScale = 0x208 # float + m_flAmplitudeScale = 0x20C # float + m_nRadiusField = 0x210 # ParticleAttributeIndex_t + m_nDurationField = 0x214 # ParticleAttributeIndex_t + m_nFrequencyField = 0x218 # ParticleAttributeIndex_t + m_nAmplitudeField = 0x21C # ParticleAttributeIndex_t + m_nFilterCP = 0x220 # int32_t + +class C_OP_RenderScreenVelocityRotate: + m_flRotateRateDegrees = 0x200 # float + m_flForwardDegrees = 0x204 # float + +class C_OP_RenderSound: + m_flDurationScale = 0x200 # float + m_flSndLvlScale = 0x204 # float + m_flPitchScale = 0x208 # float + m_flVolumeScale = 0x20C # float + m_nSndLvlField = 0x210 # ParticleAttributeIndex_t + m_nDurationField = 0x214 # ParticleAttributeIndex_t + m_nPitchField = 0x218 # ParticleAttributeIndex_t + m_nVolumeField = 0x21C # ParticleAttributeIndex_t + m_nChannel = 0x220 # int32_t + m_nCPReference = 0x224 # int32_t + m_pszSoundName = 0x228 # char[256] + m_bSuppressStopSoundEvent = 0x328 # bool + +class C_OP_RenderSprites: + m_nSequenceOverride = 0x2470 # CParticleCollectionRendererFloatInput + m_nOrientationType = 0x25C8 # ParticleOrientationChoiceList_t + m_nOrientationControlPoint = 0x25CC # int32_t + m_bUseYawWithNormalAligned = 0x25D0 # bool + m_flMinSize = 0x25D4 # float + m_flMaxSize = 0x25D8 # float + m_flAlphaAdjustWithSizeAdjust = 0x25DC # float + m_flStartFadeSize = 0x25E0 # CParticleCollectionRendererFloatInput + m_flEndFadeSize = 0x2738 # CParticleCollectionRendererFloatInput + m_flStartFadeDot = 0x2890 # float + m_flEndFadeDot = 0x2894 # float + m_bDistanceAlpha = 0x2898 # bool + m_bSoftEdges = 0x2899 # bool + m_flEdgeSoftnessStart = 0x289C # float + m_flEdgeSoftnessEnd = 0x28A0 # float + m_bOutline = 0x28A4 # bool + m_OutlineColor = 0x28A5 # Color + m_nOutlineAlpha = 0x28AC # int32_t + m_flOutlineStart0 = 0x28B0 # float + m_flOutlineStart1 = 0x28B4 # float + m_flOutlineEnd0 = 0x28B8 # float + m_flOutlineEnd1 = 0x28BC # float + m_nLightingMode = 0x28C0 # ParticleLightingQuality_t + m_flLightingTessellation = 0x28C8 # CParticleCollectionRendererFloatInput + m_flLightingDirectionality = 0x2A20 # CParticleCollectionRendererFloatInput + m_bParticleShadows = 0x2B78 # bool + m_flShadowDensity = 0x2B7C # float + +class C_OP_RenderStandardLight: + m_nLightType = 0x200 # ParticleLightTypeChoiceList_t + m_vecColorScale = 0x208 # CParticleCollectionVecInput + m_nColorBlendType = 0x860 # ParticleColorBlendType_t + m_flIntensity = 0x868 # CParticleCollectionFloatInput + m_bCastShadows = 0x9C0 # bool + m_flTheta = 0x9C8 # CParticleCollectionFloatInput + m_flPhi = 0xB20 # CParticleCollectionFloatInput + m_flRadiusMultiplier = 0xC78 # CParticleCollectionFloatInput + m_nAttenuationStyle = 0xDD0 # StandardLightingAttenuationStyle_t + m_flFalloffLinearity = 0xDD8 # CParticleCollectionFloatInput + m_flFiftyPercentFalloff = 0xF30 # CParticleCollectionFloatInput + m_flZeroPercentFalloff = 0x1088 # CParticleCollectionFloatInput + m_bRenderDiffuse = 0x11E0 # bool + m_bRenderSpecular = 0x11E1 # bool + m_lightCookie = 0x11E8 # CUtlString + m_nPriority = 0x11F0 # int32_t + m_nFogLightingMode = 0x11F4 # ParticleLightFogLightingMode_t + m_flFogContribution = 0x11F8 # CParticleCollectionRendererFloatInput + m_nCapsuleLightBehavior = 0x1350 # ParticleLightBehaviorChoiceList_t + m_flCapsuleLength = 0x1354 # float + m_bReverseOrder = 0x1358 # bool + m_bClosedLoop = 0x1359 # bool + m_nPrevPntSource = 0x135C # ParticleAttributeIndex_t + m_flMaxLength = 0x1360 # float + m_flMinLength = 0x1364 # float + m_bIgnoreDT = 0x1368 # bool + m_flConstrainRadiusToLengthRatio = 0x136C # float + m_flLengthScale = 0x1370 # float + m_flLengthFadeInTime = 0x1374 # float + +class C_OP_RenderStatusEffect: + m_pTextureColorWarp = 0x200 # CStrongHandle + m_pTextureDetail2 = 0x208 # CStrongHandle + m_pTextureDiffuseWarp = 0x210 # CStrongHandle + m_pTextureFresnelColorWarp = 0x218 # CStrongHandle + m_pTextureFresnelWarp = 0x220 # CStrongHandle + m_pTextureSpecularWarp = 0x228 # CStrongHandle + m_pTextureEnvMap = 0x230 # CStrongHandle + +class C_OP_RenderStatusEffectCitadel: + m_pTextureColorWarp = 0x200 # CStrongHandle + m_pTextureNormal = 0x208 # CStrongHandle + m_pTextureMetalness = 0x210 # CStrongHandle + m_pTextureRoughness = 0x218 # CStrongHandle + m_pTextureSelfIllum = 0x220 # CStrongHandle + m_pTextureDetail = 0x228 # CStrongHandle + +class C_OP_RenderText: + m_OutlineColor = 0x200 # Color + m_DefaultText = 0x208 # CUtlString + +class C_OP_RenderTonemapController: + m_flTonemapLevel = 0x200 # float + m_flTonemapWeight = 0x204 # float + m_nTonemapLevelField = 0x208 # ParticleAttributeIndex_t + m_nTonemapWeightField = 0x20C # ParticleAttributeIndex_t + +class C_OP_RenderTrails: + m_bEnableFadingAndClamping = 0x2740 # bool + m_flStartFadeDot = 0x2744 # float + m_flEndFadeDot = 0x2748 # float + m_nPrevPntSource = 0x274C # ParticleAttributeIndex_t + m_flMaxLength = 0x2750 # float + m_flMinLength = 0x2754 # float + m_bIgnoreDT = 0x2758 # bool + m_flConstrainRadiusToLengthRatio = 0x275C # float + m_flLengthScale = 0x2760 # float + m_flLengthFadeInTime = 0x2764 # float + m_flRadiusHeadTaper = 0x2768 # CPerParticleFloatInput + m_vecHeadColorScale = 0x28C0 # CParticleCollectionVecInput + m_flHeadAlphaScale = 0x2F18 # CPerParticleFloatInput + m_flRadiusTaper = 0x3070 # CPerParticleFloatInput + m_vecTailColorScale = 0x31C8 # CParticleCollectionVecInput + m_flTailAlphaScale = 0x3820 # CPerParticleFloatInput + m_nHorizCropField = 0x3978 # ParticleAttributeIndex_t + m_nVertCropField = 0x397C # ParticleAttributeIndex_t + m_flForwardShift = 0x3980 # float + m_bFlipUVBasedOnPitchYaw = 0x3984 # bool + +class C_OP_RenderTreeShake: + m_flPeakStrength = 0x200 # float + m_nPeakStrengthFieldOverride = 0x204 # ParticleAttributeIndex_t + m_flRadius = 0x208 # float + m_nRadiusFieldOverride = 0x20C # ParticleAttributeIndex_t + m_flShakeDuration = 0x210 # float + m_flTransitionTime = 0x214 # float + m_flTwistAmount = 0x218 # float + m_flRadialAmount = 0x21C # float + m_flControlPointOrientationAmount = 0x220 # float + m_nControlPointForLinearDirection = 0x224 # int32_t + +class C_OP_RenderVRHapticEvent: + m_nHand = 0x200 # ParticleVRHandChoiceList_t + m_nOutputHandCP = 0x204 # int32_t + m_nOutputField = 0x208 # int32_t + m_flAmplitude = 0x210 # CPerParticleFloatInput + +class C_OP_RepeatedTriggerChildGroup: + m_nChildGroupID = 0x1D0 # int32_t + m_flClusterRefireTime = 0x1D8 # CParticleCollectionFloatInput + m_flClusterSize = 0x330 # CParticleCollectionFloatInput + m_flClusterCooldown = 0x488 # CParticleCollectionFloatInput + m_bLimitChildCount = 0x5E0 # bool + +class C_OP_RestartAfterDuration: + m_flDurationMin = 0x1C0 # float + m_flDurationMax = 0x1C4 # float + m_nCP = 0x1C8 # int32_t + m_nCPField = 0x1CC # int32_t + m_nChildGroupID = 0x1D0 # int32_t + m_bOnlyChildren = 0x1D4 # bool + +class C_OP_RopeSpringConstraint: + m_flRestLength = 0x1C0 # CParticleCollectionFloatInput + m_flMinDistance = 0x318 # CParticleCollectionFloatInput + m_flMaxDistance = 0x470 # CParticleCollectionFloatInput + m_flAdjustmentScale = 0x5C8 # float + m_flInitialRestingLength = 0x5D0 # CParticleCollectionFloatInput + +class C_OP_RotateVector: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_vecRotAxisMin = 0x1C4 # Vector + m_vecRotAxisMax = 0x1D0 # Vector + m_flRotRateMin = 0x1DC # float + m_flRotRateMax = 0x1E0 # float + m_bNormalize = 0x1E4 # bool + m_flScale = 0x1E8 # CPerParticleFloatInput + +class C_OP_RtEnvCull: + m_vecTestDir = 0x1C0 # Vector + m_vecTestNormal = 0x1CC # Vector + m_bCullOnMiss = 0x1D8 # bool + m_bStickInsteadOfCull = 0x1D9 # bool + m_RtEnvName = 0x1DA # char[128] + m_nRTEnvCP = 0x25C # int32_t + m_nComponent = 0x260 # int32_t + +class C_OP_SDFConstraint: + m_flMinDist = 0x1C0 # CParticleCollectionFloatInput + m_flMaxDist = 0x318 # CParticleCollectionFloatInput + m_nMaxIterations = 0x470 # int32_t + +class C_OP_SDFForce: + m_flForceScale = 0x1D0 # float + +class C_OP_SDFLighting: + m_vLightingDir = 0x1C0 # Vector + m_vTint_0 = 0x1CC # Vector + m_vTint_1 = 0x1D8 # Vector + +class C_OP_SelectivelyEnableChildren: + m_nChildGroupID = 0x1D0 # CParticleCollectionFloatInput + m_nFirstChild = 0x328 # CParticleCollectionFloatInput + m_nNumChildrenToEnable = 0x480 # CParticleCollectionFloatInput + m_bPlayEndcapOnStop = 0x5D8 # bool + m_bDestroyImmediately = 0x5D9 # bool + +class C_OP_SequenceFromModel: + m_nControlPointNumber = 0x1C0 # int32_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + m_nFieldOutputAnim = 0x1C8 # ParticleAttributeIndex_t + m_flInputMin = 0x1CC # float + m_flInputMax = 0x1D0 # float + m_flOutputMin = 0x1D4 # float + m_flOutputMax = 0x1D8 # float + m_nSetMethod = 0x1DC # ParticleSetMethod_t + +class C_OP_SetAttributeToScalarExpression: + m_nExpression = 0x1C0 # ScalarExpressionType_t + m_flInput1 = 0x1C8 # CPerParticleFloatInput + m_flInput2 = 0x320 # CPerParticleFloatInput + m_nOutputField = 0x478 # ParticleAttributeIndex_t + m_nSetMethod = 0x47C # ParticleSetMethod_t + +class C_OP_SetCPOrientationToDirection: + m_nInputControlPoint = 0x1C0 # int32_t + m_nOutputControlPoint = 0x1C4 # int32_t + +class C_OP_SetCPOrientationToGroundNormal: + m_flInterpRate = 0x1C0 # float + m_flMaxTraceLength = 0x1C4 # float + m_flTolerance = 0x1C8 # float + m_flTraceOffset = 0x1CC # float + m_CollisionGroupName = 0x1D0 # char[128] + m_nTraceSet = 0x250 # ParticleTraceSet_t + m_nInputCP = 0x254 # int32_t + m_nOutputCP = 0x258 # int32_t + m_bIncludeWater = 0x268 # bool + +class C_OP_SetCPOrientationToPointAtCP: + m_nInputCP = 0x1D0 # int32_t + m_nOutputCP = 0x1D4 # int32_t + m_flInterpolation = 0x1D8 # CParticleCollectionFloatInput + m_b2DOrientation = 0x330 # bool + m_bAvoidSingularity = 0x331 # bool + m_bPointAway = 0x332 # bool + +class C_OP_SetCPtoVector: + m_nCPInput = 0x1C0 # int32_t + m_nFieldOutput = 0x1C4 # ParticleAttributeIndex_t + +class C_OP_SetChildControlPoints: + m_nChildGroupID = 0x1C0 # int32_t + m_nFirstControlPoint = 0x1C4 # int32_t + m_nNumControlPoints = 0x1C8 # int32_t + m_nFirstSourcePoint = 0x1D0 # CParticleCollectionFloatInput + m_bReverse = 0x328 # bool + m_bSetOrientation = 0x329 # bool + +class C_OP_SetControlPointFieldFromVectorExpression: + m_nExpression = 0x1D0 # VectorFloatExpressionType_t + m_vecInput1 = 0x1D8 # CParticleCollectionVecInput + m_vecInput2 = 0x830 # CParticleCollectionVecInput + m_flOutputRemap = 0xE88 # CParticleRemapFloatInput + m_nOutputCP = 0xFE0 # int32_t + m_nOutVectorField = 0xFE4 # int32_t + +class C_OP_SetControlPointFieldToScalarExpression: + m_nExpression = 0x1D0 # ScalarExpressionType_t + m_flInput1 = 0x1D8 # CParticleCollectionFloatInput + m_flInput2 = 0x330 # CParticleCollectionFloatInput + m_flOutputRemap = 0x488 # CParticleRemapFloatInput + m_nOutputCP = 0x5E0 # int32_t + m_nOutVectorField = 0x5E4 # int32_t + +class C_OP_SetControlPointFieldToWater: + m_nSourceCP = 0x1D0 # int32_t + m_nDestCP = 0x1D4 # int32_t + m_nCPField = 0x1D8 # int32_t + +class C_OP_SetControlPointFromObjectScale: + m_nCPInput = 0x1D0 # int32_t + m_nCPOutput = 0x1D4 # int32_t + +class C_OP_SetControlPointOrientation: + m_bUseWorldLocation = 0x1D0 # bool + m_bRandomize = 0x1D2 # bool + m_bSetOnce = 0x1D3 # bool + m_nCP = 0x1D4 # int32_t + m_nHeadLocation = 0x1D8 # int32_t + m_vecRotation = 0x1DC # QAngle + m_vecRotationB = 0x1E8 # QAngle + m_flInterpolation = 0x1F8 # CParticleCollectionFloatInput + +class C_OP_SetControlPointOrientationToCPVelocity: + m_nCPInput = 0x1D0 # int32_t + m_nCPOutput = 0x1D4 # int32_t + +class C_OP_SetControlPointPositionToRandomActiveCP: + m_nCP1 = 0x1D0 # int32_t + m_nHeadLocationMin = 0x1D4 # int32_t + m_nHeadLocationMax = 0x1D8 # int32_t + m_flResetRate = 0x1E0 # CParticleCollectionFloatInput + +class C_OP_SetControlPointPositionToTimeOfDayValue: + m_nControlPointNumber = 0x1D0 # int32_t + m_pszTimeOfDayParameter = 0x1D4 # char[128] + m_vecDefaultValue = 0x254 # Vector + +class C_OP_SetControlPointPositions: + m_bUseWorldLocation = 0x1D0 # bool + m_bOrient = 0x1D1 # bool + m_bSetOnce = 0x1D2 # bool + m_nCP1 = 0x1D4 # int32_t + m_nCP2 = 0x1D8 # int32_t + m_nCP3 = 0x1DC # int32_t + m_nCP4 = 0x1E0 # int32_t + m_vecCP1Pos = 0x1E4 # Vector + m_vecCP2Pos = 0x1F0 # Vector + m_vecCP3Pos = 0x1FC # Vector + m_vecCP4Pos = 0x208 # Vector + m_nHeadLocation = 0x214 # int32_t + +class C_OP_SetControlPointRotation: + m_vecRotAxis = 0x1D0 # CParticleCollectionVecInput + m_flRotRate = 0x828 # CParticleCollectionFloatInput + m_nCP = 0x980 # int32_t + m_nLocalCP = 0x984 # int32_t + +class C_OP_SetControlPointToCPVelocity: + m_nCPInput = 0x1D0 # int32_t + m_nCPOutputVel = 0x1D4 # int32_t + m_bNormalize = 0x1D8 # bool + m_nCPOutputMag = 0x1DC # int32_t + m_nCPField = 0x1E0 # int32_t + m_vecComparisonVelocity = 0x1E8 # CParticleCollectionVecInput + +class C_OP_SetControlPointToCenter: + m_nCP1 = 0x1D0 # int32_t + m_vecCP1Pos = 0x1D4 # Vector + m_nSetParent = 0x1E0 # ParticleParentSetMode_t + +class C_OP_SetControlPointToHMD: + m_nCP1 = 0x1D0 # int32_t + m_vecCP1Pos = 0x1D4 # Vector + m_bOrientToHMD = 0x1E0 # bool + +class C_OP_SetControlPointToHand: + m_nCP1 = 0x1D0 # int32_t + m_nHand = 0x1D4 # int32_t + m_vecCP1Pos = 0x1D8 # Vector + m_bOrientToHand = 0x1E4 # bool + +class C_OP_SetControlPointToImpactPoint: + m_nCPOut = 0x1D0 # int32_t + m_nCPIn = 0x1D4 # int32_t + m_flUpdateRate = 0x1D8 # float + m_flTraceLength = 0x1E0 # CParticleCollectionFloatInput + m_flStartOffset = 0x338 # float + m_flOffset = 0x33C # float + m_vecTraceDir = 0x340 # Vector + m_CollisionGroupName = 0x34C # char[128] + m_nTraceSet = 0x3CC # ParticleTraceSet_t + m_bSetToEndpoint = 0x3D0 # bool + m_bTraceToClosestSurface = 0x3D1 # bool + m_bIncludeWater = 0x3D2 # bool + +class C_OP_SetControlPointToPlayer: + m_nCP1 = 0x1D0 # int32_t + m_vecCP1Pos = 0x1D4 # Vector + m_bOrientToEyes = 0x1E0 # bool + +class C_OP_SetControlPointToVectorExpression: + m_nExpression = 0x1D0 # VectorExpressionType_t + m_nOutputCP = 0x1D4 # int32_t + m_vInput1 = 0x1D8 # CParticleCollectionVecInput + m_vInput2 = 0x830 # CParticleCollectionVecInput + m_bNormalizedOutput = 0xE88 # bool + +class C_OP_SetControlPointToWaterSurface: + m_nSourceCP = 0x1D0 # int32_t + m_nDestCP = 0x1D4 # int32_t + m_nFlowCP = 0x1D8 # int32_t + m_nActiveCP = 0x1DC # int32_t + m_nActiveCPField = 0x1E0 # int32_t + m_flRetestRate = 0x1E8 # CParticleCollectionFloatInput + m_bAdaptiveThreshold = 0x340 # bool + +class C_OP_SetControlPointsToModelParticles: + m_HitboxSetName = 0x1C0 # char[128] + m_AttachmentName = 0x240 # char[128] + m_nFirstControlPoint = 0x2C0 # int32_t + m_nNumControlPoints = 0x2C4 # int32_t + m_nFirstSourcePoint = 0x2C8 # int32_t + m_bSkin = 0x2CC # bool + m_bAttachment = 0x2CD # bool + +class C_OP_SetControlPointsToParticle: + m_nChildGroupID = 0x1C0 # int32_t + m_nFirstControlPoint = 0x1C4 # int32_t + m_nNumControlPoints = 0x1C8 # int32_t + m_nFirstSourcePoint = 0x1CC # int32_t + m_bSetOrientation = 0x1D0 # bool + m_nOrientationMode = 0x1D4 # ParticleOrientationSetMode_t + m_nSetParent = 0x1D8 # ParticleParentSetMode_t + +class C_OP_SetFloat: + m_InputValue = 0x1C0 # CPerParticleFloatInput + m_nOutputField = 0x318 # ParticleAttributeIndex_t + m_nSetMethod = 0x31C # ParticleSetMethod_t + m_Lerp = 0x320 # CPerParticleFloatInput + m_bUseNewCode = 0x478 # bool + +class C_OP_SetFloatAttributeToVectorExpression: + m_nExpression = 0x1C0 # VectorFloatExpressionType_t + m_vInput1 = 0x1C8 # CPerParticleVecInput + m_vInput2 = 0x820 # CPerParticleVecInput + m_flOutputRemap = 0xE78 # CParticleRemapFloatInput + m_nOutputField = 0xFD0 # ParticleAttributeIndex_t + m_nSetMethod = 0xFD4 # ParticleSetMethod_t + +class C_OP_SetFloatCollection: + m_InputValue = 0x1C0 # CParticleCollectionFloatInput + m_nOutputField = 0x318 # ParticleAttributeIndex_t + m_nSetMethod = 0x31C # ParticleSetMethod_t + m_Lerp = 0x320 # CParticleCollectionFloatInput + +class C_OP_SetFromCPSnapshot: + m_nControlPointNumber = 0x1C0 # int32_t + m_nAttributeToRead = 0x1C4 # ParticleAttributeIndex_t + m_nAttributeToWrite = 0x1C8 # ParticleAttributeIndex_t + m_nLocalSpaceCP = 0x1CC # int32_t + m_bRandom = 0x1D0 # bool + m_bReverse = 0x1D1 # bool + m_nRandomSeed = 0x1D4 # int32_t + m_nSnapShotStartPoint = 0x1D8 # CParticleCollectionFloatInput + m_nSnapShotIncrement = 0x330 # CParticleCollectionFloatInput + m_flInterpolation = 0x488 # CPerParticleFloatInput + m_bSubSample = 0x5E0 # bool + +class C_OP_SetGravityToCP: + m_nCPInput = 0x1D0 # int32_t + m_nCPOutput = 0x1D4 # int32_t + m_flScale = 0x1D8 # CParticleCollectionFloatInput + m_bSetOrientation = 0x330 # bool + m_bSetZDown = 0x331 # bool + +class C_OP_SetParentControlPointsToChildCP: + m_nChildGroupID = 0x1D0 # int32_t + m_nChildControlPoint = 0x1D4 # int32_t + m_nNumControlPoints = 0x1D8 # int32_t + m_nFirstSourcePoint = 0x1DC # int32_t + m_bSetOrientation = 0x1E0 # bool + +class C_OP_SetPerChildControlPoint: + m_nChildGroupID = 0x1C0 # int32_t + m_nFirstControlPoint = 0x1C4 # int32_t + m_nNumControlPoints = 0x1C8 # int32_t + m_nParticleIncrement = 0x1D0 # CParticleCollectionFloatInput + m_nFirstSourcePoint = 0x328 # CParticleCollectionFloatInput + m_bSetOrientation = 0x480 # bool + m_nOrientationField = 0x484 # ParticleAttributeIndex_t + m_bNumBasedOnParticleCount = 0x488 # bool + +class C_OP_SetPerChildControlPointFromAttribute: + m_nChildGroupID = 0x1C0 # int32_t + m_nFirstControlPoint = 0x1C4 # int32_t + m_nNumControlPoints = 0x1C8 # int32_t + m_nParticleIncrement = 0x1CC # int32_t + m_nFirstSourcePoint = 0x1D0 # int32_t + m_bNumBasedOnParticleCount = 0x1D4 # bool + m_nAttributeToRead = 0x1D8 # ParticleAttributeIndex_t + m_nCPField = 0x1DC # int32_t + +class C_OP_SetRandomControlPointPosition: + m_bUseWorldLocation = 0x1D0 # bool + m_bOrient = 0x1D1 # bool + m_nCP1 = 0x1D4 # int32_t + m_nHeadLocation = 0x1D8 # int32_t + m_flReRandomRate = 0x1E0 # CParticleCollectionFloatInput + m_vecCPMinPos = 0x338 # Vector + m_vecCPMaxPos = 0x344 # Vector + m_flInterpolation = 0x350 # CParticleCollectionFloatInput + +class C_OP_SetSimulationRate: + m_flSimulationScale = 0x1D0 # CParticleCollectionFloatInput + +class C_OP_SetSingleControlPointPosition: + m_bSetOnce = 0x1D0 # bool + m_nCP1 = 0x1D4 # int32_t + m_vecCP1Pos = 0x1D8 # CParticleCollectionVecInput + m_transformInput = 0x830 # CParticleTransformInput + +class C_OP_SetToCP: + m_nControlPointNumber = 0x1C0 # int32_t + m_vecOffset = 0x1C4 # Vector + m_bOffsetLocal = 0x1D0 # bool + +class C_OP_SetVariable: + m_variableReference = 0x1D0 # CParticleVariableRef + m_transformInput = 0x210 # CParticleTransformInput + m_positionOffset = 0x278 # Vector + m_rotationOffset = 0x284 # QAngle + m_vecInput = 0x290 # CParticleCollectionVecInput + m_floatInput = 0x8E8 # CParticleCollectionFloatInput + +class C_OP_SetVec: + m_InputValue = 0x1C0 # CPerParticleVecInput + m_nOutputField = 0x818 # ParticleAttributeIndex_t + m_nSetMethod = 0x81C # ParticleSetMethod_t + m_Lerp = 0x820 # CPerParticleFloatInput + m_bNormalizedOutput = 0x978 # bool + +class C_OP_SetVectorAttributeToVectorExpression: + m_nExpression = 0x1C0 # VectorExpressionType_t + m_vInput1 = 0x1C8 # CPerParticleVecInput + m_vInput2 = 0x820 # CPerParticleVecInput + m_nOutputField = 0xE78 # ParticleAttributeIndex_t + m_nSetMethod = 0xE7C # ParticleSetMethod_t + m_bNormalizedOutput = 0xE80 # bool + +class C_OP_ShapeMatchingConstraint: + m_flShapeRestorationTime = 0x1C0 # float + +class C_OP_SnapshotRigidSkinToBones: + m_bTransformNormals = 0x1C0 # bool + m_bTransformRadii = 0x1C1 # bool + m_nControlPointNumber = 0x1C4 # int32_t + +class C_OP_SnapshotSkinToBones: + m_bTransformNormals = 0x1C0 # bool + m_bTransformRadii = 0x1C1 # bool + m_nControlPointNumber = 0x1C4 # int32_t + m_flLifeTimeFadeStart = 0x1C8 # float + m_flLifeTimeFadeEnd = 0x1CC # float + m_flJumpThreshold = 0x1D0 # float + m_flPrevPosScale = 0x1D4 # float + +class C_OP_SpringToVectorConstraint: + m_flRestLength = 0x1C0 # CPerParticleFloatInput + m_flMinDistance = 0x318 # CPerParticleFloatInput + m_flMaxDistance = 0x470 # CPerParticleFloatInput + m_flRestingLength = 0x5C8 # CPerParticleFloatInput + m_vecAnchorVector = 0x720 # CPerParticleVecInput + +class C_OP_StopAfterCPDuration: + m_flDuration = 0x1D0 # CParticleCollectionFloatInput + m_bDestroyImmediately = 0x328 # bool + m_bPlayEndCap = 0x329 # bool + +class C_OP_TeleportBeam: + m_nCPPosition = 0x1C0 # int32_t + m_nCPVelocity = 0x1C4 # int32_t + m_nCPMisc = 0x1C8 # int32_t + m_nCPColor = 0x1CC # int32_t + m_nCPInvalidColor = 0x1D0 # int32_t + m_nCPExtraArcData = 0x1D4 # int32_t + m_vGravity = 0x1D8 # Vector + m_flArcMaxDuration = 0x1E4 # float + m_flSegmentBreak = 0x1E8 # float + m_flArcSpeed = 0x1EC # float + m_flAlpha = 0x1F0 # float + +class C_OP_TimeVaryingForce: + m_flStartLerpTime = 0x1D0 # float + m_StartingForce = 0x1D4 # Vector + m_flEndLerpTime = 0x1E0 # float + m_EndingForce = 0x1E4 # Vector + +class C_OP_TurbulenceForce: + m_flNoiseCoordScale0 = 0x1D0 # float + m_flNoiseCoordScale1 = 0x1D4 # float + m_flNoiseCoordScale2 = 0x1D8 # float + m_flNoiseCoordScale3 = 0x1DC # float + m_vecNoiseAmount0 = 0x1E0 # Vector + m_vecNoiseAmount1 = 0x1EC # Vector + m_vecNoiseAmount2 = 0x1F8 # Vector + m_vecNoiseAmount3 = 0x204 # Vector + +class C_OP_TwistAroundAxis: + m_fForceAmount = 0x1D0 # float + m_TwistAxis = 0x1D4 # Vector + m_bLocalSpace = 0x1E0 # bool + m_nControlPointNumber = 0x1E4 # int32_t + +class C_OP_UpdateLightSource: + m_vColorTint = 0x1C0 # Color + m_flBrightnessScale = 0x1C4 # float + m_flRadiusScale = 0x1C8 # float + m_flMinimumLightingRadius = 0x1CC # float + m_flMaximumLightingRadius = 0x1D0 # float + m_flPositionDampingConstant = 0x1D4 # float + +class C_OP_VectorFieldSnapshot: + m_nControlPointNumber = 0x1C0 # int32_t + m_nAttributeToWrite = 0x1C4 # ParticleAttributeIndex_t + m_nLocalSpaceCP = 0x1C8 # int32_t + m_flInterpolation = 0x1D0 # CPerParticleFloatInput + m_vecScale = 0x328 # CPerParticleVecInput + m_flBoundaryDampening = 0x980 # float + m_bSetVelocity = 0x984 # bool + m_bLockToSurface = 0x985 # bool + m_flGridSpacing = 0x988 # float + +class C_OP_VectorNoise: + m_nFieldOutput = 0x1C0 # ParticleAttributeIndex_t + m_vecOutputMin = 0x1C4 # Vector + m_vecOutputMax = 0x1D0 # Vector + m_fl4NoiseScale = 0x1DC # float + m_bAdditive = 0x1E0 # bool + m_bOffset = 0x1E1 # bool + m_flNoiseAnimationTimeScale = 0x1E4 # float + +class C_OP_VelocityDecay: + m_flMinVelocity = 0x1C0 # float + +class C_OP_VelocityMatchingForce: + m_flDirScale = 0x1C0 # float + m_flSpdScale = 0x1C4 # float + m_nCPBroadcast = 0x1C8 # int32_t + +class C_OP_WindForce: + m_vForce = 0x1D0 # Vector + +class C_OP_WorldTraceConstraint: + m_nCP = 0x1C0 # int32_t + m_vecCpOffset = 0x1C4 # Vector + m_nCollisionMode = 0x1D0 # ParticleCollisionMode_t + m_nCollisionModeMin = 0x1D4 # ParticleCollisionMode_t + m_nTraceSet = 0x1D8 # ParticleTraceSet_t + m_CollisionGroupName = 0x1DC # char[128] + m_bWorldOnly = 0x25C # bool + m_bBrushOnly = 0x25D # bool + m_bIncludeWater = 0x25E # bool + m_nIgnoreCP = 0x260 # int32_t + m_flCpMovementTolerance = 0x264 # float + m_flRetestRate = 0x268 # float + m_flTraceTolerance = 0x26C # float + m_flCollisionConfirmationSpeed = 0x270 # float + m_nMaxTracesPerFrame = 0x274 # float + m_flRadiusScale = 0x278 # CPerParticleFloatInput + m_flBounceAmount = 0x3D0 # CPerParticleFloatInput + m_flSlideAmount = 0x528 # CPerParticleFloatInput + m_flRandomDirScale = 0x680 # CPerParticleFloatInput + m_bDecayBounce = 0x7D8 # bool + m_bKillonContact = 0x7D9 # bool + m_flMinSpeed = 0x7DC # float + m_bSetNormal = 0x7E0 # bool + m_nStickOnCollisionField = 0x7E4 # ParticleAttributeIndex_t + m_flStopSpeed = 0x7E8 # CPerParticleFloatInput + m_nEntityStickDataField = 0x940 # ParticleAttributeIndex_t + m_nEntityStickNormalField = 0x944 # ParticleAttributeIndex_t + +class CollisionGroupContext_t: + m_nCollisionGroupNumber = 0x0 # int32_t + +class ControlPointReference_t: + m_controlPointNameString = 0x0 # int32_t + m_vOffsetFromControlPoint = 0x4 # Vector + m_bOffsetInLocalSpace = 0x10 # bool + +class FloatInputMaterialVariable_t: + m_strVariable = 0x0 # CUtlString + m_flInput = 0x8 # CParticleCollectionFloatInput + +class MaterialVariable_t: + m_strVariable = 0x0 # CUtlString + m_nVariableField = 0x8 # ParticleAttributeIndex_t + m_flScale = 0xC # float + +class ModelReference_t: + m_model = 0x0 # CStrongHandle + m_flRelativeProbabilityOfSpawn = 0x8 # float + +class PARTICLE_EHANDLE__: + unused = 0x0 # int32_t + +class PARTICLE_WORLD_HANDLE__: + unused = 0x0 # int32_t + +class ParticleAttributeIndex_t: + m_Value = 0x0 # int32_t + +class ParticleChildrenInfo_t: + m_ChildRef = 0x0 # CStrongHandle + m_flDelay = 0x8 # float + m_bEndCap = 0xC # bool + m_bDisableChild = 0xD # bool + m_nDetailLevel = 0x10 # ParticleDetailLevel_t + +class ParticleControlPointConfiguration_t: + m_name = 0x0 # CUtlString + m_drivers = 0x8 # CUtlVector + m_previewState = 0x20 # ParticlePreviewState_t + +class ParticleControlPointDriver_t: + m_iControlPoint = 0x0 # int32_t + m_iAttachType = 0x4 # ParticleAttachment_t + m_attachmentName = 0x8 # CUtlString + m_vecOffset = 0x10 # Vector + m_angOffset = 0x1C # QAngle + m_entityName = 0x28 # CUtlString + +class ParticleNamedValueConfiguration_t: + m_ConfigName = 0x0 # CUtlString + m_ConfigValue = 0x8 # KeyValues3 + m_iAttachType = 0x18 # ParticleAttachment_t + m_BoundEntityPath = 0x20 # CUtlString + m_strEntityScope = 0x28 # CUtlString + m_strAttachmentName = 0x30 # CUtlString + +class ParticleNamedValueSource_t: + m_Name = 0x0 # CUtlString + m_IsPublic = 0x8 # bool + m_ValueType = 0xC # PulseValueType_t + m_DefaultConfig = 0x10 # ParticleNamedValueConfiguration_t + m_NamedConfigs = 0x48 # CUtlVector + +class ParticlePreviewBodyGroup_t: + m_bodyGroupName = 0x0 # CUtlString + m_nValue = 0x8 # int32_t + +class ParticlePreviewState_t: + m_previewModel = 0x0 # CUtlString + m_nModSpecificData = 0x8 # uint32_t + m_groundType = 0xC # PetGroundType_t + m_sequenceName = 0x10 # CUtlString + m_nFireParticleOnSequenceFrame = 0x18 # int32_t + m_hitboxSetName = 0x20 # CUtlString + m_materialGroupName = 0x28 # CUtlString + m_vecBodyGroups = 0x30 # CUtlVector + m_flPlaybackSpeed = 0x48 # float + m_flParticleSimulationRate = 0x4C # float + m_bShouldDrawHitboxes = 0x50 # bool + m_bShouldDrawAttachments = 0x51 # bool + m_bShouldDrawAttachmentNames = 0x52 # bool + m_bShouldDrawControlPointAxes = 0x53 # bool + m_bAnimationNonLooping = 0x54 # bool + m_vecPreviewGravity = 0x58 # Vector + +class PointDefinitionWithTimeValues_t: + m_flTimeDuration = 0x14 # float + +class PointDefinition_t: + m_nControlPoint = 0x0 # int32_t + m_bLocalCoords = 0x4 # bool + m_vOffset = 0x8 # Vector + +class SequenceWeightedList_t: + m_nSequence = 0x0 # int32_t + m_flRelativeWeight = 0x4 # float + +class TextureControls_t: + m_flFinalTextureScaleU = 0x0 # CParticleCollectionRendererFloatInput + m_flFinalTextureScaleV = 0x158 # CParticleCollectionRendererFloatInput + m_flFinalTextureOffsetU = 0x2B0 # CParticleCollectionRendererFloatInput + m_flFinalTextureOffsetV = 0x408 # CParticleCollectionRendererFloatInput + m_flFinalTextureUVRotation = 0x560 # CParticleCollectionRendererFloatInput + m_flZoomScale = 0x6B8 # CParticleCollectionRendererFloatInput + m_flDistortion = 0x810 # CParticleCollectionRendererFloatInput + m_bRandomizeOffsets = 0x968 # bool + m_bClampUVs = 0x969 # bool + m_nPerParticleBlend = 0x96C # SpriteCardPerParticleScale_t + m_nPerParticleScale = 0x970 # SpriteCardPerParticleScale_t + m_nPerParticleOffsetU = 0x974 # SpriteCardPerParticleScale_t + m_nPerParticleOffsetV = 0x978 # SpriteCardPerParticleScale_t + m_nPerParticleRotation = 0x97C # SpriteCardPerParticleScale_t + m_nPerParticleZoom = 0x980 # SpriteCardPerParticleScale_t + m_nPerParticleDistortion = 0x984 # SpriteCardPerParticleScale_t + +class TextureGroup_t: + m_bEnabled = 0x0 # bool + m_bReplaceTextureWithGradient = 0x1 # bool + m_hTexture = 0x8 # CStrongHandle + m_Gradient = 0x10 # CColorGradient + m_nTextureType = 0x28 # SpriteCardTextureType_t + m_nTextureChannels = 0x2C # SpriteCardTextureChannel_t + m_nTextureBlendMode = 0x30 # ParticleTextureLayerBlendType_t + m_flTextureBlend = 0x38 # CParticleCollectionRendererFloatInput + m_TextureControls = 0x190 # TextureControls_t + +class VecInputMaterialVariable_t: + m_strVariable = 0x0 # CUtlString + m_vecInput = 0x8 # CParticleCollectionVecInput diff --git a/generated/particles.dll.rs b/generated/particles.dll.rs index 32040c0..0364a08 100644 --- a/generated/particles.dll.rs +++ b/generated/particles.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:32.008264 UTC + * 2023-10-17 02:04:50.428899600 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod CBaseRendererSource2 { pub const m_flRadiusScale: usize = 0x200; // CParticleCollectionRendererFloatInput pub const m_flAlphaScale: usize = 0x358; // CParticleCollectionRendererFloatInput diff --git a/generated/pulse_system.dll.cs b/generated/pulse_system.dll.cs index 6f5828a..6d6a7fd 100644 --- a/generated/pulse_system.dll.cs +++ b/generated/pulse_system.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.713845500 UTC + * 2023-10-17 02:04:50.088126900 UTC */ public static class CPulseCell_Base { diff --git a/generated/pulse_system.dll.hpp b/generated/pulse_system.dll.hpp index a28fe9d..939ee5c 100644 --- a/generated/pulse_system.dll.hpp +++ b/generated/pulse_system.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:50.085477700 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.711122600 UTC - */ - namespace CPulseCell_Base { constexpr std::ptrdiff_t m_nEditorNodeID = 0x8; // PulseDocNodeID_t } diff --git a/generated/pulse_system.dll.py b/generated/pulse_system.dll.py new file mode 100644 index 0000000..3c88edf --- /dev/null +++ b/generated/pulse_system.dll.py @@ -0,0 +1,233 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:50.091275300 UTC +''' + +class CPulseCell_Base: + m_nEditorNodeID = 0x8 # PulseDocNodeID_t + +class CPulseCell_Inflow_BaseEntrypoint: + m_EntryChunk = 0x48 # PulseRuntimeChunkIndex_t + m_RegisterMap = 0x50 # PulseRegisterMap_t + +class CPulseCell_Inflow_EntOutputHandler: + m_SourceEntity = 0x70 # CUtlSymbolLarge + m_SourceOutput = 0x78 # CUtlSymbolLarge + m_TargetInput = 0x80 # CUtlSymbolLarge + m_ExpectedParamType = 0x88 # CPulseValueFullType + +class CPulseCell_Inflow_EventHandler: + m_EventName = 0x70 # CUtlSymbolLarge + +class CPulseCell_Inflow_GraphHook: + m_HookName = 0x70 # CUtlSymbolLarge + +class CPulseCell_Inflow_Method: + m_MethodName = 0x70 # CUtlSymbolLarge + m_Description = 0x78 # CUtlString + m_bIsPublic = 0x80 # bool + m_ReturnType = 0x88 # CPulseValueFullType + m_Args = 0x98 # CUtlVector + +class CPulseCell_Inflow_Wait: + m_WakeResume = 0x48 # CPulse_ResumePoint + +class CPulseCell_Inflow_Yield: + m_UnyieldResume = 0x48 # CPulse_ResumePoint + +class CPulseCell_Outflow_CycleOrdered: + m_Outputs = 0x48 # CUtlVector + +class CPulseCell_Outflow_CycleOrdered_InstanceState_t: + m_nNextIndex = 0x0 # int32_t + +class CPulseCell_Outflow_CycleRandom: + m_Outputs = 0x48 # CUtlVector + +class CPulseCell_Outflow_CycleShuffled: + m_Outputs = 0x48 # CUtlVector + +class CPulseCell_Outflow_CycleShuffled_InstanceState_t: + m_Shuffle = 0x0 # CUtlVectorFixedGrowable + m_nNextShuffle = 0x20 # int32_t + +class CPulseCell_Outflow_IntSwitch: + m_DefaultCaseOutflow = 0x48 # CPulse_OutflowConnection + m_CaseOutflows = 0x58 # CUtlVector + +class CPulseCell_Outflow_SimultaneousParallel: + m_Outputs = 0x48 # CUtlVector + +class CPulseCell_Outflow_StringSwitch: + m_DefaultCaseOutflow = 0x48 # CPulse_OutflowConnection + m_CaseOutflows = 0x58 # CUtlVector + +class CPulseCell_Outflow_TestExplicitYesNo: + m_Yes = 0x48 # CPulse_OutflowConnection + m_No = 0x58 # CPulse_OutflowConnection + +class CPulseCell_Outflow_TestRandomYesNo: + m_Yes = 0x48 # CPulse_OutflowConnection + m_No = 0x58 # CPulse_OutflowConnection + +class CPulseCell_Step_CallExternalMethod: + m_MethodName = 0x48 # CUtlSymbolLarge + m_ExpectedArgs = 0x50 # CUtlVector + +class CPulseCell_Step_PublicOutput: + m_OutputIndex = 0x48 # PulseRuntimeOutputIndex_t + +class CPulseCell_Step_TestDomainEntFire: + m_Input = 0x48 # CUtlString + +class CPulseGraphDef: + m_DomainIdentifier = 0x8 # CUtlSymbolLarge + m_ParentMapName = 0x10 # CUtlSymbolLarge + m_Chunks = 0x18 # CUtlVector + m_Cells = 0x30 # CUtlVector + m_Vars = 0x48 # CUtlVector + m_PublicOutputs = 0x60 # CUtlVector + m_InvokeBindings = 0x78 # CUtlVector + m_CallInfos = 0x90 # CUtlVector + m_OutputConnections = 0xA8 # CUtlVector + +class CPulseGraphInstance_TestDomain: + m_bIsRunningUnitTests = 0xD0 # bool + m_bExplicitTimeStepping = 0xD1 # bool + m_bExpectingToDestroyWithYieldedCursors = 0xD2 # bool + m_nNextValidateIndex = 0xD4 # int32_t + m_Tracepoints = 0xD8 # CUtlVector + m_bTestYesOrNoPath = 0xF0 # bool + +class CPulseGraphInstance_TestDomain_Derived: + m_nInstanceValueX = 0xF8 # int32_t + +class CPulseRuntimeMethodArg: + m_Name = 0x0 # CKV3MemberNameWithStorage + m_Description = 0x38 # CUtlString + m_Type = 0x40 # CPulseValueFullType + +class CPulseTurtleGraphicsCursor: + m_Color = 0x188 # Color + m_vPos = 0x18C # Vector2D + m_flHeadingDeg = 0x194 # float + m_bPenUp = 0x198 # bool + +class CPulse_CallInfo: + m_PortName = 0x0 # CUtlSymbolLarge + m_nEditorNodeID = 0x8 # PulseDocNodeID_t + m_RegisterMap = 0x10 # PulseRegisterMap_t + m_CallMethodID = 0x30 # PulseDocNodeID_t + m_nSrcChunk = 0x34 # PulseRuntimeChunkIndex_t + m_nSrcInstruction = 0x38 # int32_t + +class CPulse_Chunk: + m_Instructions = 0x0 # CUtlLeanVector + m_Registers = 0x10 # CUtlLeanVector + m_InstructionEditorIDs = 0x20 # CUtlLeanVector + +class CPulse_InvokeBinding: + m_RegisterMap = 0x0 # PulseRegisterMap_t + m_FuncName = 0x20 # CUtlSymbolLarge + m_nCellIndex = 0x28 # PulseRuntimeCellIndex_t + m_InstanceType = 0x30 # CPulseValueFullType + m_nSrcChunk = 0x40 # PulseRuntimeChunkIndex_t + m_nSrcInstruction = 0x44 # int32_t + +class CPulse_OutflowConnection: + m_SourceOutflowName = 0x0 # CUtlSymbolLarge + m_nDestChunk = 0x8 # PulseRuntimeChunkIndex_t + m_nInstruction = 0xC # int32_t + +class CPulse_OutputConnection: + m_SourceOutput = 0x0 # CUtlSymbolLarge + m_TargetEntity = 0x8 # CUtlSymbolLarge + m_TargetInput = 0x10 # CUtlSymbolLarge + m_Param = 0x18 # CUtlSymbolLarge + +class CPulse_PublicOutput: + m_Name = 0x0 # CUtlSymbolLarge + m_Description = 0x8 # CUtlString + m_ParamType = 0x10 # CPulseValueFullType + +class CPulse_RegisterInfo: + m_nReg = 0x0 # PulseRuntimeRegisterIndex_t + m_Type = 0x8 # CPulseValueFullType + m_OriginName = 0x18 # CKV3MemberNameWithStorage + m_nWrittenByInstruction = 0x50 # int32_t + m_nLastReadByInstruction = 0x54 # int32_t + +class CPulse_Variable: + m_Name = 0x0 # CUtlSymbolLarge + m_Description = 0x8 # CUtlString + m_Type = 0x10 # CPulseValueFullType + m_DefaultValue = 0x20 # KeyValues3 + m_bIsPublic = 0x32 # bool + +class CTestDomainDerived_Cursor: + m_nCursorValueA = 0x188 # int32_t + m_nCursorValueB = 0x18C # int32_t + +class FakeEntity_t: + m_nHandle = 0x0 # PulseTestEHandle_t + m_Name = 0x8 # CUtlString + m_Class = 0x10 # CUtlString + m_bDestroyed = 0x18 # bool + m_pAssociatedGraphInstance = 0x20 # CPulseGraphInstance_TestDomain* + m_bFuncWasCalled = 0x28 # bool + m_fValue = 0x2C # float + +class PGDInstruction_t: + m_nCode = 0x0 # PulseInstructionCode_t + m_nVar = 0x4 # PulseRuntimeVarIndex_t + m_nReg0 = 0x8 # PulseRuntimeRegisterIndex_t + m_nReg1 = 0xA # PulseRuntimeRegisterIndex_t + m_nReg2 = 0xC # PulseRuntimeRegisterIndex_t + m_nInvokeBindingIndex = 0x10 # PulseRuntimeInvokeIndex_t + m_nChunk = 0x14 # PulseRuntimeChunkIndex_t + m_nDestInstruction = 0x18 # int32_t + m_nCallInfoIndex = 0x1C # PulseRuntimeCallInfoIndex_t + m_Arg0Name = 0x20 # CUtlSymbolLarge + m_Arg1Name = 0x28 # CUtlSymbolLarge + m_bLiteralBool = 0x30 # bool + m_nLiteralInt = 0x34 # int32_t + m_flLiteralFloat = 0x38 # float + m_LiteralString = 0x40 # CBufferString + m_vLiteralVec3 = 0x50 # Vector + +class PulseDocNodeID_t: + m_Value = 0x0 # int32_t + +class PulseRegisterMap_t: + m_Inparams = 0x0 # KeyValues3 + m_Outparams = 0x10 # KeyValues3 + +class PulseRuntimeCallInfoIndex_t: + m_Value = 0x0 # int32_t + +class PulseRuntimeCellIndex_t: + m_Value = 0x0 # int32_t + +class PulseRuntimeChunkIndex_t: + m_Value = 0x0 # int32_t + +class PulseRuntimeEntrypointIndex_t: + m_Value = 0x0 # int32_t + +class PulseRuntimeInvokeIndex_t: + m_Value = 0x0 # int32_t + +class PulseRuntimeOutputIndex_t: + m_Value = 0x0 # int32_t + +class PulseRuntimeRegisterIndex_t: + m_Value = 0x0 # int16_t + +class PulseRuntimeStateOffset_t: + m_Value = 0x0 # uint16_t + +class PulseRuntimeVarIndex_t: + m_Value = 0x0 # int32_t + +class PulseTestEHandle_t: + m_Value = 0x0 # int32_t diff --git a/generated/pulse_system.dll.rs b/generated/pulse_system.dll.rs index b0048a4..5df7b7d 100644 --- a/generated/pulse_system.dll.rs +++ b/generated/pulse_system.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.716897500 UTC + * 2023-10-17 02:04:50.094207700 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod CPulseCell_Base { pub const m_nEditorNodeID: usize = 0x8; // PulseDocNodeID_t } diff --git a/generated/rendersystemdx11.dll.cs b/generated/rendersystemdx11.dll.cs index 672cd17..ac8cd28 100644 --- a/generated/rendersystemdx11.dll.cs +++ b/generated/rendersystemdx11.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.362776200 UTC + * 2023-10-17 02:04:49.682169100 UTC */ public static class RenderInputLayoutField_t { diff --git a/generated/rendersystemdx11.dll.hpp b/generated/rendersystemdx11.dll.hpp index 3835eb1..98caeae 100644 --- a/generated/rendersystemdx11.dll.hpp +++ b/generated/rendersystemdx11.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:49.681400300 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.361960700 UTC - */ - namespace RenderInputLayoutField_t { constexpr std::ptrdiff_t m_pSemanticName = 0x0; // uint8_t[32] constexpr std::ptrdiff_t m_nSemanticIndex = 0x20; // int32_t diff --git a/generated/rendersystemdx11.dll.py b/generated/rendersystemdx11.dll.py new file mode 100644 index 0000000..da7fc63 --- /dev/null +++ b/generated/rendersystemdx11.dll.py @@ -0,0 +1,22 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:49.683189900 UTC +''' + +class RenderInputLayoutField_t: + m_pSemanticName = 0x0 # uint8_t[32] + m_nSemanticIndex = 0x20 # int32_t + m_Format = 0x24 # uint32_t + m_nOffset = 0x28 # int32_t + m_nSlot = 0x2C # int32_t + m_nSlotType = 0x30 # RenderSlotType_t + m_nInstanceStepRate = 0x34 # int32_t + +class VsInputSignatureElement_t: + m_pName = 0x0 # char[64] + m_pSemantic = 0x40 # char[64] + m_pD3DSemanticName = 0x80 # char[64] + m_nD3DSemanticIndex = 0xC0 # int32_t + +class VsInputSignature_t: + m_elems = 0x0 # CUtlVector diff --git a/generated/rendersystemdx11.dll.rs b/generated/rendersystemdx11.dll.rs index 52525ab..9ab7287 100644 --- a/generated/rendersystemdx11.dll.rs +++ b/generated/rendersystemdx11.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.363913900 UTC + * 2023-10-17 02:04:49.684161100 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod RenderInputLayoutField_t { pub const m_pSemanticName: usize = 0x0; // uint8_t[32] pub const m_nSemanticIndex: usize = 0x20; // int32_t diff --git a/generated/resourcesystem.dll.cs b/generated/resourcesystem.dll.cs index 4721ae1..a38fa97 100644 --- a/generated/resourcesystem.dll.cs +++ b/generated/resourcesystem.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.358179600 UTC + * 2023-10-17 02:04:49.676506900 UTC */ public static class AABB_t { diff --git a/generated/resourcesystem.dll.hpp b/generated/resourcesystem.dll.hpp index 2dfce76..7a4e766 100644 --- a/generated/resourcesystem.dll.hpp +++ b/generated/resourcesystem.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:49.675361400 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.356904800 UTC - */ - namespace AABB_t { constexpr std::ptrdiff_t m_vMinBounds = 0x0; // Vector constexpr std::ptrdiff_t m_vMaxBounds = 0xC; // Vector diff --git a/generated/resourcesystem.dll.py b/generated/resourcesystem.dll.py new file mode 100644 index 0000000..196dba0 --- /dev/null +++ b/generated/resourcesystem.dll.py @@ -0,0 +1,65 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:49.677881900 UTC +''' + +class AABB_t: + m_vMinBounds = 0x0 # Vector + m_vMaxBounds = 0xC # Vector + +class CFuseProgram: + m_programBuffer = 0x0 # CUtlVector + m_variablesRead = 0x18 # CUtlVector + m_variablesWritten = 0x30 # CUtlVector + m_nMaxTempVarsUsed = 0x48 # int32_t + +class CFuseSymbolTable: + m_constants = 0x0 # CUtlVector + m_variables = 0x18 # CUtlVector + m_functions = 0x30 # CUtlVector + m_constantMap = 0x48 # CUtlHashtable + m_variableMap = 0x68 # CUtlHashtable + m_functionMap = 0x88 # CUtlHashtable + +class ConstantInfo_t: + m_name = 0x0 # CUtlString + m_nameToken = 0x8 # CUtlStringToken + m_flValue = 0xC # float + +class FourQuaternions: + x = 0x0 # fltx4 + y = 0x10 # fltx4 + z = 0x20 # fltx4 + w = 0x30 # fltx4 + +class FunctionInfo_t: + m_name = 0x8 # CUtlString + m_nameToken = 0x10 # CUtlStringToken + m_nParamCount = 0x14 # int32_t + m_nIndex = 0x18 # FuseFunctionIndex_t + m_bIsPure = 0x1A # bool + +class FuseFunctionIndex_t: + m_Value = 0x0 # uint16_t + +class FuseVariableIndex_t: + m_Value = 0x0 # uint16_t + +class ManifestTestResource_t: + m_name = 0x0 # CUtlString + m_child = 0x8 # CStrongHandle + +class PackedAABB_t: + m_nPackedMin = 0x0 # uint32_t + m_nPackedMax = 0x4 # uint32_t + +class TestResource_t: + m_name = 0x0 # CUtlString + +class VariableInfo_t: + m_name = 0x0 # CUtlString + m_nameToken = 0x8 # CUtlStringToken + m_nIndex = 0xC # FuseVariableIndex_t + m_nNumComponents = 0xE # uint8_t + m_eVarType = 0xF # FuseVariableType_t + m_eAccess = 0x10 # FuseVariableAccess_t diff --git a/generated/resourcesystem.dll.rs b/generated/resourcesystem.dll.rs index 225e508..70ad48f 100644 --- a/generated/resourcesystem.dll.rs +++ b/generated/resourcesystem.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.359706 UTC + * 2023-10-17 02:04:49.679145400 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod AABB_t { pub const m_vMinBounds: usize = 0x0; // Vector pub const m_vMaxBounds: usize = 0xC; // Vector diff --git a/generated/scenesystem.dll.cs b/generated/scenesystem.dll.cs index 381703b..49ea7fc 100644 --- a/generated/scenesystem.dll.cs +++ b/generated/scenesystem.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.675288600 UTC + * 2023-10-17 02:04:50.044809800 UTC */ public static class CSSDSEndFrameViewInfo { diff --git a/generated/scenesystem.dll.hpp b/generated/scenesystem.dll.hpp index 61a67bd..138e841 100644 --- a/generated/scenesystem.dll.hpp +++ b/generated/scenesystem.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:50.043752900 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.674184500 UTC - */ - namespace CSSDSEndFrameViewInfo { constexpr std::ptrdiff_t m_nViewId = 0x0; // uint64_t constexpr std::ptrdiff_t m_ViewName = 0x8; // CUtlString diff --git a/generated/scenesystem.dll.py b/generated/scenesystem.dll.py new file mode 100644 index 0000000..d80aa90 --- /dev/null +++ b/generated/scenesystem.dll.py @@ -0,0 +1,44 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:50.046158400 UTC +''' + +class CSSDSEndFrameViewInfo: + m_nViewId = 0x0 # uint64_t + m_ViewName = 0x8 # CUtlString + +class CSSDSMsg_EndFrame: + m_Views = 0x0 # CUtlVector + +class CSSDSMsg_LayerBase: + m_viewId = 0x0 # SceneViewId_t + m_ViewName = 0x10 # CUtlString + m_nLayerIndex = 0x18 # int32_t + m_nLayerId = 0x20 # uint64_t + m_LayerName = 0x28 # CUtlString + m_displayText = 0x30 # CUtlString + +class CSSDSMsg_ViewRender: + m_viewId = 0x0 # SceneViewId_t + m_ViewName = 0x10 # CUtlString + +class CSSDSMsg_ViewTarget: + m_Name = 0x0 # CUtlString + m_TextureId = 0x8 # uint64_t + m_nWidth = 0x10 # int32_t + m_nHeight = 0x14 # int32_t + m_nRequestedWidth = 0x18 # int32_t + m_nRequestedHeight = 0x1C # int32_t + m_nNumMipLevels = 0x20 # int32_t + m_nDepth = 0x24 # int32_t + m_nMultisampleNumSamples = 0x28 # int32_t + m_nFormat = 0x2C # int32_t + +class CSSDSMsg_ViewTargetList: + m_viewId = 0x0 # SceneViewId_t + m_ViewName = 0x10 # CUtlString + m_Targets = 0x18 # CUtlVector + +class SceneViewId_t: + m_nViewId = 0x0 # uint64_t + m_nFrameCount = 0x8 # uint64_t diff --git a/generated/scenesystem.dll.rs b/generated/scenesystem.dll.rs index aa1cf84..408a43c 100644 --- a/generated/scenesystem.dll.rs +++ b/generated/scenesystem.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.676655900 UTC + * 2023-10-17 02:04:50.047339600 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod CSSDSEndFrameViewInfo { pub const m_nViewId: usize = 0x0; // uint64_t pub const m_ViewName: usize = 0x8; // CUtlString diff --git a/generated/schemasystem.dll.cs b/generated/schemasystem.dll.cs index 88aee68..223d0c5 100644 --- a/generated/schemasystem.dll.cs +++ b/generated/schemasystem.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.348418900 UTC + * 2023-10-17 02:04:49.665634700 UTC */ public static class CExampleSchemaVData_Monomorphic { diff --git a/generated/schemasystem.dll.hpp b/generated/schemasystem.dll.hpp index a2da526..091f580 100644 --- a/generated/schemasystem.dll.hpp +++ b/generated/schemasystem.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:49.664660100 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.347354400 UTC - */ - namespace CExampleSchemaVData_Monomorphic { constexpr std::ptrdiff_t m_nExample1 = 0x0; // int32_t constexpr std::ptrdiff_t m_nExample2 = 0x4; // int32_t diff --git a/generated/schemasystem.dll.py b/generated/schemasystem.dll.py new file mode 100644 index 0000000..3ecd960 --- /dev/null +++ b/generated/schemasystem.dll.py @@ -0,0 +1,44 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:49.666916200 UTC +''' + +class CExampleSchemaVData_Monomorphic: + m_nExample1 = 0x0 # int32_t + m_nExample2 = 0x4 # int32_t + +class CExampleSchemaVData_PolymorphicBase: + m_nBase = 0x8 # int32_t + +class CExampleSchemaVData_PolymorphicDerivedA: + m_nDerivedA = 0x10 # int32_t + +class CExampleSchemaVData_PolymorphicDerivedB: + m_nDerivedB = 0x10 # int32_t + +class CSchemaSystemInternalRegistration: + m_Vector2D = 0x0 # Vector2D + m_Vector = 0x8 # Vector + m_VectorAligned = 0x20 # VectorAligned + m_Quaternion = 0x30 # Quaternion + m_QAngle = 0x40 # QAngle + m_RotationVector = 0x4C # RotationVector + m_RadianEuler = 0x58 # RadianEuler + m_DegreeEuler = 0x64 # DegreeEuler + m_QuaternionStorage = 0x70 # QuaternionStorage + m_matrix3x4_t = 0x80 # matrix3x4_t + m_matrix3x4a_t = 0xB0 # matrix3x4a_t + m_Color = 0xE0 # Color + m_Vector4D = 0xE4 # Vector4D + m_CTransform = 0x100 # CTransform + m_pKeyValues = 0x120 # KeyValues* + m_CUtlBinaryBlock = 0x128 # CUtlBinaryBlock + m_CUtlString = 0x140 # CUtlString + m_CUtlSymbol = 0x148 # CUtlSymbol + m_stringToken = 0x14C # CUtlStringToken + m_stringTokenWithStorage = 0x150 # CUtlStringTokenWithStorage + m_ResourceTypes = 0x168 # CResourceArray> + m_KV3 = 0x170 # KeyValues3 + +class ResourceId_t: + m_Value = 0x0 # uint64_t diff --git a/generated/schemasystem.dll.rs b/generated/schemasystem.dll.rs index 2509484..f753ef8 100644 --- a/generated/schemasystem.dll.rs +++ b/generated/schemasystem.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.349825800 UTC + * 2023-10-17 02:04:49.668056600 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod CExampleSchemaVData_Monomorphic { pub const m_nExample1: usize = 0x0; // int32_t pub const m_nExample2: usize = 0x4; // int32_t diff --git a/generated/server.dll.cs b/generated/server.dll.cs index a9f94e9..c28e4df 100644 --- a/generated/server.dll.cs +++ b/generated/server.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:32.484000900 UTC + * 2023-10-17 02:04:50.910543800 UTC */ public static class ActiveModelConfig_t { diff --git a/generated/server.dll.hpp b/generated/server.dll.hpp index 75482b0..a684cab 100644 --- a/generated/server.dll.hpp +++ b/generated/server.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:50.840707300 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:32.413845700 UTC - */ - namespace ActiveModelConfig_t { constexpr std::ptrdiff_t m_Handle = 0x28; // ModelConfigHandle_t constexpr std::ptrdiff_t m_Name = 0x30; // CUtlSymbolLarge diff --git a/generated/server.dll.py b/generated/server.dll.py new file mode 100644 index 0000000..6025464 --- /dev/null +++ b/generated/server.dll.py @@ -0,0 +1,5979 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:50.982256700 UTC +''' + +class ActiveModelConfig_t: + m_Handle = 0x28 # ModelConfigHandle_t + m_Name = 0x30 # CUtlSymbolLarge + m_AssociatedEntities = 0x38 # CNetworkUtlVectorBase> + m_AssociatedEntityNames = 0x50 # CNetworkUtlVectorBase + +class AmmoIndex_t: + m_Value = 0x0 # int8_t + +class AmmoTypeInfo_t: + m_nMaxCarry = 0x10 # int32_t + m_nSplashSize = 0x1C # CRangeInt + m_nFlags = 0x24 # AmmoFlags_t + m_flMass = 0x28 # float + m_flSpeed = 0x2C # CRangeFloat + +class AnimationUpdateListHandle_t: + m_Value = 0x0 # uint32_t + +class CAISound: + m_iSoundType = 0x4B0 # int32_t + m_iSoundContext = 0x4B4 # int32_t + m_iVolume = 0x4B8 # int32_t + m_iSoundIndex = 0x4BC # int32_t + m_flDuration = 0x4C0 # float + m_iszProxyEntityName = 0x4C8 # CUtlSymbolLarge + +class CAI_ChangeHintGroup: + m_iSearchType = 0x4B0 # int32_t + m_strSearchName = 0x4B8 # CUtlSymbolLarge + m_strNewHintGroup = 0x4C0 # CUtlSymbolLarge + m_flRadius = 0x4C8 # float + +class CAI_ChangeTarget: + m_iszNewTarget = 0x4B0 # CUtlSymbolLarge + +class CAI_Expresser: + m_flStopTalkTime = 0x38 # GameTime_t + m_flStopTalkTimeWithoutDelay = 0x3C # GameTime_t + m_flBlockedTalkTime = 0x40 # GameTime_t + m_voicePitch = 0x44 # int32_t + m_flLastTimeAcceptedSpeak = 0x48 # GameTime_t + m_bAllowSpeakingInterrupts = 0x4C # bool + m_bConsiderSceneInvolvementAsSpeech = 0x4D # bool + m_nLastSpokenPriority = 0x50 # int32_t + m_pOuter = 0x58 # CBaseFlex* + +class CAI_ExpresserWithFollowup: + m_pPostponedFollowup = 0x60 # ResponseFollowup* + +class CAmbientGeneric: + m_radius = 0x4B0 # float + m_flMaxRadius = 0x4B4 # float + m_iSoundLevel = 0x4B8 # soundlevel_t + m_dpv = 0x4BC # dynpitchvol_t + m_fActive = 0x520 # bool + m_fLooping = 0x521 # bool + m_iszSound = 0x528 # CUtlSymbolLarge + m_sSourceEntName = 0x530 # CUtlSymbolLarge + m_hSoundSource = 0x538 # CHandle + m_nSoundSourceEntIndex = 0x53C # CEntityIndex + +class CAnimGraphNetworkedVariables: + m_PredNetBoolVariables = 0x8 # CNetworkUtlVectorBase + m_PredNetByteVariables = 0x20 # CNetworkUtlVectorBase + m_PredNetUInt16Variables = 0x38 # CNetworkUtlVectorBase + m_PredNetIntVariables = 0x50 # CNetworkUtlVectorBase + m_PredNetUInt32Variables = 0x68 # CNetworkUtlVectorBase + m_PredNetUInt64Variables = 0x80 # CNetworkUtlVectorBase + m_PredNetFloatVariables = 0x98 # CNetworkUtlVectorBase + m_PredNetVectorVariables = 0xB0 # CNetworkUtlVectorBase + m_PredNetQuaternionVariables = 0xC8 # CNetworkUtlVectorBase + m_OwnerOnlyPredNetBoolVariables = 0xE0 # CNetworkUtlVectorBase + m_OwnerOnlyPredNetByteVariables = 0xF8 # CNetworkUtlVectorBase + m_OwnerOnlyPredNetUInt16Variables = 0x110 # CNetworkUtlVectorBase + m_OwnerOnlyPredNetIntVariables = 0x128 # CNetworkUtlVectorBase + m_OwnerOnlyPredNetUInt32Variables = 0x140 # CNetworkUtlVectorBase + m_OwnerOnlyPredNetUInt64Variables = 0x158 # CNetworkUtlVectorBase + m_OwnerOnlyPredNetFloatVariables = 0x170 # CNetworkUtlVectorBase + m_OwnerOnlyPredNetVectorVariables = 0x188 # CNetworkUtlVectorBase + m_OwnerOnlyPredNetQuaternionVariables = 0x1A0 # CNetworkUtlVectorBase + m_nBoolVariablesCount = 0x1B8 # int32_t + m_nOwnerOnlyBoolVariablesCount = 0x1BC # int32_t + m_nRandomSeedOffset = 0x1C0 # int32_t + m_flLastTeleportTime = 0x1C4 # float + +class CAnimGraphTagRef: + m_nTagIndex = 0x0 # int32_t + m_tagName = 0x10 # CGlobalSymbol + +class CAttributeContainer: + m_Item = 0x50 # CEconItemView + +class CAttributeList: + m_Attributes = 0x8 # CUtlVectorEmbeddedNetworkVar + m_pManager = 0x58 # CAttributeManager* + +class CAttributeManager: + m_Providers = 0x8 # CUtlVector> + m_iReapplyProvisionParity = 0x20 # int32_t + m_hOuter = 0x24 # CHandle + m_bPreventLoopback = 0x28 # bool + m_ProviderType = 0x2C # attributeprovidertypes_t + m_CachedResults = 0x30 # CUtlVector + +class CAttributeManager_cached_attribute_float_t: + flIn = 0x0 # float + iAttribHook = 0x8 # CUtlSymbolLarge + flOut = 0x10 # float + +class CBarnLight: + m_bEnabled = 0x700 # bool + m_nColorMode = 0x704 # int32_t + m_Color = 0x708 # Color + m_flColorTemperature = 0x70C # float + m_flBrightness = 0x710 # float + m_flBrightnessScale = 0x714 # float + m_nDirectLight = 0x718 # int32_t + m_nBakedShadowIndex = 0x71C # int32_t + m_nLuminaireShape = 0x720 # int32_t + m_flLuminaireSize = 0x724 # float + m_flLuminaireAnisotropy = 0x728 # float + m_LightStyleString = 0x730 # CUtlString + m_flLightStyleStartTime = 0x738 # GameTime_t + m_QueuedLightStyleStrings = 0x740 # CNetworkUtlVectorBase + m_LightStyleEvents = 0x758 # CNetworkUtlVectorBase + m_LightStyleTargets = 0x770 # CNetworkUtlVectorBase> + m_StyleEvent = 0x788 # CEntityIOOutput[4] + m_StyleRadianceVar = 0x828 # CUtlString + m_StyleVar = 0x830 # CUtlString + m_hLightCookie = 0x858 # CStrongHandle + m_flShape = 0x860 # float + m_flSoftX = 0x864 # float + m_flSoftY = 0x868 # float + m_flSkirt = 0x86C # float + m_flSkirtNear = 0x870 # float + m_vSizeParams = 0x874 # Vector + m_flRange = 0x880 # float + m_vShear = 0x884 # Vector + m_nBakeSpecularToCubemaps = 0x890 # int32_t + m_vBakeSpecularToCubemapsSize = 0x894 # Vector + m_nCastShadows = 0x8A0 # int32_t + m_nShadowMapSize = 0x8A4 # int32_t + m_nShadowPriority = 0x8A8 # int32_t + m_bContactShadow = 0x8AC # bool + m_nBounceLight = 0x8B0 # int32_t + m_flBounceScale = 0x8B4 # float + m_flMinRoughness = 0x8B8 # float + m_vAlternateColor = 0x8BC # Vector + m_fAlternateColorBrightness = 0x8C8 # float + m_nFog = 0x8CC # int32_t + m_flFogStrength = 0x8D0 # float + m_nFogShadows = 0x8D4 # int32_t + m_flFogScale = 0x8D8 # float + m_flFadeSizeStart = 0x8DC # float + m_flFadeSizeEnd = 0x8E0 # float + m_flShadowFadeSizeStart = 0x8E4 # float + m_flShadowFadeSizeEnd = 0x8E8 # float + m_bPrecomputedFieldsValid = 0x8EC # bool + m_vPrecomputedBoundsMins = 0x8F0 # Vector + m_vPrecomputedBoundsMaxs = 0x8FC # Vector + m_vPrecomputedOBBOrigin = 0x908 # Vector + m_vPrecomputedOBBAngles = 0x914 # QAngle + m_vPrecomputedOBBExtent = 0x920 # Vector + m_bPvsModifyEntity = 0x92C # bool + +class CBaseAnimGraph: + m_bInitiallyPopulateInterpHistory = 0x700 # bool + m_bShouldAnimateDuringGameplayPause = 0x701 # bool + m_pChoreoServices = 0x708 # IChoreoServices* + m_bAnimGraphUpdateEnabled = 0x710 # bool + m_flMaxSlopeDistance = 0x714 # float + m_vLastSlopeCheckPos = 0x718 # Vector + m_bAnimGraphDirty = 0x724 # bool + m_vecForce = 0x728 # Vector + m_nForceBone = 0x734 # int32_t + m_pRagdollPose = 0x748 # PhysicsRagdollPose_t* + m_bClientRagdoll = 0x750 # bool + +class CBaseAnimGraphController: + m_baseLayer = 0x18 # CNetworkedSequenceOperation + m_animGraphNetworkedVars = 0x40 # CAnimGraphNetworkedVariables + m_bSequenceFinished = 0x218 # bool + m_flLastEventCycle = 0x21C # float + m_flLastEventAnimTime = 0x220 # float + m_flPlaybackRate = 0x224 # CNetworkedQuantizedFloat + m_flPrevAnimTime = 0x22C # float + m_bClientSideAnimation = 0x230 # bool + m_bNetworkedAnimationInputsChanged = 0x231 # bool + m_nNewSequenceParity = 0x234 # int32_t + m_nResetEventsParity = 0x238 # int32_t + m_nAnimLoopMode = 0x23C # AnimLoopMode_t + m_hAnimationUpdate = 0x2DC # AnimationUpdateListHandle_t + +class CBaseButton: + m_angMoveEntitySpace = 0x780 # QAngle + m_fStayPushed = 0x78C # bool + m_fRotating = 0x78D # bool + m_ls = 0x790 # locksound_t + m_sUseSound = 0x7B0 # CUtlSymbolLarge + m_sLockedSound = 0x7B8 # CUtlSymbolLarge + m_sUnlockedSound = 0x7C0 # CUtlSymbolLarge + m_bLocked = 0x7C8 # bool + m_bDisabled = 0x7C9 # bool + m_flUseLockedTime = 0x7CC # GameTime_t + m_bSolidBsp = 0x7D0 # bool + m_OnDamaged = 0x7D8 # CEntityIOOutput + m_OnPressed = 0x800 # CEntityIOOutput + m_OnUseLocked = 0x828 # CEntityIOOutput + m_OnIn = 0x850 # CEntityIOOutput + m_OnOut = 0x878 # CEntityIOOutput + m_nState = 0x8A0 # int32_t + m_hConstraint = 0x8A4 # CEntityHandle + m_hConstraintParent = 0x8A8 # CEntityHandle + m_bForceNpcExclude = 0x8AC # bool + m_sGlowEntity = 0x8B0 # CUtlSymbolLarge + m_glowEntity = 0x8B8 # CHandle + m_usable = 0x8BC # bool + m_szDisplayText = 0x8C0 # CUtlSymbolLarge + +class CBaseCSGrenade: + m_bRedraw = 0xDF8 # bool + m_bIsHeldByPlayer = 0xDF9 # bool + m_bPinPulled = 0xDFA # bool + m_bJumpThrow = 0xDFB # bool + m_eThrowStatus = 0xDFC # EGrenadeThrowState + m_fThrowTime = 0xE00 # GameTime_t + m_flThrowStrength = 0xE04 # float + m_flThrowStrengthApproach = 0xE08 # float + m_fDropTime = 0xE0C # GameTime_t + +class CBaseCSGrenadeProjectile: + m_vInitialVelocity = 0x9C8 # Vector + m_nBounces = 0x9D4 # int32_t + m_nExplodeEffectIndex = 0x9D8 # CStrongHandle + m_nExplodeEffectTickBegin = 0x9E0 # int32_t + m_vecExplodeEffectOrigin = 0x9E4 # Vector + m_unOGSExtraFlags = 0x9F0 # uint8_t + m_bDetonationRecorded = 0x9F1 # bool + m_flDetonateTime = 0x9F4 # GameTime_t + m_nItemIndex = 0x9F8 # uint16_t + m_vecOriginalSpawnLocation = 0x9FC # Vector + m_flLastBounceSoundTime = 0xA08 # GameTime_t + m_vecGrenadeSpin = 0xA0C # RotationVector + m_vecLastHitSurfaceNormal = 0xA18 # Vector + m_nTicksAtZeroVelocity = 0xA24 # int32_t + +class CBaseClientUIEntity: + m_bEnabled = 0x700 # bool + m_DialogXMLName = 0x708 # CUtlSymbolLarge + m_PanelClassName = 0x710 # CUtlSymbolLarge + m_PanelID = 0x718 # CUtlSymbolLarge + m_CustomOutput0 = 0x720 # CEntityIOOutput + m_CustomOutput1 = 0x748 # CEntityIOOutput + m_CustomOutput2 = 0x770 # CEntityIOOutput + m_CustomOutput3 = 0x798 # CEntityIOOutput + m_CustomOutput4 = 0x7C0 # CEntityIOOutput + m_CustomOutput5 = 0x7E8 # CEntityIOOutput + m_CustomOutput6 = 0x810 # CEntityIOOutput + m_CustomOutput7 = 0x838 # CEntityIOOutput + m_CustomOutput8 = 0x860 # CEntityIOOutput + m_CustomOutput9 = 0x888 # CEntityIOOutput + +class CBaseCombatCharacter: + m_bForceServerRagdoll = 0x920 # bool + m_hMyWearables = 0x928 # CNetworkUtlVectorBase> + m_flFieldOfView = 0x940 # float + m_impactEnergyScale = 0x944 # float + m_LastHitGroup = 0x948 # HitGroup_t + m_bApplyStressDamage = 0x94C # bool + m_bloodColor = 0x950 # int32_t + m_navMeshID = 0x9B0 # int32_t + m_iDamageCount = 0x9B4 # int32_t + m_pVecRelationships = 0x9B8 # CUtlVector* + m_strRelationships = 0x9C0 # CUtlSymbolLarge + m_eHull = 0x9C8 # Hull_t + m_nNavHullIdx = 0x9CC # uint32_t + +class CBaseDMStart: + m_Master = 0x4B0 # CUtlSymbolLarge + +class CBaseDoor: + m_angMoveEntitySpace = 0x790 # QAngle + m_vecMoveDirParentSpace = 0x79C # Vector + m_ls = 0x7A8 # locksound_t + m_bForceClosed = 0x7C8 # bool + m_bDoorGroup = 0x7C9 # bool + m_bLocked = 0x7CA # bool + m_bIgnoreDebris = 0x7CB # bool + m_eSpawnPosition = 0x7CC # FuncDoorSpawnPos_t + m_flBlockDamage = 0x7D0 # float + m_NoiseMoving = 0x7D8 # CUtlSymbolLarge + m_NoiseArrived = 0x7E0 # CUtlSymbolLarge + m_NoiseMovingClosed = 0x7E8 # CUtlSymbolLarge + m_NoiseArrivedClosed = 0x7F0 # CUtlSymbolLarge + m_ChainTarget = 0x7F8 # CUtlSymbolLarge + m_OnBlockedClosing = 0x800 # CEntityIOOutput + m_OnBlockedOpening = 0x828 # CEntityIOOutput + m_OnUnblockedClosing = 0x850 # CEntityIOOutput + m_OnUnblockedOpening = 0x878 # CEntityIOOutput + m_OnFullyClosed = 0x8A0 # CEntityIOOutput + m_OnFullyOpen = 0x8C8 # CEntityIOOutput + m_OnClose = 0x8F0 # CEntityIOOutput + m_OnOpen = 0x918 # CEntityIOOutput + m_OnLockedUse = 0x940 # CEntityIOOutput + m_bLoopMoveSound = 0x968 # bool + m_bCreateNavObstacle = 0x980 # bool + m_isChaining = 0x981 # bool + m_bIsUsable = 0x982 # bool + +class CBaseEntity: + m_CBodyComponent = 0x30 # CBodyComponent* + m_NetworkTransmitComponent = 0x38 # CNetworkTransmitComponent + m_aThinkFunctions = 0x228 # CUtlVector + m_iCurrentThinkContext = 0x240 # int32_t + m_nLastThinkTick = 0x244 # GameTick_t + m_isSteadyState = 0x250 # CBitVec<64> + m_lastNetworkChange = 0x258 # float + m_ResponseContexts = 0x268 # CUtlVector + m_iszResponseContext = 0x280 # CUtlSymbolLarge + m_iHealth = 0x2A8 # int32_t + m_iMaxHealth = 0x2AC # int32_t + m_lifeState = 0x2B0 # uint8_t + m_flDamageAccumulator = 0x2B4 # float + m_bTakesDamage = 0x2B8 # bool + m_nTakeDamageFlags = 0x2BC # TakeDamageFlags_t + m_MoveCollide = 0x2C1 # MoveCollide_t + m_MoveType = 0x2C2 # MoveType_t + m_nWaterTouch = 0x2C3 # uint8_t + m_nSlimeTouch = 0x2C4 # uint8_t + m_bRestoreInHierarchy = 0x2C5 # bool + m_target = 0x2C8 # CUtlSymbolLarge + m_flMoveDoneTime = 0x2D0 # float + m_hDamageFilter = 0x2D4 # CHandle + m_iszDamageFilterName = 0x2D8 # CUtlSymbolLarge + m_nSubclassID = 0x2E0 # CUtlStringToken + m_flAnimTime = 0x2F0 # float + m_flSimulationTime = 0x2F4 # float + m_flCreateTime = 0x2F8 # GameTime_t + m_bClientSideRagdoll = 0x2FC # bool + m_ubInterpolationFrame = 0x2FD # uint8_t + m_vPrevVPhysicsUpdatePos = 0x300 # Vector + m_iTeamNum = 0x30C # uint8_t + m_iGlobalname = 0x310 # CUtlSymbolLarge + m_iSentToClients = 0x318 # int32_t + m_flSpeed = 0x31C # float + m_sUniqueHammerID = 0x320 # CUtlString + m_spawnflags = 0x328 # uint32_t + m_nNextThinkTick = 0x32C # GameTick_t + m_nSimulationTick = 0x330 # int32_t + m_OnKilled = 0x338 # CEntityIOOutput + m_fFlags = 0x360 # uint32_t + m_vecAbsVelocity = 0x364 # Vector + m_vecVelocity = 0x370 # CNetworkVelocityVector + m_vecBaseVelocity = 0x3A0 # Vector + m_nPushEnumCount = 0x3AC # int32_t + m_pCollision = 0x3B0 # CCollisionProperty* + m_hEffectEntity = 0x3B8 # CHandle + m_hOwnerEntity = 0x3BC # CHandle + m_fEffects = 0x3C0 # uint32_t + m_hGroundEntity = 0x3C4 # CHandle + m_flFriction = 0x3C8 # float + m_flElasticity = 0x3CC # float + m_flGravityScale = 0x3D0 # float + m_flTimeScale = 0x3D4 # float + m_flWaterLevel = 0x3D8 # float + m_bSimulatedEveryTick = 0x3DC # bool + m_bAnimatedEveryTick = 0x3DD # bool + m_bDisableLowViolence = 0x3DE # bool + m_nWaterType = 0x3DF # uint8_t + m_iEFlags = 0x3E0 # int32_t + m_OnUser1 = 0x3E8 # CEntityIOOutput + m_OnUser2 = 0x410 # CEntityIOOutput + m_OnUser3 = 0x438 # CEntityIOOutput + m_OnUser4 = 0x460 # CEntityIOOutput + m_iInitialTeamNum = 0x488 # int32_t + m_flNavIgnoreUntilTime = 0x48C # GameTime_t + m_vecAngVelocity = 0x490 # QAngle + m_bNetworkQuantizeOriginAndAngles = 0x49C # bool + m_bLagCompensate = 0x49D # bool + m_flOverriddenFriction = 0x4A0 # float + m_pBlocker = 0x4A4 # CHandle + m_flLocalTime = 0x4A8 # float + m_flVPhysicsUpdateLocalTime = 0x4AC # float + +class CBaseFilter: + m_bNegated = 0x4B0 # bool + m_OnPass = 0x4B8 # CEntityIOOutput + m_OnFail = 0x4E0 # CEntityIOOutput + +class CBaseFire: + m_flScale = 0x4B0 # float + m_flStartScale = 0x4B4 # float + m_flScaleTime = 0x4B8 # float + m_nFlags = 0x4BC # uint32_t + +class CBaseFlex: + m_flexWeight = 0x890 # CNetworkUtlVectorBase + m_vLookTargetPosition = 0x8A8 # Vector + m_blinktoggle = 0x8B4 # bool + m_flAllowResponsesEndTime = 0x908 # GameTime_t + m_flLastFlexAnimationTime = 0x90C # GameTime_t + m_nNextSceneEventId = 0x910 # uint32_t + m_bUpdateLayerPriorities = 0x914 # bool + +class CBaseGrenade: + m_OnPlayerPickup = 0x928 # CEntityIOOutput + m_OnExplode = 0x950 # CEntityIOOutput + m_bHasWarnedAI = 0x978 # bool + m_bIsSmokeGrenade = 0x979 # bool + m_bIsLive = 0x97A # bool + m_DmgRadius = 0x97C # float + m_flDetonateTime = 0x980 # GameTime_t + m_flWarnAITime = 0x984 # float + m_flDamage = 0x988 # float + m_iszBounceSound = 0x990 # CUtlSymbolLarge + m_ExplosionSound = 0x998 # CUtlString + m_hThrower = 0x9A4 # CHandle + m_flNextAttack = 0x9BC # GameTime_t + m_hOriginalThrower = 0x9C0 # CHandle + +class CBaseIssue: + m_szTypeString = 0x20 # char[64] + m_szDetailsString = 0x60 # char[260] + m_iNumYesVotes = 0x164 # int32_t + m_iNumNoVotes = 0x168 # int32_t + m_iNumPotentialVotes = 0x16C # int32_t + m_pVoteController = 0x170 # CVoteController* + +class CBaseModelEntity: + m_CRenderComponent = 0x4B0 # CRenderComponent* + m_CHitboxComponent = 0x4B8 # CHitboxComponent + m_flDissolveStartTime = 0x4E0 # GameTime_t + m_OnIgnite = 0x4E8 # CEntityIOOutput + m_nRenderMode = 0x510 # RenderMode_t + m_nRenderFX = 0x511 # RenderFx_t + m_bAllowFadeInView = 0x512 # bool + m_clrRender = 0x513 # Color + m_vecRenderAttributes = 0x518 # CUtlVectorEmbeddedNetworkVar + m_LightGroup = 0x568 # CUtlStringToken + m_bRenderToCubemaps = 0x56C # bool + m_Collision = 0x570 # CCollisionProperty + m_Glow = 0x620 # CGlowProperty + m_flGlowBackfaceMult = 0x678 # float + m_fadeMinDist = 0x67C # float + m_fadeMaxDist = 0x680 # float + m_flFadeScale = 0x684 # float + m_flShadowStrength = 0x688 # float + m_nObjectCulling = 0x68C # uint8_t + m_nAddDecal = 0x690 # int32_t + m_vDecalPosition = 0x694 # Vector + m_vDecalForwardAxis = 0x6A0 # Vector + m_flDecalHealBloodRate = 0x6AC # float + m_flDecalHealHeightRate = 0x6B0 # float + m_ConfigEntitiesToPropagateMaterialDecalsTo = 0x6B8 # CNetworkUtlVectorBase> + m_vecViewOffset = 0x6D0 # CNetworkViewOffsetVector + +class CBaseMoveBehavior: + m_iPositionInterpolator = 0x510 # int32_t + m_iRotationInterpolator = 0x514 # int32_t + m_flAnimStartTime = 0x518 # float + m_flAnimEndTime = 0x51C # float + m_flAverageSpeedAcrossFrame = 0x520 # float + m_pCurrentKeyFrame = 0x528 # CPathKeyFrame* + m_pTargetKeyFrame = 0x530 # CPathKeyFrame* + m_pPreKeyFrame = 0x538 # CPathKeyFrame* + m_pPostKeyFrame = 0x540 # CPathKeyFrame* + m_flTimeIntoFrame = 0x548 # float + m_iDirection = 0x54C # int32_t + +class CBasePlatTrain: + m_NoiseMoving = 0x780 # CUtlSymbolLarge + m_NoiseArrived = 0x788 # CUtlSymbolLarge + m_volume = 0x798 # float + m_flTWidth = 0x79C # float + m_flTLength = 0x7A0 # float + +class CBasePlayerController: + m_nInButtonsWhichAreToggles = 0x4B8 # uint64_t + m_nTickBase = 0x4C0 # uint32_t + m_hPawn = 0x4F0 # CHandle + m_nSplitScreenSlot = 0x4F4 # CSplitScreenSlot + m_hSplitOwner = 0x4F8 # CHandle + m_hSplitScreenPlayers = 0x500 # CUtlVector> + m_bIsHLTV = 0x518 # bool + m_iConnected = 0x51C # PlayerConnectedState + m_iszPlayerName = 0x520 # char[128] + m_szNetworkIDString = 0x5A0 # CUtlString + m_fLerpTime = 0x5A8 # float + m_bLagCompensation = 0x5AC # bool + m_bPredict = 0x5AD # bool + m_bAutoKickDisabled = 0x5AE # bool + m_bIsLowViolence = 0x5AF # bool + m_bGamePaused = 0x5B0 # bool + m_nHighestCommandNumberReceived = 0x628 # int32_t + m_nUsecTimestampLastUserCmdReceived = 0x630 # int64_t + m_iIgnoreGlobalChat = 0x648 # ChatIgnoreType_t + m_flLastPlayerTalkTime = 0x64C # float + m_flLastEntitySteadyState = 0x650 # float + m_nAvailableEntitySteadyState = 0x654 # int32_t + m_bHasAnySteadyStateEnts = 0x658 # bool + m_steamID = 0x668 # uint64_t + m_iDesiredFOV = 0x670 # uint32_t + +class CBasePlayerPawn: + m_pWeaponServices = 0x9D0 # CPlayer_WeaponServices* + m_pItemServices = 0x9D8 # CPlayer_ItemServices* + m_pAutoaimServices = 0x9E0 # CPlayer_AutoaimServices* + m_pObserverServices = 0x9E8 # CPlayer_ObserverServices* + m_pWaterServices = 0x9F0 # CPlayer_WaterServices* + m_pUseServices = 0x9F8 # CPlayer_UseServices* + m_pFlashlightServices = 0xA00 # CPlayer_FlashlightServices* + m_pCameraServices = 0xA08 # CPlayer_CameraServices* + m_pMovementServices = 0xA10 # CPlayer_MovementServices* + m_ServerViewAngleChanges = 0xA20 # CUtlVectorEmbeddedNetworkVar + m_nHighestGeneratedServerViewAngleChangeIndex = 0xA70 # uint32_t + v_angle = 0xA74 # QAngle + v_anglePrevious = 0xA80 # QAngle + m_iHideHUD = 0xA8C # uint32_t + m_skybox3d = 0xA90 # sky3dparams_t + m_fTimeLastHurt = 0xB20 # GameTime_t + m_flDeathTime = 0xB24 # GameTime_t + m_fNextSuicideTime = 0xB28 # GameTime_t + m_fInitHUD = 0xB2C # bool + m_pExpresser = 0xB30 # CAI_Expresser* + m_hController = 0xB38 # CHandle + m_fHltvReplayDelay = 0xB40 # float + m_fHltvReplayEnd = 0xB44 # float + m_iHltvReplayEntity = 0xB48 # CEntityIndex + +class CBasePlayerVData: + m_sModelName = 0x28 # CResourceNameTyped> + m_flHeadDamageMultiplier = 0x108 # CSkillFloat + m_flChestDamageMultiplier = 0x118 # CSkillFloat + m_flStomachDamageMultiplier = 0x128 # CSkillFloat + m_flArmDamageMultiplier = 0x138 # CSkillFloat + m_flLegDamageMultiplier = 0x148 # CSkillFloat + m_flHoldBreathTime = 0x158 # float + m_flDrowningDamageInterval = 0x15C # float + m_nDrowningDamageInitial = 0x160 # int32_t + m_nDrowningDamageMax = 0x164 # int32_t + m_nWaterSpeed = 0x168 # int32_t + m_flUseRange = 0x16C # float + m_flUseAngleTolerance = 0x170 # float + m_flCrouchTime = 0x174 # float + +class CBasePlayerWeapon: + m_nNextPrimaryAttackTick = 0xC18 # GameTick_t + m_flNextPrimaryAttackTickRatio = 0xC1C # float + m_nNextSecondaryAttackTick = 0xC20 # GameTick_t + m_flNextSecondaryAttackTickRatio = 0xC24 # float + m_iClip1 = 0xC28 # int32_t + m_iClip2 = 0xC2C # int32_t + m_pReserveAmmo = 0xC30 # int32_t[2] + m_OnPlayerUse = 0xC38 # CEntityIOOutput + +class CBasePlayerWeaponVData: + m_szWorldModel = 0x28 # CResourceNameTyped> + m_bBuiltRightHanded = 0x108 # bool + m_bAllowFlipping = 0x109 # bool + m_bIsFullAuto = 0x10A # bool + m_nNumBullets = 0x10C # int32_t + m_sMuzzleAttachment = 0x110 # CUtlString + m_szMuzzleFlashParticle = 0x118 # CResourceNameTyped> + m_iFlags = 0x1F8 # ItemFlagTypes_t + m_nPrimaryAmmoType = 0x1F9 # AmmoIndex_t + m_nSecondaryAmmoType = 0x1FA # AmmoIndex_t + m_iMaxClip1 = 0x1FC # int32_t + m_iMaxClip2 = 0x200 # int32_t + m_iDefaultClip1 = 0x204 # int32_t + m_iDefaultClip2 = 0x208 # int32_t + m_iWeight = 0x20C # int32_t + m_bAutoSwitchTo = 0x210 # bool + m_bAutoSwitchFrom = 0x211 # bool + m_iRumbleEffect = 0x214 # RumbleEffect_t + m_aShootSounds = 0x218 # CUtlMap + m_iSlot = 0x238 # int32_t + m_iPosition = 0x23C # int32_t + +class CBaseProp: + m_bModelOverrodeBlockLOS = 0x890 # bool + m_iShapeType = 0x894 # int32_t + m_bConformToCollisionBounds = 0x898 # bool + m_mPreferredCatchTransform = 0x89C # matrix3x4_t + +class CBasePropDoor: + m_flAutoReturnDelay = 0xB18 # float + m_hDoorList = 0xB20 # CUtlVector> + m_nHardwareType = 0xB38 # int32_t + m_bNeedsHardware = 0xB3C # bool + m_eDoorState = 0xB40 # DoorState_t + m_bLocked = 0xB44 # bool + m_closedPosition = 0xB48 # Vector + m_closedAngles = 0xB54 # QAngle + m_hBlocker = 0xB60 # CHandle + m_bFirstBlocked = 0xB64 # bool + m_ls = 0xB68 # locksound_t + m_bForceClosed = 0xB88 # bool + m_vecLatchWorldPosition = 0xB8C # Vector + m_hActivator = 0xB98 # CHandle + m_SoundMoving = 0xBA8 # CUtlSymbolLarge + m_SoundOpen = 0xBB0 # CUtlSymbolLarge + m_SoundClose = 0xBB8 # CUtlSymbolLarge + m_SoundLock = 0xBC0 # CUtlSymbolLarge + m_SoundUnlock = 0xBC8 # CUtlSymbolLarge + m_SoundLatch = 0xBD0 # CUtlSymbolLarge + m_SoundPound = 0xBD8 # CUtlSymbolLarge + m_SoundJiggle = 0xBE0 # CUtlSymbolLarge + m_SoundLockedAnim = 0xBE8 # CUtlSymbolLarge + m_numCloseAttempts = 0xBF0 # int32_t + m_nPhysicsMaterial = 0xBF4 # CUtlStringToken + m_SlaveName = 0xBF8 # CUtlSymbolLarge + m_hMaster = 0xC00 # CHandle + m_OnBlockedClosing = 0xC08 # CEntityIOOutput + m_OnBlockedOpening = 0xC30 # CEntityIOOutput + m_OnUnblockedClosing = 0xC58 # CEntityIOOutput + m_OnUnblockedOpening = 0xC80 # CEntityIOOutput + m_OnFullyClosed = 0xCA8 # CEntityIOOutput + m_OnFullyOpen = 0xCD0 # CEntityIOOutput + m_OnClose = 0xCF8 # CEntityIOOutput + m_OnOpen = 0xD20 # CEntityIOOutput + m_OnLockedUse = 0xD48 # CEntityIOOutput + m_OnAjarOpen = 0xD70 # CEntityIOOutput + +class CBaseToggle: + m_toggle_state = 0x700 # TOGGLE_STATE + m_flMoveDistance = 0x704 # float + m_flWait = 0x708 # float + m_flLip = 0x70C # float + m_bAlwaysFireBlockedOutputs = 0x710 # bool + m_vecPosition1 = 0x714 # Vector + m_vecPosition2 = 0x720 # Vector + m_vecMoveAng = 0x72C # QAngle + m_vecAngle1 = 0x738 # QAngle + m_vecAngle2 = 0x744 # QAngle + m_flHeight = 0x750 # float + m_hActivator = 0x754 # CHandle + m_vecFinalDest = 0x758 # Vector + m_vecFinalAngle = 0x764 # QAngle + m_movementType = 0x770 # int32_t + m_sMaster = 0x778 # CUtlSymbolLarge + +class CBaseTrigger: + m_bDisabled = 0x780 # bool + m_iFilterName = 0x788 # CUtlSymbolLarge + m_hFilter = 0x790 # CHandle + m_OnStartTouch = 0x798 # CEntityIOOutput + m_OnStartTouchAll = 0x7C0 # CEntityIOOutput + m_OnEndTouch = 0x7E8 # CEntityIOOutput + m_OnEndTouchAll = 0x810 # CEntityIOOutput + m_OnTouching = 0x838 # CEntityIOOutput + m_OnNotTouching = 0x860 # CEntityIOOutput + m_hTouchingEntities = 0x888 # CUtlVector> + m_bClientSidePredicted = 0x8A0 # bool + +class CBaseViewModel: + m_vecLastFacing = 0x898 # Vector + m_nViewModelIndex = 0x8A4 # uint32_t + m_nAnimationParity = 0x8A8 # uint32_t + m_flAnimationStartTime = 0x8AC # float + m_hWeapon = 0x8B0 # CHandle + m_sVMName = 0x8B8 # CUtlSymbolLarge + m_sAnimationPrefix = 0x8C0 # CUtlSymbolLarge + m_hOldLayerSequence = 0x8C8 # HSequence + m_oldLayer = 0x8CC # int32_t + m_oldLayerStartTime = 0x8D0 # float + m_hControlPanel = 0x8D4 # CHandle + +class CBeam: + m_flFrameRate = 0x700 # float + m_flHDRColorScale = 0x704 # float + m_flFireTime = 0x708 # GameTime_t + m_flDamage = 0x70C # float + m_nNumBeamEnts = 0x710 # uint8_t + m_hBaseMaterial = 0x718 # CStrongHandle + m_nHaloIndex = 0x720 # CStrongHandle + m_nBeamType = 0x728 # BeamType_t + m_nBeamFlags = 0x72C # uint32_t + m_hAttachEntity = 0x730 # CHandle[10] + m_nAttachIndex = 0x758 # AttachmentHandle_t[10] + m_fWidth = 0x764 # float + m_fEndWidth = 0x768 # float + m_fFadeLength = 0x76C # float + m_fHaloScale = 0x770 # float + m_fAmplitude = 0x774 # float + m_fStartFrame = 0x778 # float + m_fSpeed = 0x77C # float + m_flFrame = 0x780 # float + m_nClipStyle = 0x784 # BeamClipStyle_t + m_bTurnedOff = 0x788 # bool + m_vecEndPos = 0x78C # Vector + m_hEndEntity = 0x798 # CHandle + m_nDissolveType = 0x79C # int32_t + +class CBlood: + m_vecSprayAngles = 0x4B0 # QAngle + m_vecSprayDir = 0x4BC # Vector + m_flAmount = 0x4C8 # float + m_Color = 0x4CC # int32_t + +class CBodyComponent: + m_pSceneNode = 0x8 # CGameSceneNode* + __m_pChainEntity = 0x20 # CNetworkVarChainer + +class CBodyComponentBaseAnimGraph: + m_animationController = 0x470 # CBaseAnimGraphController + __m_pChainEntity = 0x750 # CNetworkVarChainer + +class CBodyComponentBaseModelEntity: + __m_pChainEntity = 0x470 # CNetworkVarChainer + +class CBodyComponentPoint: + m_sceneNode = 0x50 # CGameSceneNode + __m_pChainEntity = 0x1A0 # CNetworkVarChainer + +class CBodyComponentSkeletonInstance: + m_skeletonInstance = 0x50 # CSkeletonInstance + __m_pChainEntity = 0x440 # CNetworkVarChainer + +class CBombTarget: + m_OnBombExplode = 0x8A8 # CEntityIOOutput + m_OnBombPlanted = 0x8D0 # CEntityIOOutput + m_OnBombDefused = 0x8F8 # CEntityIOOutput + m_bIsBombSiteB = 0x920 # bool + m_bIsHeistBombTarget = 0x921 # bool + m_bBombPlantedHere = 0x922 # bool + m_szMountTarget = 0x928 # CUtlSymbolLarge + m_hInstructorHint = 0x930 # CHandle + m_nBombSiteDesignation = 0x934 # int32_t + +class CBot: + m_pController = 0x10 # CCSPlayerController* + m_pPlayer = 0x18 # CCSPlayerPawn* + m_bHasSpawned = 0x20 # bool + m_id = 0x24 # uint32_t + m_isRunning = 0x98 # bool + m_isCrouching = 0x99 # bool + m_forwardSpeed = 0x9C # float + m_leftSpeed = 0xA0 # float + m_verticalSpeed = 0xA4 # float + m_buttonFlags = 0xA8 # uint64_t + m_jumpTimestamp = 0xB0 # float + m_viewForward = 0xB4 # Vector + m_postureStackIndex = 0xD0 # int32_t + +class CBreakable: + m_Material = 0x710 # Materials + m_hBreaker = 0x714 # CHandle + m_Explosion = 0x718 # Explosions + m_iszSpawnObject = 0x720 # CUtlSymbolLarge + m_flPressureDelay = 0x728 # float + m_iMinHealthDmg = 0x72C # int32_t + m_iszPropData = 0x730 # CUtlSymbolLarge + m_impactEnergyScale = 0x738 # float + m_nOverrideBlockLOS = 0x73C # EOverrideBlockLOS_t + m_OnBreak = 0x740 # CEntityIOOutput + m_OnHealthChanged = 0x768 # CEntityOutputTemplate + m_flDmgModBullet = 0x790 # float + m_flDmgModClub = 0x794 # float + m_flDmgModExplosive = 0x798 # float + m_flDmgModFire = 0x79C # float + m_iszPhysicsDamageTableName = 0x7A0 # CUtlSymbolLarge + m_iszBasePropData = 0x7A8 # CUtlSymbolLarge + m_iInteractions = 0x7B0 # int32_t + m_PerformanceMode = 0x7B4 # PerformanceMode_t + m_hPhysicsAttacker = 0x7B8 # CHandle + m_flLastPhysicsInfluenceTime = 0x7BC # GameTime_t + +class CBreakableProp: + m_OnBreak = 0x8E0 # CEntityIOOutput + m_OnHealthChanged = 0x908 # CEntityOutputTemplate + m_OnTakeDamage = 0x930 # CEntityIOOutput + m_impactEnergyScale = 0x958 # float + m_iMinHealthDmg = 0x95C # int32_t + m_preferredCarryAngles = 0x960 # QAngle + m_flPressureDelay = 0x96C # float + m_hBreaker = 0x970 # CHandle + m_PerformanceMode = 0x974 # PerformanceMode_t + m_flDmgModBullet = 0x978 # float + m_flDmgModClub = 0x97C # float + m_flDmgModExplosive = 0x980 # float + m_flDmgModFire = 0x984 # float + m_iszPhysicsDamageTableName = 0x988 # CUtlSymbolLarge + m_iszBasePropData = 0x990 # CUtlSymbolLarge + m_iInteractions = 0x998 # int32_t + m_flPreventDamageBeforeTime = 0x99C # GameTime_t + m_bHasBreakPiecesOrCommands = 0x9A0 # bool + m_explodeDamage = 0x9A4 # float + m_explodeRadius = 0x9A8 # float + m_explosionDelay = 0x9B0 # float + m_explosionBuildupSound = 0x9B8 # CUtlSymbolLarge + m_explosionCustomEffect = 0x9C0 # CUtlSymbolLarge + m_explosionCustomSound = 0x9C8 # CUtlSymbolLarge + m_explosionModifier = 0x9D0 # CUtlSymbolLarge + m_hPhysicsAttacker = 0x9D8 # CHandle + m_flLastPhysicsInfluenceTime = 0x9DC # GameTime_t + m_bOriginalBlockLOS = 0x9E0 # bool + m_flDefaultFadeScale = 0x9E4 # float + m_hLastAttacker = 0x9E8 # CHandle + m_hFlareEnt = 0x9EC # CHandle + m_bUsePuntSound = 0x9F0 # bool + m_iszPuntSound = 0x9F8 # CUtlSymbolLarge + m_noGhostCollision = 0xA00 # bool + +class CBreakableStageHelper: + m_nCurrentStage = 0x8 # int32_t + m_nStageCount = 0xC # int32_t + +class CBtActionAim: + m_szSensorInputKey = 0x68 # CUtlString + m_szAimReadyKey = 0x80 # CUtlString + m_flZoomCooldownTimestamp = 0x88 # float + m_bDoneAiming = 0x8C # bool + m_flLerpStartTime = 0x90 # float + m_flNextLookTargetLerpTime = 0x94 # float + m_flPenaltyReductionRatio = 0x98 # float + m_NextLookTarget = 0x9C # QAngle + m_AimTimer = 0xA8 # CountdownTimer + m_SniperHoldTimer = 0xC0 # CountdownTimer + m_FocusIntervalTimer = 0xD8 # CountdownTimer + m_bAcquired = 0xF0 # bool + +class CBtActionCombatPositioning: + m_szSensorInputKey = 0x68 # CUtlString + m_szIsAttackingKey = 0x80 # CUtlString + m_ActionTimer = 0x88 # CountdownTimer + m_bCrouching = 0xA0 # bool + +class CBtActionMoveTo: + m_szDestinationInputKey = 0x60 # CUtlString + m_szHidingSpotInputKey = 0x68 # CUtlString + m_szThreatInputKey = 0x70 # CUtlString + m_vecDestination = 0x78 # Vector + m_bAutoLookAdjust = 0x84 # bool + m_bComputePath = 0x85 # bool + m_flDamagingAreasPenaltyCost = 0x88 # float + m_CheckApproximateCornersTimer = 0x90 # CountdownTimer + m_CheckHighPriorityItem = 0xA8 # CountdownTimer + m_RepathTimer = 0xC0 # CountdownTimer + m_flArrivalEpsilon = 0xD8 # float + m_flAdditionalArrivalEpsilon2D = 0xDC # float + m_flHidingSpotCheckDistanceThreshold = 0xE0 # float + m_flNearestAreaDistanceThreshold = 0xE4 # float + +class CBtActionParachutePositioning: + m_ActionTimer = 0x58 # CountdownTimer + +class CBtNodeCondition: + m_bNegated = 0x58 # bool + +class CBtNodeConditionInactive: + m_flRoundStartThresholdSeconds = 0x78 # float + m_flSensorInactivityThresholdSeconds = 0x7C # float + m_SensorInactivityTimer = 0x80 # CountdownTimer + +class CBubbling: + m_density = 0x700 # int32_t + m_frequency = 0x704 # int32_t + m_state = 0x708 # int32_t + +class CBuoyancyHelper: + m_flFluidDensity = 0x18 # float + +class CBuyZone: + m_LegacyTeamNum = 0x8A8 # int32_t + +class CC4: + m_vecLastValidPlayerHeldPosition = 0xDD8 # Vector + m_vecLastValidDroppedPosition = 0xDE4 # Vector + m_bDoValidDroppedPositionCheck = 0xDF0 # bool + m_bStartedArming = 0xDF1 # bool + m_fArmedTime = 0xDF4 # GameTime_t + m_bBombPlacedAnimation = 0xDF8 # bool + m_bIsPlantingViaUse = 0xDF9 # bool + m_entitySpottedState = 0xE00 # EntitySpottedState_t + m_nSpotRules = 0xE18 # int32_t + m_bPlayedArmingBeeps = 0xE1C # bool[7] + m_bBombPlanted = 0xE23 # bool + m_bDroppedFromDeath = 0xE24 # bool + +class CCSBot: + m_lastCoopSpawnPoint = 0xD8 # CHandle + m_eyePosition = 0xE8 # Vector + m_name = 0xF4 # char[64] + m_combatRange = 0x134 # float + m_isRogue = 0x138 # bool + m_rogueTimer = 0x140 # CountdownTimer + m_diedLastRound = 0x15C # bool + m_safeTime = 0x160 # float + m_wasSafe = 0x164 # bool + m_blindFire = 0x16C # bool + m_surpriseTimer = 0x170 # CountdownTimer + m_bAllowActive = 0x188 # bool + m_isFollowing = 0x189 # bool + m_leader = 0x18C # CHandle + m_followTimestamp = 0x190 # float + m_allowAutoFollowTime = 0x194 # float + m_hurryTimer = 0x198 # CountdownTimer + m_alertTimer = 0x1B0 # CountdownTimer + m_sneakTimer = 0x1C8 # CountdownTimer + m_panicTimer = 0x1E0 # CountdownTimer + m_stateTimestamp = 0x4B0 # float + m_isAttacking = 0x4B4 # bool + m_isOpeningDoor = 0x4B5 # bool + m_taskEntity = 0x4BC # CHandle + m_goalPosition = 0x4CC # Vector + m_goalEntity = 0x4D8 # CHandle + m_avoid = 0x4DC # CHandle + m_avoidTimestamp = 0x4E0 # float + m_isStopping = 0x4E4 # bool + m_hasVisitedEnemySpawn = 0x4E5 # bool + m_stillTimer = 0x4E8 # IntervalTimer + m_bEyeAnglesUnderPathFinderControl = 0x4F8 # bool + m_pathIndex = 0x65F0 # int32_t + m_areaEnteredTimestamp = 0x65F4 # GameTime_t + m_repathTimer = 0x65F8 # CountdownTimer + m_avoidFriendTimer = 0x6610 # CountdownTimer + m_isFriendInTheWay = 0x6628 # bool + m_politeTimer = 0x6630 # CountdownTimer + m_isWaitingBehindFriend = 0x6648 # bool + m_pathLadderEnd = 0x6674 # float + m_mustRunTimer = 0x66C0 # CountdownTimer + m_waitTimer = 0x66D8 # CountdownTimer + m_updateTravelDistanceTimer = 0x66F0 # CountdownTimer + m_playerTravelDistance = 0x6708 # float[64] + m_travelDistancePhase = 0x6808 # uint8_t + m_hostageEscortCount = 0x69A0 # uint8_t + m_hostageEscortCountTimestamp = 0x69A4 # float + m_desiredTeam = 0x69A8 # int32_t + m_hasJoined = 0x69AC # bool + m_isWaitingForHostage = 0x69AD # bool + m_inhibitWaitingForHostageTimer = 0x69B0 # CountdownTimer + m_waitForHostageTimer = 0x69C8 # CountdownTimer + m_noisePosition = 0x69E0 # Vector + m_noiseTravelDistance = 0x69EC # float + m_noiseTimestamp = 0x69F0 # float + m_noiseSource = 0x69F8 # CCSPlayerPawn* + m_noiseBendTimer = 0x6A10 # CountdownTimer + m_bentNoisePosition = 0x6A28 # Vector + m_bendNoisePositionValid = 0x6A34 # bool + m_lookAroundStateTimestamp = 0x6A38 # float + m_lookAheadAngle = 0x6A3C # float + m_forwardAngle = 0x6A40 # float + m_inhibitLookAroundTimestamp = 0x6A44 # float + m_lookAtSpot = 0x6A4C # Vector + m_lookAtSpotDuration = 0x6A5C # float + m_lookAtSpotTimestamp = 0x6A60 # float + m_lookAtSpotAngleTolerance = 0x6A64 # float + m_lookAtSpotClearIfClose = 0x6A68 # bool + m_lookAtSpotAttack = 0x6A69 # bool + m_lookAtDesc = 0x6A70 # char* + m_peripheralTimestamp = 0x6A78 # float + m_approachPointCount = 0x6C00 # uint8_t + m_approachPointViewPosition = 0x6C04 # Vector + m_viewSteadyTimer = 0x6C10 # IntervalTimer + m_tossGrenadeTimer = 0x6C28 # CountdownTimer + m_isAvoidingGrenade = 0x6C48 # CountdownTimer + m_spotCheckTimestamp = 0x6C68 # float + m_checkedHidingSpotCount = 0x7070 # int32_t + m_lookPitch = 0x7074 # float + m_lookPitchVel = 0x7078 # float + m_lookYaw = 0x707C # float + m_lookYawVel = 0x7080 # float + m_targetSpot = 0x7084 # Vector + m_targetSpotVelocity = 0x7090 # Vector + m_targetSpotPredicted = 0x709C # Vector + m_aimError = 0x70A8 # QAngle + m_aimGoal = 0x70B4 # QAngle + m_targetSpotTime = 0x70C0 # GameTime_t + m_aimFocus = 0x70C4 # float + m_aimFocusInterval = 0x70C8 # float + m_aimFocusNextUpdate = 0x70CC # GameTime_t + m_ignoreEnemiesTimer = 0x70D8 # CountdownTimer + m_enemy = 0x70F0 # CHandle + m_isEnemyVisible = 0x70F4 # bool + m_visibleEnemyParts = 0x70F5 # uint8_t + m_lastEnemyPosition = 0x70F8 # Vector + m_lastSawEnemyTimestamp = 0x7104 # float + m_firstSawEnemyTimestamp = 0x7108 # float + m_currentEnemyAcquireTimestamp = 0x710C # float + m_enemyDeathTimestamp = 0x7110 # float + m_friendDeathTimestamp = 0x7114 # float + m_isLastEnemyDead = 0x7118 # bool + m_nearbyEnemyCount = 0x711C # int32_t + m_bomber = 0x7328 # CHandle + m_nearbyFriendCount = 0x732C # int32_t + m_closestVisibleFriend = 0x7330 # CHandle + m_closestVisibleHumanFriend = 0x7334 # CHandle + m_attentionInterval = 0x7338 # IntervalTimer + m_attacker = 0x7348 # CHandle + m_attackedTimestamp = 0x734C # float + m_burnedByFlamesTimer = 0x7350 # IntervalTimer + m_lastVictimID = 0x7360 # int32_t + m_isAimingAtEnemy = 0x7364 # bool + m_isRapidFiring = 0x7365 # bool + m_equipTimer = 0x7368 # IntervalTimer + m_zoomTimer = 0x7378 # CountdownTimer + m_fireWeaponTimestamp = 0x7390 # GameTime_t + m_lookForWeaponsOnGroundTimer = 0x7398 # CountdownTimer + m_bIsSleeping = 0x73B0 # bool + m_isEnemySniperVisible = 0x73B1 # bool + m_sawEnemySniperTimer = 0x73B8 # CountdownTimer + m_enemyQueueIndex = 0x7470 # uint8_t + m_enemyQueueCount = 0x7471 # uint8_t + m_enemyQueueAttendIndex = 0x7472 # uint8_t + m_isStuck = 0x7473 # bool + m_stuckTimestamp = 0x7474 # GameTime_t + m_stuckSpot = 0x7478 # Vector + m_wiggleTimer = 0x7488 # CountdownTimer + m_stuckJumpTimer = 0x74A0 # CountdownTimer + m_nextCleanupCheckTimestamp = 0x74B8 # GameTime_t + m_avgVel = 0x74BC # float[10] + m_avgVelIndex = 0x74E4 # int32_t + m_avgVelCount = 0x74E8 # int32_t + m_lastOrigin = 0x74EC # Vector + m_lastRadioRecievedTimestamp = 0x74FC # float + m_lastRadioSentTimestamp = 0x7500 # float + m_radioSubject = 0x7504 # CHandle + m_radioPosition = 0x7508 # Vector + m_voiceEndTimestamp = 0x7514 # float + m_lastValidReactionQueueFrame = 0x7520 # int32_t + +class CCSGOViewModel: + m_bShouldIgnoreOffsetAndAccuracy = 0x8D8 # bool + m_nWeaponParity = 0x8DC # uint32_t + m_nOldWeaponParity = 0x8E0 # uint32_t + +class CCSGO_TeamPreviewCharacterPosition: + m_nVariant = 0x4B0 # int32_t + m_nRandom = 0x4B4 # int32_t + m_nOrdinal = 0x4B8 # int32_t + m_sWeaponName = 0x4C0 # CUtlString + m_xuid = 0x4C8 # uint64_t + m_agentItem = 0x4D0 # CEconItemView + m_glovesItem = 0x748 # CEconItemView + m_weaponItem = 0x9C0 # CEconItemView + +class CCSGameModeRules: + __m_pChainEntity = 0x8 # CNetworkVarChainer + +class CCSGameModeRules_Deathmatch: + m_bFirstThink = 0x30 # bool + m_bFirstThinkAfterConnected = 0x31 # bool + m_flDMBonusStartTime = 0x34 # GameTime_t + m_flDMBonusTimeLength = 0x38 # float + m_nDMBonusWeaponLoadoutSlot = 0x3C # int16_t + +class CCSGameRules: + __m_pChainEntity = 0x98 # CNetworkVarChainer + m_coopMissionManager = 0xC0 # CHandle + m_bFreezePeriod = 0xC4 # bool + m_bWarmupPeriod = 0xC5 # bool + m_fWarmupPeriodEnd = 0xC8 # GameTime_t + m_fWarmupPeriodStart = 0xCC # GameTime_t + m_nTotalPausedTicks = 0xD0 # int32_t + m_nPauseStartTick = 0xD4 # int32_t + m_bServerPaused = 0xD8 # bool + m_bGamePaused = 0xD9 # bool + m_bTerroristTimeOutActive = 0xDA # bool + m_bCTTimeOutActive = 0xDB # bool + m_flTerroristTimeOutRemaining = 0xDC # float + m_flCTTimeOutRemaining = 0xE0 # float + m_nTerroristTimeOuts = 0xE4 # int32_t + m_nCTTimeOuts = 0xE8 # int32_t + m_bTechnicalTimeOut = 0xEC # bool + m_bMatchWaitingForResume = 0xED # bool + m_iRoundTime = 0xF0 # int32_t + m_fMatchStartTime = 0xF4 # float + m_fRoundStartTime = 0xF8 # GameTime_t + m_flRestartRoundTime = 0xFC # GameTime_t + m_bGameRestart = 0x100 # bool + m_flGameStartTime = 0x104 # float + m_timeUntilNextPhaseStarts = 0x108 # float + m_gamePhase = 0x10C # int32_t + m_totalRoundsPlayed = 0x110 # int32_t + m_nRoundsPlayedThisPhase = 0x114 # int32_t + m_nOvertimePlaying = 0x118 # int32_t + m_iHostagesRemaining = 0x11C # int32_t + m_bAnyHostageReached = 0x120 # bool + m_bMapHasBombTarget = 0x121 # bool + m_bMapHasRescueZone = 0x122 # bool + m_bMapHasBuyZone = 0x123 # bool + m_bIsQueuedMatchmaking = 0x124 # bool + m_nQueuedMatchmakingMode = 0x128 # int32_t + m_bIsValveDS = 0x12C # bool + m_bLogoMap = 0x12D # bool + m_bPlayAllStepSoundsOnServer = 0x12E # bool + m_iSpectatorSlotCount = 0x130 # int32_t + m_MatchDevice = 0x134 # int32_t + m_bHasMatchStarted = 0x138 # bool + m_nNextMapInMapgroup = 0x13C # int32_t + m_szTournamentEventName = 0x140 # char[512] + m_szTournamentEventStage = 0x340 # char[512] + m_szMatchStatTxt = 0x540 # char[512] + m_szTournamentPredictionsTxt = 0x740 # char[512] + m_nTournamentPredictionsPct = 0x940 # int32_t + m_flCMMItemDropRevealStartTime = 0x944 # GameTime_t + m_flCMMItemDropRevealEndTime = 0x948 # GameTime_t + m_bIsDroppingItems = 0x94C # bool + m_bIsQuestEligible = 0x94D # bool + m_bIsHltvActive = 0x94E # bool + m_nGuardianModeWaveNumber = 0x950 # int32_t + m_nGuardianModeSpecialKillsRemaining = 0x954 # int32_t + m_nGuardianModeSpecialWeaponNeeded = 0x958 # int32_t + m_nGuardianGrenadesToGiveBots = 0x95C # int32_t + m_nNumHeaviesToSpawn = 0x960 # int32_t + m_numGlobalGiftsGiven = 0x964 # uint32_t + m_numGlobalGifters = 0x968 # uint32_t + m_numGlobalGiftsPeriodSeconds = 0x96C # uint32_t + m_arrFeaturedGiftersAccounts = 0x970 # uint32_t[4] + m_arrFeaturedGiftersGifts = 0x980 # uint32_t[4] + m_arrProhibitedItemIndices = 0x990 # uint16_t[100] + m_arrTournamentActiveCasterAccounts = 0xA58 # uint32_t[4] + m_numBestOfMaps = 0xA68 # int32_t + m_nHalloweenMaskListSeed = 0xA6C # int32_t + m_bBombDropped = 0xA70 # bool + m_bBombPlanted = 0xA71 # bool + m_iRoundWinStatus = 0xA74 # int32_t + m_eRoundWinReason = 0xA78 # int32_t + m_bTCantBuy = 0xA7C # bool + m_bCTCantBuy = 0xA7D # bool + m_flGuardianBuyUntilTime = 0xA80 # GameTime_t + m_iMatchStats_RoundResults = 0xA84 # int32_t[30] + m_iMatchStats_PlayersAlive_CT = 0xAFC # int32_t[30] + m_iMatchStats_PlayersAlive_T = 0xB74 # int32_t[30] + m_TeamRespawnWaveTimes = 0xBEC # float[32] + m_flNextRespawnWave = 0xC6C # GameTime_t[32] + m_nServerQuestID = 0xCEC # int32_t + m_vMinimapMins = 0xCF0 # Vector + m_vMinimapMaxs = 0xCFC # Vector + m_MinimapVerticalSectionHeights = 0xD08 # float[8] + m_bDontIncrementCoopWave = 0xD28 # bool + m_bSpawnedTerrorHuntHeavy = 0xD29 # bool + m_nEndMatchMapGroupVoteTypes = 0xD2C # int32_t[10] + m_nEndMatchMapGroupVoteOptions = 0xD54 # int32_t[10] + m_nEndMatchMapVoteWinner = 0xD7C # int32_t + m_iNumConsecutiveCTLoses = 0xD80 # int32_t + m_iNumConsecutiveTerroristLoses = 0xD84 # int32_t + m_bHasHostageBeenTouched = 0xDA0 # bool + m_flIntermissionStartTime = 0xDA4 # GameTime_t + m_flIntermissionEndTime = 0xDA8 # GameTime_t + m_bLevelInitialized = 0xDAC # bool + m_iTotalRoundsPlayed = 0xDB0 # int32_t + m_iUnBalancedRounds = 0xDB4 # int32_t + m_endMatchOnRoundReset = 0xDB8 # bool + m_endMatchOnThink = 0xDB9 # bool + m_iFreezeTime = 0xDBC # int32_t + m_iNumTerrorist = 0xDC0 # int32_t + m_iNumCT = 0xDC4 # int32_t + m_iNumSpawnableTerrorist = 0xDC8 # int32_t + m_iNumSpawnableCT = 0xDCC # int32_t + m_arrSelectedHostageSpawnIndices = 0xDD0 # CUtlVector + m_bFirstConnected = 0xDE8 # bool + m_bCompleteReset = 0xDE9 # bool + m_bPickNewTeamsOnReset = 0xDEA # bool + m_bScrambleTeamsOnRestart = 0xDEB # bool + m_bSwapTeamsOnRestart = 0xDEC # bool + m_nEndMatchTiedVotes = 0xDF8 # CUtlVector + m_bNeedToAskPlayersForContinueVote = 0xE14 # bool + m_numQueuedMatchmakingAccounts = 0xE18 # uint32_t + m_pQueuedMatchmakingReservationString = 0xE20 # char* + m_numTotalTournamentDrops = 0xE28 # uint32_t + m_numSpectatorsCountMax = 0xE2C # uint32_t + m_numSpectatorsCountMaxTV = 0xE30 # uint32_t + m_numSpectatorsCountMaxLnk = 0xE34 # uint32_t + m_bForceTeamChangeSilent = 0xE40 # bool + m_bLoadingRoundBackupData = 0xE41 # bool + m_nMatchInfoShowType = 0xE78 # int32_t + m_flMatchInfoDecidedTime = 0xE7C # float + m_flCoopRespawnAndHealTime = 0xE98 # float + m_coopBonusCoinsFound = 0xE9C # int32_t + m_coopBonusPistolsOnly = 0xEA0 # bool + m_coopPlayersInDeploymentZone = 0xEA1 # bool + m_coopMissionDeadPlayerRespawnEnabled = 0xEA2 # bool + mTeamDMLastWinningTeamNumber = 0xEA4 # int32_t + mTeamDMLastThinkTime = 0xEA8 # float + m_flTeamDMLastAnnouncementTime = 0xEAC # float + m_iAccountTerrorist = 0xEB0 # int32_t + m_iAccountCT = 0xEB4 # int32_t + m_iSpawnPointCount_Terrorist = 0xEB8 # int32_t + m_iSpawnPointCount_CT = 0xEBC # int32_t + m_iMaxNumTerrorists = 0xEC0 # int32_t + m_iMaxNumCTs = 0xEC4 # int32_t + m_iLoserBonus = 0xEC8 # int32_t + m_iLoserBonusMostRecentTeam = 0xECC # int32_t + m_tmNextPeriodicThink = 0xED0 # float + m_bVoiceWonMatchBragFired = 0xED4 # bool + m_fWarmupNextChatNoticeTime = 0xED8 # float + m_iHostagesRescued = 0xEE0 # int32_t + m_iHostagesTouched = 0xEE4 # int32_t + m_flNextHostageAnnouncement = 0xEE8 # float + m_bNoTerroristsKilled = 0xEEC # bool + m_bNoCTsKilled = 0xEED # bool + m_bNoEnemiesKilled = 0xEEE # bool + m_bCanDonateWeapons = 0xEEF # bool + m_firstKillTime = 0xEF4 # float + m_firstBloodTime = 0xEFC # float + m_hostageWasInjured = 0xF18 # bool + m_hostageWasKilled = 0xF19 # bool + m_bVoteCalled = 0xF28 # bool + m_bServerVoteOnReset = 0xF29 # bool + m_flVoteCheckThrottle = 0xF2C # float + m_bBuyTimeEnded = 0xF30 # bool + m_nLastFreezeEndBeep = 0xF34 # int32_t + m_bTargetBombed = 0xF38 # bool + m_bBombDefused = 0xF39 # bool + m_bMapHasBombZone = 0xF3A # bool + m_vecMainCTSpawnPos = 0xF58 # Vector + m_CTSpawnPointsMasterList = 0xF68 # CUtlVector + m_TerroristSpawnPointsMasterList = 0xF80 # CUtlVector + m_iNextCTSpawnPoint = 0xF98 # int32_t + m_iNextTerroristSpawnPoint = 0xF9C # int32_t + m_CTSpawnPoints = 0xFA0 # CUtlVector + m_TerroristSpawnPoints = 0xFB8 # CUtlVector + m_bIsUnreservedGameServer = 0xFD0 # bool + m_fAutobalanceDisplayTime = 0xFD4 # float + m_bAllowWeaponSwitch = 0x1240 # bool + m_bRoundTimeWarningTriggered = 0x1241 # bool + m_phaseChangeAnnouncementTime = 0x1244 # GameTime_t + m_fNextUpdateTeamClanNamesTime = 0x1248 # float + m_flLastThinkTime = 0x124C # GameTime_t + m_fAccumulatedRoundOffDamage = 0x1250 # float + m_nShorthandedBonusLastEvalRound = 0x1254 # int32_t + m_bMatchAbortedDueToPlayerBan = 0x14D0 # bool + m_bHasTriggeredRoundStartMusic = 0x14D1 # bool + m_bHasTriggeredCoopSpawnReset = 0x14D2 # bool + m_bSwitchingTeamsAtRoundReset = 0x14D3 # bool + m_pGameModeRules = 0x14F0 # CCSGameModeRules* + m_BtGlobalBlackboard = 0x14F8 # KeyValues3 + m_hPlayerResource = 0x1560 # CHandle + m_RetakeRules = 0x1568 # CRetakeGameRules + m_GuardianBotSkillLevelMax = 0x174C # int32_t + m_GuardianBotSkillLevelMin = 0x1750 # int32_t + m_arrTeamUniqueKillWeaponsMatch = 0x1758 # CUtlVector[4] + m_bTeamLastKillUsedUniqueWeaponMatch = 0x17B8 # bool[4] + m_nMatchEndCount = 0x17E0 # uint8_t + m_nTTeamIntroVariant = 0x17E4 # int32_t + m_nCTTeamIntroVariant = 0x17E8 # int32_t + m_bTeamIntroPeriod = 0x17EC # bool + m_fTeamIntroPeriodEnd = 0x17F0 # GameTime_t + m_bPlayedTeamIntroVO = 0x17F4 # bool + m_flLastPerfSampleTime = 0x5800 # double + m_bSkipNextServerPerfSample = 0x5808 # bool + +class CCSGameRulesProxy: + m_pGameRules = 0x4B0 # CCSGameRules* + +class CCSPlace: + m_name = 0x708 # CUtlSymbolLarge + +class CCSPlayerBase_CameraServices: + m_iFOV = 0x170 # uint32_t + m_iFOVStart = 0x174 # uint32_t + m_flFOVTime = 0x178 # GameTime_t + m_flFOVRate = 0x17C # float + m_hZoomOwner = 0x180 # CHandle + m_hTriggerFogList = 0x188 # CUtlVector> + m_hLastFogTrigger = 0x1A0 # CHandle + +class CCSPlayerController: + m_pInGameMoneyServices = 0x6A0 # CCSPlayerController_InGameMoneyServices* + m_pInventoryServices = 0x6A8 # CCSPlayerController_InventoryServices* + m_pActionTrackingServices = 0x6B0 # CCSPlayerController_ActionTrackingServices* + m_pDamageServices = 0x6B8 # CCSPlayerController_DamageServices* + m_iPing = 0x6C0 # uint32_t + m_bHasCommunicationAbuseMute = 0x6C4 # bool + m_szCrosshairCodes = 0x6C8 # CUtlSymbolLarge + m_iPendingTeamNum = 0x6D0 # uint8_t + m_flForceTeamTime = 0x6D4 # GameTime_t + m_iCompTeammateColor = 0x6D8 # int32_t + m_bEverPlayedOnTeam = 0x6DC # bool + m_bAttemptedToGetColor = 0x6DD # bool + m_iTeammatePreferredColor = 0x6E0 # int32_t + m_bTeamChanged = 0x6E4 # bool + m_bInSwitchTeam = 0x6E5 # bool + m_bHasSeenJoinGame = 0x6E6 # bool + m_bJustBecameSpectator = 0x6E7 # bool + m_bSwitchTeamsOnNextRoundReset = 0x6E8 # bool + m_bRemoveAllItemsOnNextRoundReset = 0x6E9 # bool + m_szClan = 0x6F0 # CUtlSymbolLarge + m_szClanName = 0x6F8 # char[32] + m_iCoachingTeam = 0x718 # int32_t + m_nPlayerDominated = 0x720 # uint64_t + m_nPlayerDominatingMe = 0x728 # uint64_t + m_iCompetitiveRanking = 0x730 # int32_t + m_iCompetitiveWins = 0x734 # int32_t + m_iCompetitiveRankType = 0x738 # int8_t + m_iCompetitiveRankingPredicted_Win = 0x73C # int32_t + m_iCompetitiveRankingPredicted_Loss = 0x740 # int32_t + m_iCompetitiveRankingPredicted_Tie = 0x744 # int32_t + m_nEndMatchNextMapVote = 0x748 # int32_t + m_unActiveQuestId = 0x74C # uint16_t + m_nQuestProgressReason = 0x750 # QuestProgress::Reason + m_unPlayerTvControlFlags = 0x754 # uint32_t + m_iDraftIndex = 0x780 # int32_t + m_msQueuedModeDisconnectionTimestamp = 0x784 # uint32_t + m_uiAbandonRecordedReason = 0x788 # uint32_t + m_bEverFullyConnected = 0x78C # bool + m_bAbandonAllowsSurrender = 0x78D # bool + m_bAbandonOffersInstantSurrender = 0x78E # bool + m_bDisconnection1MinWarningPrinted = 0x78F # bool + m_bScoreReported = 0x790 # bool + m_nDisconnectionTick = 0x794 # int32_t + m_bControllingBot = 0x7A0 # bool + m_bHasControlledBotThisRound = 0x7A1 # bool + m_bHasBeenControlledByPlayerThisRound = 0x7A2 # bool + m_nBotsControlledThisRound = 0x7A4 # int32_t + m_bCanControlObservedBot = 0x7A8 # bool + m_hPlayerPawn = 0x7AC # CHandle + m_hObserverPawn = 0x7B0 # CHandle + m_DesiredObserverMode = 0x7B4 # int32_t + m_hDesiredObserverTarget = 0x7B8 # CEntityHandle + m_bPawnIsAlive = 0x7BC # bool + m_iPawnHealth = 0x7C0 # uint32_t + m_iPawnArmor = 0x7C4 # int32_t + m_bPawnHasDefuser = 0x7C8 # bool + m_bPawnHasHelmet = 0x7C9 # bool + m_nPawnCharacterDefIndex = 0x7CA # uint16_t + m_iPawnLifetimeStart = 0x7CC # int32_t + m_iPawnLifetimeEnd = 0x7D0 # int32_t + m_iPawnBotDifficulty = 0x7D4 # int32_t + m_hOriginalControllerOfCurrentPawn = 0x7D8 # CHandle + m_iScore = 0x7DC # int32_t + m_iRoundScore = 0x7E0 # int32_t + m_iRoundsWon = 0x7E4 # int32_t + m_vecKills = 0x7E8 # CNetworkUtlVectorBase + m_iMVPs = 0x800 # int32_t + m_nUpdateCounter = 0x804 # int32_t + m_lastHeldVoteTimer = 0xF8A8 # IntervalTimer + m_bShowHints = 0xF8C0 # bool + m_iNextTimeCheck = 0xF8C4 # int32_t + m_bJustDidTeamKill = 0xF8C8 # bool + m_bPunishForTeamKill = 0xF8C9 # bool + m_bGaveTeamDamageWarning = 0xF8CA # bool + m_bGaveTeamDamageWarningThisRound = 0xF8CB # bool + m_LastTeamDamageWarningTime = 0xF8CC # GameTime_t + +class CCSPlayerController_ActionTrackingServices: + m_perRoundStats = 0x40 # CUtlVectorEmbeddedNetworkVar + m_matchStats = 0x90 # CSMatchStats_t + m_iNumRoundKills = 0x148 # int32_t + m_iNumRoundKillsHeadshots = 0x14C # int32_t + +class CCSPlayerController_DamageServices: + m_nSendUpdate = 0x40 # int32_t + m_DamageList = 0x48 # CUtlVectorEmbeddedNetworkVar + +class CCSPlayerController_InGameMoneyServices: + m_bReceivesMoneyNextRound = 0x40 # bool + m_iAccountMoneyEarnedForNextRound = 0x44 # int32_t + m_iAccount = 0x48 # int32_t + m_iStartAccount = 0x4C # int32_t + m_iTotalCashSpent = 0x50 # int32_t + m_iCashSpentThisRound = 0x54 # int32_t + +class CCSPlayerController_InventoryServices: + m_unMusicID = 0x40 # uint16_t + m_rank = 0x44 # MedalRank_t[6] + m_nPersonaDataPublicLevel = 0x5C # int32_t + m_nPersonaDataPublicCommendsLeader = 0x60 # int32_t + m_nPersonaDataPublicCommendsTeacher = 0x64 # int32_t + m_nPersonaDataPublicCommendsFriendly = 0x68 # int32_t + m_unEquippedPlayerSprayIDs = 0xF48 # uint32_t[1] + m_vecServerAuthoritativeWeaponSlots = 0xF50 # CUtlVectorEmbeddedNetworkVar + +class CCSPlayerPawn: + m_pBulletServices = 0x1548 # CCSPlayer_BulletServices* + m_pHostageServices = 0x1550 # CCSPlayer_HostageServices* + m_pBuyServices = 0x1558 # CCSPlayer_BuyServices* + m_pActionTrackingServices = 0x1560 # CCSPlayer_ActionTrackingServices* + m_pRadioServices = 0x1568 # CCSPlayer_RadioServices* + m_pDamageReactServices = 0x1570 # CCSPlayer_DamageReactServices* + m_nCharacterDefIndex = 0x1578 # uint16_t + m_hPreviousModel = 0x1580 # CStrongHandle + m_bHasFemaleVoice = 0x1588 # bool + m_strVOPrefix = 0x1590 # CUtlString + m_szLastPlaceName = 0x1598 # char[18] + m_bInBuyZone = 0x1658 # bool + m_bWasInBuyZone = 0x1659 # bool + m_bInHostageRescueZone = 0x165A # bool + m_bInBombZone = 0x165B # bool + m_bWasInHostageRescueZone = 0x165C # bool + m_iRetakesOffering = 0x1660 # int32_t + m_iRetakesOfferingCard = 0x1664 # int32_t + m_bRetakesHasDefuseKit = 0x1668 # bool + m_bRetakesMVPLastRound = 0x1669 # bool + m_iRetakesMVPBoostItem = 0x166C # int32_t + m_RetakesMVPBoostExtraUtility = 0x1670 # loadout_slot_t + m_flHealthShotBoostExpirationTime = 0x1674 # GameTime_t + m_flLandseconds = 0x1678 # float + m_aimPunchAngle = 0x167C # QAngle + m_aimPunchAngleVel = 0x1688 # QAngle + m_aimPunchTickBase = 0x1694 # int32_t + m_aimPunchTickFraction = 0x1698 # float + m_aimPunchCache = 0x16A0 # CUtlVector + m_bIsBuyMenuOpen = 0x16B8 # bool + m_xLastHeadBoneTransform = 0x1C30 # CTransform + m_bLastHeadBoneTransformIsValid = 0x1C50 # bool + m_lastLandTime = 0x1C54 # GameTime_t + m_bOnGroundLastTick = 0x1C58 # bool + m_iPlayerLocked = 0x1C5C # int32_t + m_flTimeOfLastInjury = 0x1C64 # GameTime_t + m_flNextSprayDecalTime = 0x1C68 # GameTime_t + m_bNextSprayDecalTimeExpedited = 0x1C6C # bool + m_nRagdollDamageBone = 0x1C70 # int32_t + m_vRagdollDamageForce = 0x1C74 # Vector + m_vRagdollDamagePosition = 0x1C80 # Vector + m_szRagdollDamageWeaponName = 0x1C8C # char[64] + m_bRagdollDamageHeadshot = 0x1CCC # bool + m_EconGloves = 0x1CD0 # CEconItemView + m_qDeathEyeAngles = 0x1F48 # QAngle + m_bSkipOneHeadConstraintUpdate = 0x1F54 # bool + +class CCSPlayerPawnBase: + m_CTouchExpansionComponent = 0xB60 # CTouchExpansionComponent + m_pPingServices = 0xBB0 # CCSPlayer_PingServices* + m_pViewModelServices = 0xBB8 # CPlayer_ViewModelServices* + m_iDisplayHistoryBits = 0xBC0 # uint32_t + m_flLastAttackedTeammate = 0xBC4 # float + m_hOriginalController = 0xBC8 # CHandle + m_blindUntilTime = 0xBCC # GameTime_t + m_blindStartTime = 0xBD0 # GameTime_t + m_allowAutoFollowTime = 0xBD4 # GameTime_t + m_entitySpottedState = 0xBD8 # EntitySpottedState_t + m_nSpotRules = 0xBF0 # int32_t + m_iPlayerState = 0xBF4 # CSPlayerState + m_chickenIdleSoundTimer = 0xC00 # CountdownTimer + m_chickenJumpSoundTimer = 0xC18 # CountdownTimer + m_vecLastBookmarkedPosition = 0xCD0 # Vector + m_flLastDistanceTraveledNotice = 0xCDC # float + m_flAccumulatedDistanceTraveled = 0xCE0 # float + m_flLastFriendlyFireDamageReductionRatio = 0xCE4 # float + m_bRespawning = 0xCE8 # bool + m_nLastPickupPriority = 0xCEC # int32_t + m_flLastPickupPriorityTime = 0xCF0 # float + m_bIsScoped = 0xCF4 # bool + m_bIsWalking = 0xCF5 # bool + m_bResumeZoom = 0xCF6 # bool + m_bIsDefusing = 0xCF7 # bool + m_bIsGrabbingHostage = 0xCF8 # bool + m_iBlockingUseActionInProgress = 0xCFC # CSPlayerBlockingUseAction_t + m_fImmuneToGunGameDamageTime = 0xD00 # GameTime_t + m_bGunGameImmunity = 0xD04 # bool + m_unTotalRoundDamageDealt = 0xD08 # uint32_t + m_fMolotovDamageTime = 0xD0C # float + m_bHasMovedSinceSpawn = 0xD10 # bool + m_bCanMoveDuringFreezePeriod = 0xD11 # bool + m_flGuardianTooFarDistFrac = 0xD14 # float + m_flNextGuardianTooFarHurtTime = 0xD18 # float + m_flDetectedByEnemySensorTime = 0xD1C # GameTime_t + m_flDealtDamageToEnemyMostRecentTimestamp = 0xD20 # float + m_flLastEquippedHelmetTime = 0xD24 # GameTime_t + m_flLastEquippedArmorTime = 0xD28 # GameTime_t + m_nHeavyAssaultSuitCooldownRemaining = 0xD2C # int32_t + m_bResetArmorNextSpawn = 0xD30 # bool + m_flLastBumpMineBumpTime = 0xD34 # GameTime_t + m_flEmitSoundTime = 0xD38 # GameTime_t + m_iNumSpawns = 0xD3C # int32_t + m_iShouldHaveCash = 0xD40 # int32_t + m_bInvalidSteamLogonDelayed = 0xD44 # bool + m_flLastAction = 0xD48 # GameTime_t + m_flNameChangeHistory = 0xD4C # float[5] + m_fLastGivenDefuserTime = 0xD60 # float + m_fLastGivenBombTime = 0xD64 # float + m_bHasNightVision = 0xD68 # bool + m_bNightVisionOn = 0xD69 # bool + m_fNextRadarUpdateTime = 0xD6C # float + m_flLastMoneyUpdateTime = 0xD70 # float + m_MenuStringBuffer = 0xD74 # char[1024] + m_fIntroCamTime = 0x1174 # float + m_nMyCollisionGroup = 0x1178 # int32_t + m_bInNoDefuseArea = 0x117C # bool + m_bKilledByTaser = 0x117D # bool + m_iMoveState = 0x1180 # int32_t + m_grenadeParameterStashTime = 0x1184 # GameTime_t + m_bGrenadeParametersStashed = 0x1188 # bool + m_angStashedShootAngles = 0x118C # QAngle + m_vecStashedGrenadeThrowPosition = 0x1198 # Vector + m_vecStashedVelocity = 0x11A4 # Vector + m_angShootAngleHistory = 0x11B0 # QAngle[2] + m_vecThrowPositionHistory = 0x11C8 # Vector[2] + m_vecVelocityHistory = 0x11E0 # Vector[2] + m_bDiedAirborne = 0x11F8 # bool + m_iBombSiteIndex = 0x11FC # CEntityIndex + m_nWhichBombZone = 0x1200 # int32_t + m_bInBombZoneTrigger = 0x1204 # bool + m_bWasInBombZoneTrigger = 0x1205 # bool + m_iDirection = 0x1208 # int32_t + m_iShotsFired = 0x120C # int32_t + m_ArmorValue = 0x1210 # int32_t + m_flFlinchStack = 0x1214 # float + m_flVelocityModifier = 0x1218 # float + m_flHitHeading = 0x121C # float + m_nHitBodyPart = 0x1220 # int32_t + m_iHostagesKilled = 0x1224 # int32_t + m_vecTotalBulletForce = 0x1228 # Vector + m_flFlashDuration = 0x1234 # float + m_flFlashMaxAlpha = 0x1238 # float + m_flProgressBarStartTime = 0x123C # float + m_iProgressBarDuration = 0x1240 # int32_t + m_bWaitForNoAttack = 0x1244 # bool + m_flLowerBodyYawTarget = 0x1248 # float + m_bStrafing = 0x124C # bool + m_lastStandingPos = 0x1250 # Vector + m_ignoreLadderJumpTime = 0x125C # float + m_ladderSurpressionTimer = 0x1260 # CountdownTimer + m_lastLadderNormal = 0x1278 # Vector + m_lastLadderPos = 0x1284 # Vector + m_thirdPersonHeading = 0x1290 # QAngle + m_flSlopeDropOffset = 0x129C # float + m_flSlopeDropHeight = 0x12A0 # float + m_vHeadConstraintOffset = 0x12A4 # Vector + m_iLastWeaponFireUsercmd = 0x12B8 # int32_t + m_angEyeAngles = 0x12BC # QAngle + m_bVCollisionInitted = 0x12C8 # bool + m_storedSpawnPosition = 0x12CC # Vector + m_storedSpawnAngle = 0x12D8 # QAngle + m_bIsSpawning = 0x12E4 # bool + m_bHideTargetID = 0x12E5 # bool + m_nNumDangerZoneDamageHits = 0x12E8 # int32_t + m_bHud_MiniScoreHidden = 0x12EC # bool + m_bHud_RadarHidden = 0x12ED # bool + m_nLastKillerIndex = 0x12F0 # CEntityIndex + m_nLastConcurrentKilled = 0x12F4 # int32_t + m_nDeathCamMusic = 0x12F8 # int32_t + m_iAddonBits = 0x12FC # int32_t + m_iPrimaryAddon = 0x1300 # int32_t + m_iSecondaryAddon = 0x1304 # int32_t + m_currentDeafnessFilter = 0x1308 # CUtlStringToken + m_NumEnemiesKilledThisSpawn = 0x130C # int32_t + m_NumEnemiesKilledThisRound = 0x1310 # int32_t + m_NumEnemiesAtRoundStart = 0x1314 # int32_t + m_wasNotKilledNaturally = 0x1318 # bool + m_vecPlayerPatchEconIndices = 0x131C # uint32_t[5] + m_iDeathFlags = 0x1330 # int32_t + m_hPet = 0x1334 # CHandle + m_unCurrentEquipmentValue = 0x1500 # uint16_t + m_unRoundStartEquipmentValue = 0x1502 # uint16_t + m_unFreezetimeEndEquipmentValue = 0x1504 # uint16_t + m_nSurvivalTeamNumber = 0x1508 # int32_t + m_bHasDeathInfo = 0x150C # bool + m_flDeathInfoTime = 0x1510 # float + m_vecDeathInfoOrigin = 0x1514 # Vector + m_bKilledByHeadshot = 0x1520 # bool + m_LastHitBox = 0x1524 # int32_t + m_LastHealth = 0x1528 # int32_t + m_flLastCollisionCeiling = 0x152C # float + m_flLastCollisionCeilingChangeTime = 0x1530 # float + m_pBot = 0x1538 # CCSBot* + m_bBotAllowActive = 0x1540 # bool + m_bCommittingSuicideOnTeamChange = 0x1541 # bool + +class CCSPlayerResource: + m_bHostageAlive = 0x4B0 # bool[12] + m_isHostageFollowingSomeone = 0x4BC # bool[12] + m_iHostageEntityIDs = 0x4C8 # CEntityIndex[12] + m_bombsiteCenterA = 0x4F8 # Vector + m_bombsiteCenterB = 0x504 # Vector + m_hostageRescueX = 0x510 # int32_t[4] + m_hostageRescueY = 0x520 # int32_t[4] + m_hostageRescueZ = 0x530 # int32_t[4] + m_bEndMatchNextMapAllVoted = 0x540 # bool + m_foundGoalPositions = 0x541 # bool + +class CCSPlayer_ActionTrackingServices: + m_hLastWeaponBeforeC4AutoSwitch = 0x208 # CHandle + m_bIsRescuing = 0x23C # bool + m_weaponPurchasesThisMatch = 0x240 # WeaponPurchaseTracker_t + m_weaponPurchasesThisRound = 0x298 # WeaponPurchaseTracker_t + +class CCSPlayer_BulletServices: + m_totalHitsOnServer = 0x40 # int32_t + +class CCSPlayer_BuyServices: + m_vecSellbackPurchaseEntries = 0xC8 # CUtlVectorEmbeddedNetworkVar + +class CCSPlayer_HostageServices: + m_hCarriedHostage = 0x40 # CHandle + m_hCarriedHostageProp = 0x44 # CHandle + +class CCSPlayer_ItemServices: + m_bHasDefuser = 0x40 # bool + m_bHasHelmet = 0x41 # bool + m_bHasHeavyArmor = 0x42 # bool + +class CCSPlayer_MovementServices: + m_flMaxFallVelocity = 0x220 # float + m_vecLadderNormal = 0x224 # Vector + m_nLadderSurfacePropIndex = 0x230 # int32_t + m_flDuckAmount = 0x234 # float + m_flDuckSpeed = 0x238 # float + m_bDuckOverride = 0x23C # bool + m_bDesiresDuck = 0x23D # bool + m_flDuckOffset = 0x240 # float + m_nDuckTimeMsecs = 0x244 # uint32_t + m_nDuckJumpTimeMsecs = 0x248 # uint32_t + m_nJumpTimeMsecs = 0x24C # uint32_t + m_flLastDuckTime = 0x250 # float + m_vecLastPositionAtFullCrouchSpeed = 0x260 # Vector2D + m_duckUntilOnGround = 0x268 # bool + m_bHasWalkMovedSinceLastJump = 0x269 # bool + m_bInStuckTest = 0x26A # bool + m_flStuckCheckTime = 0x278 # float[64][2] + m_nTraceCount = 0x478 # int32_t + m_StuckLast = 0x47C # int32_t + m_bSpeedCropped = 0x480 # bool + m_nOldWaterLevel = 0x484 # int32_t + m_flWaterEntryTime = 0x488 # float + m_vecForward = 0x48C # Vector + m_vecLeft = 0x498 # Vector + m_vecUp = 0x4A4 # Vector + m_vecPreviouslyPredictedOrigin = 0x4B0 # Vector + m_bMadeFootstepNoise = 0x4BC # bool + m_iFootsteps = 0x4C0 # int32_t + m_bOldJumpPressed = 0x4C4 # bool + m_flJumpPressedTime = 0x4C8 # float + m_flJumpUntil = 0x4CC # float + m_flJumpVel = 0x4D0 # float + m_fStashGrenadeParameterWhen = 0x4D4 # GameTime_t + m_nButtonDownMaskPrev = 0x4D8 # uint64_t + m_flOffsetTickCompleteTime = 0x4E0 # float + m_flOffsetTickStashedSpeed = 0x4E4 # float + m_flStamina = 0x4E8 # float + +class CCSPlayer_PingServices: + m_flPlayerPingTokens = 0x40 # GameTime_t[5] + m_hPlayerPing = 0x54 # CHandle + +class CCSPlayer_RadioServices: + m_flGotHostageTalkTimer = 0x40 # GameTime_t + m_flDefusingTalkTimer = 0x44 # GameTime_t + m_flC4PlantTalkTimer = 0x48 # GameTime_t + m_flRadioTokenSlots = 0x4C # GameTime_t[3] + m_bIgnoreRadio = 0x58 # bool + +class CCSPlayer_UseServices: + m_hLastKnownUseEntity = 0x40 # CHandle + m_flLastUseTimeStamp = 0x44 # GameTime_t + m_flTimeStartedHoldingUse = 0x48 # GameTime_t + m_flTimeLastUsedWindow = 0x4C # GameTime_t + +class CCSPlayer_ViewModelServices: + m_hViewModel = 0x40 # CHandle[3] + +class CCSPlayer_WaterServices: + m_NextDrownDamageTime = 0x40 # float + m_nDrownDmgRate = 0x44 # int32_t + m_AirFinishedTime = 0x48 # GameTime_t + m_flWaterJumpTime = 0x4C # float + m_vecWaterJumpVel = 0x50 # Vector + m_flSwimSoundTime = 0x5C # float + +class CCSPlayer_WeaponServices: + m_flNextAttack = 0xB0 # GameTime_t + m_bIsLookingAtWeapon = 0xB4 # bool + m_bIsHoldingLookAtWeapon = 0xB5 # bool + m_hSavedWeapon = 0xB8 # CHandle + m_nTimeToMelee = 0xBC # int32_t + m_nTimeToSecondary = 0xC0 # int32_t + m_nTimeToPrimary = 0xC4 # int32_t + m_nTimeToSniperRifle = 0xC8 # int32_t + m_bIsBeingGivenItem = 0xCC # bool + m_bIsPickingUpItemWithUse = 0xCD # bool + m_bPickedUpWeapon = 0xCE # bool + +class CCSTeam: + m_nLastRecievedShorthandedRoundBonus = 0x568 # int32_t + m_nShorthandedRoundBonusStartRound = 0x56C # int32_t + m_bSurrendered = 0x570 # bool + m_szTeamMatchStat = 0x571 # char[512] + m_numMapVictories = 0x774 # int32_t + m_scoreFirstHalf = 0x778 # int32_t + m_scoreSecondHalf = 0x77C # int32_t + m_scoreOvertime = 0x780 # int32_t + m_szClanTeamname = 0x784 # char[129] + m_iClanID = 0x808 # uint32_t + m_szTeamFlagImage = 0x80C # char[8] + m_szTeamLogoImage = 0x814 # char[8] + m_flNextResourceTime = 0x81C # float + m_iLastUpdateSentAt = 0x820 # int32_t + +class CCSWeaponBase: + m_bRemoveable = 0xC88 # bool + m_flFireSequenceStartTime = 0xC8C # float + m_nFireSequenceStartTimeChange = 0xC90 # int32_t + m_nFireSequenceStartTimeAck = 0xC94 # int32_t + m_bPlayerFireEventIsPrimary = 0xC98 # bool + m_seqIdle = 0xC9C # HSequence + m_seqFirePrimary = 0xCA0 # HSequence + m_seqFireSecondary = 0xCA4 # HSequence + m_bPlayerAmmoStockOnPickup = 0xCB0 # bool + m_bRequireUseToTouch = 0xCB1 # bool + m_iState = 0xCB4 # CSWeaponState_t + m_flLastTimeInAir = 0xCB8 # GameTime_t + m_flLastDeployTime = 0xCBC # GameTime_t + m_nViewModelIndex = 0xCC0 # uint32_t + m_bReloadsWithClips = 0xCC4 # bool + m_flTimeWeaponIdle = 0xCE0 # GameTime_t + m_bFireOnEmpty = 0xCE4 # bool + m_OnPlayerPickup = 0xCE8 # CEntityIOOutput + m_weaponMode = 0xD10 # CSWeaponMode + m_flTurningInaccuracyDelta = 0xD14 # float + m_vecTurningInaccuracyEyeDirLast = 0xD18 # Vector + m_flTurningInaccuracy = 0xD24 # float + m_fAccuracyPenalty = 0xD28 # float + m_flLastAccuracyUpdateTime = 0xD2C # GameTime_t + m_fAccuracySmoothedForZoom = 0xD30 # float + m_fScopeZoomEndTime = 0xD34 # GameTime_t + m_iRecoilIndex = 0xD38 # int32_t + m_flRecoilIndex = 0xD3C # float + m_bBurstMode = 0xD40 # bool + m_flPostponeFireReadyTime = 0xD44 # GameTime_t + m_bInReload = 0xD48 # bool + m_bReloadVisuallyComplete = 0xD49 # bool + m_flDroppedAtTime = 0xD4C # GameTime_t + m_bIsHauledBack = 0xD50 # bool + m_bSilencerOn = 0xD51 # bool + m_flTimeSilencerSwitchComplete = 0xD54 # GameTime_t + m_iOriginalTeamNumber = 0xD58 # int32_t + m_flNextAttackRenderTimeOffset = 0xD5C # float + m_bCanBePickedUp = 0xD68 # bool + m_bUseCanOverrideNextOwnerTouchTime = 0xD69 # bool + m_nextOwnerTouchTime = 0xD6C # GameTime_t + m_nextPrevOwnerTouchTime = 0xD70 # GameTime_t + m_hPrevOwner = 0xD74 # CHandle + m_nDropTick = 0xD78 # GameTick_t + m_donated = 0xD9C # bool + m_fLastShotTime = 0xDA0 # GameTime_t + m_bWasOwnedByCT = 0xDA4 # bool + m_bWasOwnedByTerrorist = 0xDA5 # bool + m_bFiredOutOfAmmoEvent = 0xDA6 # bool + m_numRemoveUnownedWeaponThink = 0xDA8 # int32_t + m_IronSightController = 0xDB0 # CIronSightController + m_iIronSightMode = 0xDC8 # int32_t + m_flLastLOSTraceFailureTime = 0xDCC # GameTime_t + m_iNumEmptyAttacks = 0xDD0 # int32_t + +class CCSWeaponBaseGun: + m_zoomLevel = 0xDD8 # int32_t + m_iBurstShotsRemaining = 0xDDC # int32_t + m_silencedModelIndex = 0xDE8 # int32_t + m_inPrecache = 0xDEC # bool + m_bNeedsBoltAction = 0xDED # bool + m_bSkillReloadAvailable = 0xDEE # bool + m_bSkillReloadLiftedReloadKey = 0xDEF # bool + m_bSkillBoltInterruptAvailable = 0xDF0 # bool + m_bSkillBoltLiftedFireKey = 0xDF1 # bool + +class CCSWeaponBaseVData: + m_WeaponType = 0x240 # CSWeaponType + m_WeaponCategory = 0x244 # CSWeaponCategory + m_szViewModel = 0x248 # CResourceNameTyped> + m_szPlayerModel = 0x328 # CResourceNameTyped> + m_szWorldDroppedModel = 0x408 # CResourceNameTyped> + m_szAimsightLensMaskModel = 0x4E8 # CResourceNameTyped> + m_szMagazineModel = 0x5C8 # CResourceNameTyped> + m_szHeatEffect = 0x6A8 # CResourceNameTyped> + m_szEjectBrassEffect = 0x788 # CResourceNameTyped> + m_szMuzzleFlashParticleAlt = 0x868 # CResourceNameTyped> + m_szMuzzleFlashThirdPersonParticle = 0x948 # CResourceNameTyped> + m_szMuzzleFlashThirdPersonParticleAlt = 0xA28 # CResourceNameTyped> + m_szTracerParticle = 0xB08 # CResourceNameTyped> + m_GearSlot = 0xBE8 # gear_slot_t + m_GearSlotPosition = 0xBEC # int32_t + m_DefaultLoadoutSlot = 0xBF0 # loadout_slot_t + m_sWrongTeamMsg = 0xBF8 # CUtlString + m_nPrice = 0xC00 # int32_t + m_nKillAward = 0xC04 # int32_t + m_nPrimaryReserveAmmoMax = 0xC08 # int32_t + m_nSecondaryReserveAmmoMax = 0xC0C # int32_t + m_bMeleeWeapon = 0xC10 # bool + m_bHasBurstMode = 0xC11 # bool + m_bIsRevolver = 0xC12 # bool + m_bCannotShootUnderwater = 0xC13 # bool + m_szName = 0xC18 # CUtlString + m_szAnimExtension = 0xC20 # CUtlString + m_eSilencerType = 0xC28 # CSWeaponSilencerType + m_nCrosshairMinDistance = 0xC2C # int32_t + m_nCrosshairDeltaDistance = 0xC30 # int32_t + m_flCycleTime = 0xC34 # CFiringModeFloat + m_flMaxSpeed = 0xC3C # CFiringModeFloat + m_flSpread = 0xC44 # CFiringModeFloat + m_flInaccuracyCrouch = 0xC4C # CFiringModeFloat + m_flInaccuracyStand = 0xC54 # CFiringModeFloat + m_flInaccuracyJump = 0xC5C # CFiringModeFloat + m_flInaccuracyLand = 0xC64 # CFiringModeFloat + m_flInaccuracyLadder = 0xC6C # CFiringModeFloat + m_flInaccuracyFire = 0xC74 # CFiringModeFloat + m_flInaccuracyMove = 0xC7C # CFiringModeFloat + m_flRecoilAngle = 0xC84 # CFiringModeFloat + m_flRecoilAngleVariance = 0xC8C # CFiringModeFloat + m_flRecoilMagnitude = 0xC94 # CFiringModeFloat + m_flRecoilMagnitudeVariance = 0xC9C # CFiringModeFloat + m_nTracerFrequency = 0xCA4 # CFiringModeInt + m_flInaccuracyJumpInitial = 0xCAC # float + m_flInaccuracyJumpApex = 0xCB0 # float + m_flInaccuracyReload = 0xCB4 # float + m_nRecoilSeed = 0xCB8 # int32_t + m_nSpreadSeed = 0xCBC # int32_t + m_flTimeToIdleAfterFire = 0xCC0 # float + m_flIdleInterval = 0xCC4 # float + m_flAttackMovespeedFactor = 0xCC8 # float + m_flHeatPerShot = 0xCCC # float + m_flInaccuracyPitchShift = 0xCD0 # float + m_flInaccuracyAltSoundThreshold = 0xCD4 # float + m_flBotAudibleRange = 0xCD8 # float + m_szUseRadioSubtitle = 0xCE0 # CUtlString + m_bUnzoomsAfterShot = 0xCE8 # bool + m_bHideViewModelWhenZoomed = 0xCE9 # bool + m_nZoomLevels = 0xCEC # int32_t + m_nZoomFOV1 = 0xCF0 # int32_t + m_nZoomFOV2 = 0xCF4 # int32_t + m_flZoomTime0 = 0xCF8 # float + m_flZoomTime1 = 0xCFC # float + m_flZoomTime2 = 0xD00 # float + m_flIronSightPullUpSpeed = 0xD04 # float + m_flIronSightPutDownSpeed = 0xD08 # float + m_flIronSightFOV = 0xD0C # float + m_flIronSightPivotForward = 0xD10 # float + m_flIronSightLooseness = 0xD14 # float + m_angPivotAngle = 0xD18 # QAngle + m_vecIronSightEyePos = 0xD24 # Vector + m_nDamage = 0xD30 # int32_t + m_flHeadshotMultiplier = 0xD34 # float + m_flArmorRatio = 0xD38 # float + m_flPenetration = 0xD3C # float + m_flRange = 0xD40 # float + m_flRangeModifier = 0xD44 # float + m_flFlinchVelocityModifierLarge = 0xD48 # float + m_flFlinchVelocityModifierSmall = 0xD4C # float + m_flRecoveryTimeCrouch = 0xD50 # float + m_flRecoveryTimeStand = 0xD54 # float + m_flRecoveryTimeCrouchFinal = 0xD58 # float + m_flRecoveryTimeStandFinal = 0xD5C # float + m_nRecoveryTransitionStartBullet = 0xD60 # int32_t + m_nRecoveryTransitionEndBullet = 0xD64 # int32_t + m_flThrowVelocity = 0xD68 # float + m_vSmokeColor = 0xD6C # Vector + m_szAnimClass = 0xD78 # CUtlString + +class CChangeLevel: + m_sMapName = 0x8A8 # CUtlString + m_sLandmarkName = 0x8B0 # CUtlString + m_OnChangeLevel = 0x8B8 # CEntityIOOutput + m_bTouched = 0x8E0 # bool + m_bNoTouch = 0x8E1 # bool + m_bNewChapter = 0x8E2 # bool + m_bOnChangeLevelFired = 0x8E3 # bool + +class CChicken: + m_AttributeManager = 0xB28 # CAttributeContainer + m_OriginalOwnerXuidLow = 0xDF0 # uint32_t + m_OriginalOwnerXuidHigh = 0xDF4 # uint32_t + m_updateTimer = 0xDF8 # CountdownTimer + m_stuckAnchor = 0xE10 # Vector + m_stuckTimer = 0xE20 # CountdownTimer + m_collisionStuckTimer = 0xE38 # CountdownTimer + m_isOnGround = 0xE50 # bool + m_vFallVelocity = 0xE54 # Vector + m_activity = 0xE60 # ChickenActivity + m_activityTimer = 0xE68 # CountdownTimer + m_turnRate = 0xE80 # float + m_fleeFrom = 0xE84 # CHandle + m_moveRateThrottleTimer = 0xE88 # CountdownTimer + m_startleTimer = 0xEA0 # CountdownTimer + m_vocalizeTimer = 0xEB8 # CountdownTimer + m_flWhenZombified = 0xED0 # GameTime_t + m_jumpedThisFrame = 0xED4 # bool + m_leader = 0xED8 # CHandle + m_reuseTimer = 0xEE0 # CountdownTimer + m_hasBeenUsed = 0xEF8 # bool + m_jumpTimer = 0xF00 # CountdownTimer + m_flLastJumpTime = 0xF18 # float + m_bInJump = 0xF1C # bool + m_isWaitingForLeader = 0xF1D # bool + m_repathTimer = 0x2F28 # CountdownTimer + m_inhibitDoorTimer = 0x2F40 # CountdownTimer + m_inhibitObstacleAvoidanceTimer = 0x2FD0 # CountdownTimer + m_vecPathGoal = 0x2FF0 # Vector + m_flActiveFollowStartTime = 0x2FFC # GameTime_t + m_followMinuteTimer = 0x3000 # CountdownTimer + m_vecLastEggPoopPosition = 0x3018 # Vector + m_vecEggsPooped = 0x3028 # CUtlVector> + m_BlockDirectionTimer = 0x3048 # CountdownTimer + +class CCollisionProperty: + m_collisionAttribute = 0x10 # VPhysicsCollisionAttribute_t + m_vecMins = 0x40 # Vector + m_vecMaxs = 0x4C # Vector + m_usSolidFlags = 0x5A # uint8_t + m_nSolidType = 0x5B # SolidType_t + m_triggerBloat = 0x5C # uint8_t + m_nSurroundType = 0x5D # SurroundingBoundsType_t + m_CollisionGroup = 0x5E # uint8_t + m_nEnablePhysics = 0x5F # uint8_t + m_flBoundingRadius = 0x60 # float + m_vecSpecifiedSurroundingMins = 0x64 # Vector + m_vecSpecifiedSurroundingMaxs = 0x70 # Vector + m_vecSurroundingMaxs = 0x7C # Vector + m_vecSurroundingMins = 0x88 # Vector + m_vCapsuleCenter1 = 0x94 # Vector + m_vCapsuleCenter2 = 0xA0 # Vector + m_flCapsuleRadius = 0xAC # float + +class CColorCorrection: + m_flFadeInDuration = 0x4B0 # float + m_flFadeOutDuration = 0x4B4 # float + m_flStartFadeInWeight = 0x4B8 # float + m_flStartFadeOutWeight = 0x4BC # float + m_flTimeStartFadeIn = 0x4C0 # GameTime_t + m_flTimeStartFadeOut = 0x4C4 # GameTime_t + m_flMaxWeight = 0x4C8 # float + m_bStartDisabled = 0x4CC # bool + m_bEnabled = 0x4CD # bool + m_bMaster = 0x4CE # bool + m_bClientSide = 0x4CF # bool + m_bExclusive = 0x4D0 # bool + m_MinFalloff = 0x4D4 # float + m_MaxFalloff = 0x4D8 # float + m_flCurWeight = 0x4DC # float + m_netlookupFilename = 0x4E0 # char[512] + m_lookupFilename = 0x6E0 # CUtlSymbolLarge + +class CColorCorrectionVolume: + m_bEnabled = 0x8A8 # bool + m_MaxWeight = 0x8AC # float + m_FadeDuration = 0x8B0 # float + m_bStartDisabled = 0x8B4 # bool + m_Weight = 0x8B8 # float + m_lookupFilename = 0x8BC # char[512] + m_LastEnterWeight = 0xABC # float + m_LastEnterTime = 0xAC0 # GameTime_t + m_LastExitWeight = 0xAC4 # float + m_LastExitTime = 0xAC8 # GameTime_t + +class CCommentaryAuto: + m_OnCommentaryNewGame = 0x4B0 # CEntityIOOutput + m_OnCommentaryMidGame = 0x4D8 # CEntityIOOutput + m_OnCommentaryMultiplayerSpawn = 0x500 # CEntityIOOutput + +class CCommentarySystem: + m_bCommentaryConvarsChanging = 0x11 # bool + m_bCommentaryEnabledMidGame = 0x12 # bool + m_flNextTeleportTime = 0x14 # GameTime_t + m_iTeleportStage = 0x18 # int32_t + m_bCheatState = 0x1C # bool + m_bIsFirstSpawnGroupToLoad = 0x1D # bool + m_hCurrentNode = 0x38 # CHandle + m_hActiveCommentaryNode = 0x3C # CHandle + m_hLastCommentaryNode = 0x40 # CHandle + m_vecNodes = 0x48 # CUtlVector> + +class CConstantForceController: + m_linear = 0xC # Vector + m_angular = 0x18 # RotationVector + m_linearSave = 0x24 # Vector + m_angularSave = 0x30 # RotationVector + +class CConstraintAnchor: + m_massScale = 0x890 # float + +class CCopyRecipientFilter: + m_Flags = 0x8 # int32_t + m_Recipients = 0x10 # CUtlVector + +class CCredits: + m_OnCreditsDone = 0x4B0 # CEntityIOOutput + m_bRolledOutroCredits = 0x4D8 # bool + m_flLogoLength = 0x4DC # float + +class CDamageRecord: + m_PlayerDamager = 0x28 # CHandle + m_PlayerRecipient = 0x2C # CHandle + m_hPlayerControllerDamager = 0x30 # CHandle + m_hPlayerControllerRecipient = 0x34 # CHandle + m_szPlayerDamagerName = 0x38 # CUtlString + m_szPlayerRecipientName = 0x40 # CUtlString + m_DamagerXuid = 0x48 # uint64_t + m_RecipientXuid = 0x50 # uint64_t + m_iDamage = 0x58 # int32_t + m_iActualHealthRemoved = 0x5C # int32_t + m_iNumHits = 0x60 # int32_t + m_iLastBulletUpdate = 0x64 # int32_t + m_bIsOtherEnemy = 0x68 # bool + m_killType = 0x69 # EKillTypes_t + +class CDebugHistory: + m_nNpcEvents = 0x44F0 # int32_t + +class CDecoyProjectile: + m_shotsRemaining = 0xA30 # int32_t + m_fExpireTime = 0xA34 # GameTime_t + m_decoyWeaponDefIndex = 0xA40 # uint16_t + +class CDynamicLight: + m_ActualFlags = 0x700 # uint8_t + m_Flags = 0x701 # uint8_t + m_LightStyle = 0x702 # uint8_t + m_On = 0x703 # bool + m_Radius = 0x704 # float + m_Exponent = 0x708 # int32_t + m_InnerAngle = 0x70C # float + m_OuterAngle = 0x710 # float + m_SpotRadius = 0x714 # float + +class CDynamicProp: + m_bCreateNavObstacle = 0xA10 # bool + m_bUseHitboxesForRenderBox = 0xA11 # bool + m_bUseAnimGraph = 0xA12 # bool + m_pOutputAnimBegun = 0xA18 # CEntityIOOutput + m_pOutputAnimOver = 0xA40 # CEntityIOOutput + m_pOutputAnimLoopCycleOver = 0xA68 # CEntityIOOutput + m_OnAnimReachedStart = 0xA90 # CEntityIOOutput + m_OnAnimReachedEnd = 0xAB8 # CEntityIOOutput + m_iszDefaultAnim = 0xAE0 # CUtlSymbolLarge + m_nDefaultAnimLoopMode = 0xAE8 # AnimLoopMode_t + m_bAnimateOnServer = 0xAEC # bool + m_bRandomizeCycle = 0xAED # bool + m_bStartDisabled = 0xAEE # bool + m_bScriptedMovement = 0xAEF # bool + m_bFiredStartEndOutput = 0xAF0 # bool + m_bForceNpcExclude = 0xAF1 # bool + m_bCreateNonSolid = 0xAF2 # bool + m_bIsOverrideProp = 0xAF3 # bool + m_iInitialGlowState = 0xAF4 # int32_t + m_nGlowRange = 0xAF8 # int32_t + m_nGlowRangeMin = 0xAFC # int32_t + m_glowColor = 0xB00 # Color + m_nGlowTeam = 0xB04 # int32_t + +class CEconEntity: + m_AttributeManager = 0x930 # CAttributeContainer + m_OriginalOwnerXuidLow = 0xBF8 # uint32_t + m_OriginalOwnerXuidHigh = 0xBFC # uint32_t + m_nFallbackPaintKit = 0xC00 # int32_t + m_nFallbackSeed = 0xC04 # int32_t + m_flFallbackWear = 0xC08 # float + m_nFallbackStatTrak = 0xC0C # int32_t + m_hOldProvidee = 0xC10 # CHandle + m_iOldOwnerClass = 0xC14 # int32_t + +class CEconItemAttribute: + m_iAttributeDefinitionIndex = 0x30 # uint16_t + m_flValue = 0x34 # float + m_flInitialValue = 0x38 # float + m_nRefundableCurrency = 0x3C # int32_t + m_bSetBonus = 0x40 # bool + +class CEconItemView: + m_iItemDefinitionIndex = 0x38 # uint16_t + m_iEntityQuality = 0x3C # int32_t + m_iEntityLevel = 0x40 # uint32_t + m_iItemID = 0x48 # uint64_t + m_iItemIDHigh = 0x50 # uint32_t + m_iItemIDLow = 0x54 # uint32_t + m_iAccountID = 0x58 # uint32_t + m_iInventoryPosition = 0x5C # uint32_t + m_bInitialized = 0x68 # bool + m_AttributeList = 0x70 # CAttributeList + m_NetworkedDynamicAttributes = 0xD0 # CAttributeList + m_szCustomName = 0x130 # char[161] + m_szCustomNameOverride = 0x1D1 # char[161] + +class CEconWearable: + m_nForceSkin = 0xC18 # int32_t + m_bAlwaysAllow = 0xC1C # bool + +class CEffectData: + m_vOrigin = 0x8 # Vector + m_vStart = 0x14 # Vector + m_vNormal = 0x20 # Vector + m_vAngles = 0x2C # QAngle + m_hEntity = 0x38 # CEntityHandle + m_hOtherEntity = 0x3C # CEntityHandle + m_flScale = 0x40 # float + m_flMagnitude = 0x44 # float + m_flRadius = 0x48 # float + m_nSurfaceProp = 0x4C # CUtlStringToken + m_nEffectIndex = 0x50 # CWeakHandle + m_nDamageType = 0x58 # uint32_t + m_nPenetrate = 0x5C # uint8_t + m_nMaterial = 0x5E # uint16_t + m_nHitBox = 0x60 # uint16_t + m_nColor = 0x62 # uint8_t + m_fFlags = 0x63 # uint8_t + m_nAttachmentIndex = 0x64 # AttachmentHandle_t + m_nAttachmentName = 0x68 # CUtlStringToken + m_iEffectName = 0x6C # uint16_t + m_nExplosionType = 0x6E # uint8_t + +class CEntityDissolve: + m_flFadeInStart = 0x700 # float + m_flFadeInLength = 0x704 # float + m_flFadeOutModelStart = 0x708 # float + m_flFadeOutModelLength = 0x70C # float + m_flFadeOutStart = 0x710 # float + m_flFadeOutLength = 0x714 # float + m_flStartTime = 0x718 # GameTime_t + m_nDissolveType = 0x71C # EntityDisolveType_t + m_vDissolverOrigin = 0x720 # Vector + m_nMagnitude = 0x72C # uint32_t + +class CEntityFlame: + m_hEntAttached = 0x4B0 # CHandle + m_bCheapEffect = 0x4B4 # bool + m_flSize = 0x4B8 # float + m_bUseHitboxes = 0x4BC # bool + m_iNumHitboxFires = 0x4C0 # int32_t + m_flHitboxFireScale = 0x4C4 # float + m_flLifetime = 0x4C8 # GameTime_t + m_hAttacker = 0x4CC # CHandle + m_iDangerSound = 0x4D0 # int32_t + m_flDirectDamagePerSecond = 0x4D4 # float + m_iCustomDamageType = 0x4D8 # int32_t + +class CEntityIdentity: + m_nameStringableIndex = 0x14 # int32_t + m_name = 0x18 # CUtlSymbolLarge + m_designerName = 0x20 # CUtlSymbolLarge + m_flags = 0x30 # uint32_t + m_worldGroupId = 0x38 # WorldGroupId_t + m_fDataObjectTypes = 0x3C # uint32_t + m_PathIndex = 0x40 # ChangeAccessorFieldPathIndex_t + m_pPrev = 0x58 # CEntityIdentity* + m_pNext = 0x60 # CEntityIdentity* + m_pPrevByClass = 0x68 # CEntityIdentity* + m_pNextByClass = 0x70 # CEntityIdentity* + +class CEntityInstance: + m_iszPrivateVScripts = 0x8 # CUtlSymbolLarge + m_pEntity = 0x10 # CEntityIdentity* + m_CScriptComponent = 0x28 # CScriptComponent* + +class CEnvBeam: + m_active = 0x7A0 # int32_t + m_spriteTexture = 0x7A8 # CStrongHandle + m_iszStartEntity = 0x7B0 # CUtlSymbolLarge + m_iszEndEntity = 0x7B8 # CUtlSymbolLarge + m_life = 0x7C0 # float + m_boltWidth = 0x7C4 # float + m_noiseAmplitude = 0x7C8 # float + m_speed = 0x7CC # int32_t + m_restrike = 0x7D0 # float + m_iszSpriteName = 0x7D8 # CUtlSymbolLarge + m_frameStart = 0x7E0 # int32_t + m_vEndPointWorld = 0x7E4 # Vector + m_vEndPointRelative = 0x7F0 # Vector + m_radius = 0x7FC # float + m_TouchType = 0x800 # Touch_t + m_iFilterName = 0x808 # CUtlSymbolLarge + m_hFilter = 0x810 # CHandle + m_iszDecal = 0x818 # CUtlSymbolLarge + m_OnTouchedByEntity = 0x820 # CEntityIOOutput + +class CEnvBeverage: + m_CanInDispenser = 0x4B0 # bool + m_nBeverageType = 0x4B4 # int32_t + +class CEnvCombinedLightProbeVolume: + m_Color = 0x1518 # Color + m_flBrightness = 0x151C # float + m_hCubemapTexture = 0x1520 # CStrongHandle + m_bCustomCubemapTexture = 0x1528 # bool + m_hLightProbeTexture = 0x1530 # CStrongHandle + m_hLightProbeDirectLightIndicesTexture = 0x1538 # CStrongHandle + m_hLightProbeDirectLightScalarsTexture = 0x1540 # CStrongHandle + m_hLightProbeDirectLightShadowsTexture = 0x1548 # CStrongHandle + m_vBoxMins = 0x1550 # Vector + m_vBoxMaxs = 0x155C # Vector + m_LightGroups = 0x1568 # CUtlSymbolLarge + m_bMoveable = 0x1570 # bool + m_nHandshake = 0x1574 # int32_t + m_nEnvCubeMapArrayIndex = 0x1578 # int32_t + m_nPriority = 0x157C # int32_t + m_bStartDisabled = 0x1580 # bool + m_flEdgeFadeDist = 0x1584 # float + m_vEdgeFadeDists = 0x1588 # Vector + m_nLightProbeSizeX = 0x1594 # int32_t + m_nLightProbeSizeY = 0x1598 # int32_t + m_nLightProbeSizeZ = 0x159C # int32_t + m_nLightProbeAtlasX = 0x15A0 # int32_t + m_nLightProbeAtlasY = 0x15A4 # int32_t + m_nLightProbeAtlasZ = 0x15A8 # int32_t + m_bEnabled = 0x15C1 # bool + +class CEnvCubemap: + m_hCubemapTexture = 0x538 # CStrongHandle + m_bCustomCubemapTexture = 0x540 # bool + m_flInfluenceRadius = 0x544 # float + m_vBoxProjectMins = 0x548 # Vector + m_vBoxProjectMaxs = 0x554 # Vector + m_LightGroups = 0x560 # CUtlSymbolLarge + m_bMoveable = 0x568 # bool + m_nHandshake = 0x56C # int32_t + m_nEnvCubeMapArrayIndex = 0x570 # int32_t + m_nPriority = 0x574 # int32_t + m_flEdgeFadeDist = 0x578 # float + m_vEdgeFadeDists = 0x57C # Vector + m_flDiffuseScale = 0x588 # float + m_bStartDisabled = 0x58C # bool + m_bDefaultEnvMap = 0x58D # bool + m_bDefaultSpecEnvMap = 0x58E # bool + m_bIndoorCubeMap = 0x58F # bool + m_bCopyDiffuseFromDefaultCubemap = 0x590 # bool + m_bEnabled = 0x5A0 # bool + +class CEnvCubemapFog: + m_flEndDistance = 0x4B0 # float + m_flStartDistance = 0x4B4 # float + m_flFogFalloffExponent = 0x4B8 # float + m_bHeightFogEnabled = 0x4BC # bool + m_flFogHeightWidth = 0x4C0 # float + m_flFogHeightEnd = 0x4C4 # float + m_flFogHeightStart = 0x4C8 # float + m_flFogHeightExponent = 0x4CC # float + m_flLODBias = 0x4D0 # float + m_bActive = 0x4D4 # bool + m_bStartDisabled = 0x4D5 # bool + m_flFogMaxOpacity = 0x4D8 # float + m_nCubemapSourceType = 0x4DC # int32_t + m_hSkyMaterial = 0x4E0 # CStrongHandle + m_iszSkyEntity = 0x4E8 # CUtlSymbolLarge + m_hFogCubemapTexture = 0x4F0 # CStrongHandle + m_bHasHeightFogEnd = 0x4F8 # bool + m_bFirstTime = 0x4F9 # bool + +class CEnvDecal: + m_hDecalMaterial = 0x700 # CStrongHandle + m_flWidth = 0x708 # float + m_flHeight = 0x70C # float + m_flDepth = 0x710 # float + m_nRenderOrder = 0x714 # uint32_t + m_bProjectOnWorld = 0x718 # bool + m_bProjectOnCharacters = 0x719 # bool + m_bProjectOnWater = 0x71A # bool + m_flDepthSortBias = 0x71C # float + +class CEnvDetailController: + m_flFadeStartDist = 0x4B0 # float + m_flFadeEndDist = 0x4B4 # float + +class CEnvEntityIgniter: + m_flLifetime = 0x4B0 # float + +class CEnvEntityMaker: + m_vecEntityMins = 0x4B0 # Vector + m_vecEntityMaxs = 0x4BC # Vector + m_hCurrentInstance = 0x4C8 # CHandle + m_hCurrentBlocker = 0x4CC # CHandle + m_vecBlockerOrigin = 0x4D0 # Vector + m_angPostSpawnDirection = 0x4DC # QAngle + m_flPostSpawnDirectionVariance = 0x4E8 # float + m_flPostSpawnSpeed = 0x4EC # float + m_bPostSpawnUseAngles = 0x4F0 # bool + m_iszTemplate = 0x4F8 # CUtlSymbolLarge + m_pOutputOnSpawned = 0x500 # CEntityIOOutput + m_pOutputOnFailedSpawn = 0x528 # CEntityIOOutput + +class CEnvExplosion: + m_iMagnitude = 0x700 # int32_t + m_flPlayerDamage = 0x704 # float + m_iRadiusOverride = 0x708 # int32_t + m_flInnerRadius = 0x70C # float + m_spriteScale = 0x710 # int32_t + m_flDamageForce = 0x714 # float + m_hInflictor = 0x718 # CHandle + m_iCustomDamageType = 0x71C # int32_t + m_iszExplosionType = 0x728 # CUtlSymbolLarge + m_iszCustomEffectName = 0x730 # CUtlSymbolLarge + m_iszCustomSoundName = 0x738 # CUtlSymbolLarge + m_iClassIgnore = 0x740 # Class_T + m_iClassIgnore2 = 0x744 # Class_T + m_iszEntityIgnoreName = 0x748 # CUtlSymbolLarge + m_hEntityIgnore = 0x750 # CHandle + +class CEnvFade: + m_fadeColor = 0x4B0 # Color + m_Duration = 0x4B4 # float + m_HoldDuration = 0x4B8 # float + m_OnBeginFade = 0x4C0 # CEntityIOOutput + +class CEnvFireSensor: + m_bEnabled = 0x4B0 # bool + m_bHeatAtLevel = 0x4B1 # bool + m_radius = 0x4B4 # float + m_targetLevel = 0x4B8 # float + m_targetTime = 0x4BC # float + m_levelTime = 0x4C0 # float + m_OnHeatLevelStart = 0x4C8 # CEntityIOOutput + m_OnHeatLevelEnd = 0x4F0 # CEntityIOOutput + +class CEnvFireSource: + m_bEnabled = 0x4B0 # bool + m_radius = 0x4B4 # float + m_damage = 0x4B8 # float + +class CEnvGlobal: + m_outCounter = 0x4B0 # CEntityOutputTemplate + m_globalstate = 0x4D8 # CUtlSymbolLarge + m_triggermode = 0x4E0 # int32_t + m_initialstate = 0x4E4 # int32_t + m_counter = 0x4E8 # int32_t + +class CEnvHudHint: + m_iszMessage = 0x4B0 # CUtlSymbolLarge + +class CEnvInstructorHint: + m_iszName = 0x4B0 # CUtlSymbolLarge + m_iszReplace_Key = 0x4B8 # CUtlSymbolLarge + m_iszHintTargetEntity = 0x4C0 # CUtlSymbolLarge + m_iTimeout = 0x4C8 # int32_t + m_iDisplayLimit = 0x4CC # int32_t + m_iszIcon_Onscreen = 0x4D0 # CUtlSymbolLarge + m_iszIcon_Offscreen = 0x4D8 # CUtlSymbolLarge + m_iszCaption = 0x4E0 # CUtlSymbolLarge + m_iszActivatorCaption = 0x4E8 # CUtlSymbolLarge + m_Color = 0x4F0 # Color + m_fIconOffset = 0x4F4 # float + m_fRange = 0x4F8 # float + m_iPulseOption = 0x4FC # uint8_t + m_iAlphaOption = 0x4FD # uint8_t + m_iShakeOption = 0x4FE # uint8_t + m_bStatic = 0x4FF # bool + m_bNoOffscreen = 0x500 # bool + m_bForceCaption = 0x501 # bool + m_iInstanceType = 0x504 # int32_t + m_bSuppressRest = 0x508 # bool + m_iszBinding = 0x510 # CUtlSymbolLarge + m_bAllowNoDrawTarget = 0x518 # bool + m_bAutoStart = 0x519 # bool + m_bLocalPlayerOnly = 0x51A # bool + +class CEnvInstructorVRHint: + m_iszName = 0x4B0 # CUtlSymbolLarge + m_iszHintTargetEntity = 0x4B8 # CUtlSymbolLarge + m_iTimeout = 0x4C0 # int32_t + m_iszCaption = 0x4C8 # CUtlSymbolLarge + m_iszStartSound = 0x4D0 # CUtlSymbolLarge + m_iLayoutFileType = 0x4D8 # int32_t + m_iszCustomLayoutFile = 0x4E0 # CUtlSymbolLarge + m_iAttachType = 0x4E8 # int32_t + m_flHeightOffset = 0x4EC # float + +class CEnvLaser: + m_iszLaserTarget = 0x7A0 # CUtlSymbolLarge + m_pSprite = 0x7A8 # CSprite* + m_iszSpriteName = 0x7B0 # CUtlSymbolLarge + m_firePosition = 0x7B8 # Vector + m_flStartFrame = 0x7C4 # float + +class CEnvLightProbeVolume: + m_hLightProbeTexture = 0x1490 # CStrongHandle + m_hLightProbeDirectLightIndicesTexture = 0x1498 # CStrongHandle + m_hLightProbeDirectLightScalarsTexture = 0x14A0 # CStrongHandle + m_hLightProbeDirectLightShadowsTexture = 0x14A8 # CStrongHandle + m_vBoxMins = 0x14B0 # Vector + m_vBoxMaxs = 0x14BC # Vector + m_LightGroups = 0x14C8 # CUtlSymbolLarge + m_bMoveable = 0x14D0 # bool + m_nHandshake = 0x14D4 # int32_t + m_nPriority = 0x14D8 # int32_t + m_bStartDisabled = 0x14DC # bool + m_nLightProbeSizeX = 0x14E0 # int32_t + m_nLightProbeSizeY = 0x14E4 # int32_t + m_nLightProbeSizeZ = 0x14E8 # int32_t + m_nLightProbeAtlasX = 0x14EC # int32_t + m_nLightProbeAtlasY = 0x14F0 # int32_t + m_nLightProbeAtlasZ = 0x14F4 # int32_t + m_bEnabled = 0x1501 # bool + +class CEnvMicrophone: + m_bDisabled = 0x4B0 # bool + m_hMeasureTarget = 0x4B4 # CHandle + m_nSoundMask = 0x4B8 # int32_t + m_flSensitivity = 0x4BC # float + m_flSmoothFactor = 0x4C0 # float + m_flMaxRange = 0x4C4 # float + m_iszSpeakerName = 0x4C8 # CUtlSymbolLarge + m_hSpeaker = 0x4D0 # CHandle + m_bAvoidFeedback = 0x4D4 # bool + m_iSpeakerDSPPreset = 0x4D8 # int32_t + m_iszListenFilter = 0x4E0 # CUtlSymbolLarge + m_hListenFilter = 0x4E8 # CHandle + m_SoundLevel = 0x4F0 # CEntityOutputTemplate + m_OnRoutedSound = 0x518 # CEntityIOOutput + m_OnHeardSound = 0x540 # CEntityIOOutput + m_szLastSound = 0x568 # char[256] + m_iLastRoutedFrame = 0x668 # int32_t + +class CEnvMuzzleFlash: + m_flScale = 0x4B0 # float + m_iszParentAttachment = 0x4B8 # CUtlSymbolLarge + +class CEnvParticleGlow: + m_flAlphaScale = 0xC78 # float + m_flRadiusScale = 0xC7C # float + m_flSelfIllumScale = 0xC80 # float + m_ColorTint = 0xC84 # Color + m_hTextureOverride = 0xC88 # CStrongHandle + +class CEnvProjectedTexture: + m_hTargetEntity = 0x700 # CHandle + m_bState = 0x704 # bool + m_bAlwaysUpdate = 0x705 # bool + m_flLightFOV = 0x708 # float + m_bEnableShadows = 0x70C # bool + m_bSimpleProjection = 0x70D # bool + m_bLightOnlyTarget = 0x70E # bool + m_bLightWorld = 0x70F # bool + m_bCameraSpace = 0x710 # bool + m_flBrightnessScale = 0x714 # float + m_LightColor = 0x718 # Color + m_flIntensity = 0x71C # float + m_flLinearAttenuation = 0x720 # float + m_flQuadraticAttenuation = 0x724 # float + m_bVolumetric = 0x728 # bool + m_flNoiseStrength = 0x72C # float + m_flFlashlightTime = 0x730 # float + m_nNumPlanes = 0x734 # uint32_t + m_flPlaneOffset = 0x738 # float + m_flVolumetricIntensity = 0x73C # float + m_flColorTransitionTime = 0x740 # float + m_flAmbient = 0x744 # float + m_SpotlightTextureName = 0x748 # char[512] + m_nSpotlightTextureFrame = 0x948 # int32_t + m_nShadowQuality = 0x94C # uint32_t + m_flNearZ = 0x950 # float + m_flFarZ = 0x954 # float + m_flProjectionSize = 0x958 # float + m_flRotation = 0x95C # float + m_bFlipHorizontal = 0x960 # bool + +class CEnvScreenOverlay: + m_iszOverlayNames = 0x4B0 # CUtlSymbolLarge[10] + m_flOverlayTimes = 0x500 # float[10] + m_flStartTime = 0x528 # GameTime_t + m_iDesiredOverlay = 0x52C # int32_t + m_bIsActive = 0x530 # bool + +class CEnvShake: + m_limitToEntity = 0x4B0 # CUtlSymbolLarge + m_Amplitude = 0x4B8 # float + m_Frequency = 0x4BC # float + m_Duration = 0x4C0 # float + m_Radius = 0x4C4 # float + m_stopTime = 0x4C8 # GameTime_t + m_nextShake = 0x4CC # GameTime_t + m_currentAmp = 0x4D0 # float + m_maxForce = 0x4D4 # Vector + m_shakeCallback = 0x4E8 # CPhysicsShake + +class CEnvSky: + m_hSkyMaterial = 0x700 # CStrongHandle + m_hSkyMaterialLightingOnly = 0x708 # CStrongHandle + m_bStartDisabled = 0x710 # bool + m_vTintColor = 0x711 # Color + m_vTintColorLightingOnly = 0x715 # Color + m_flBrightnessScale = 0x71C # float + m_nFogType = 0x720 # int32_t + m_flFogMinStart = 0x724 # float + m_flFogMinEnd = 0x728 # float + m_flFogMaxStart = 0x72C # float + m_flFogMaxEnd = 0x730 # float + m_bEnabled = 0x734 # bool + +class CEnvSoundscape: + m_OnPlay = 0x4B0 # CEntityIOOutput + m_flRadius = 0x4D8 # float + m_soundscapeName = 0x4E0 # CUtlSymbolLarge + m_soundEventName = 0x4E8 # CUtlSymbolLarge + m_bOverrideWithEvent = 0x4F0 # bool + m_soundscapeIndex = 0x4F4 # int32_t + m_soundscapeEntityListId = 0x4F8 # int32_t + m_soundEventHash = 0x4FC # uint32_t + m_positionNames = 0x500 # CUtlSymbolLarge[8] + m_hProxySoundscape = 0x540 # CHandle + m_bDisabled = 0x544 # bool + +class CEnvSoundscapeProxy: + m_MainSoundscapeName = 0x548 # CUtlSymbolLarge + +class CEnvSpark: + m_flDelay = 0x4B0 # float + m_nMagnitude = 0x4B4 # int32_t + m_nTrailLength = 0x4B8 # int32_t + m_nType = 0x4BC # int32_t + m_OnSpark = 0x4C0 # CEntityIOOutput + +class CEnvSplash: + m_flScale = 0x4B0 # float + +class CEnvTilt: + m_Duration = 0x4B0 # float + m_Radius = 0x4B4 # float + m_TiltTime = 0x4B8 # float + m_stopTime = 0x4BC # GameTime_t + +class CEnvTracer: + m_vecEnd = 0x4B0 # Vector + m_flDelay = 0x4BC # float + +class CEnvViewPunch: + m_flRadius = 0x4B0 # float + m_angViewPunch = 0x4B4 # QAngle + +class CEnvVolumetricFogController: + m_flScattering = 0x4B0 # float + m_flAnisotropy = 0x4B4 # float + m_flFadeSpeed = 0x4B8 # float + m_flDrawDistance = 0x4BC # float + m_flFadeInStart = 0x4C0 # float + m_flFadeInEnd = 0x4C4 # float + m_flIndirectStrength = 0x4C8 # float + m_nIndirectTextureDimX = 0x4CC # int32_t + m_nIndirectTextureDimY = 0x4D0 # int32_t + m_nIndirectTextureDimZ = 0x4D4 # int32_t + m_vBoxMins = 0x4D8 # Vector + m_vBoxMaxs = 0x4E4 # Vector + m_bActive = 0x4F0 # bool + m_flStartAnisoTime = 0x4F4 # GameTime_t + m_flStartScatterTime = 0x4F8 # GameTime_t + m_flStartDrawDistanceTime = 0x4FC # GameTime_t + m_flStartAnisotropy = 0x500 # float + m_flStartScattering = 0x504 # float + m_flStartDrawDistance = 0x508 # float + m_flDefaultAnisotropy = 0x50C # float + m_flDefaultScattering = 0x510 # float + m_flDefaultDrawDistance = 0x514 # float + m_bStartDisabled = 0x518 # bool + m_bEnableIndirect = 0x519 # bool + m_bIsMaster = 0x51A # bool + m_hFogIndirectTexture = 0x520 # CStrongHandle + m_nForceRefreshCount = 0x528 # int32_t + m_bFirstTime = 0x52C # bool + +class CEnvVolumetricFogVolume: + m_bActive = 0x4B0 # bool + m_vBoxMins = 0x4B4 # Vector + m_vBoxMaxs = 0x4C0 # Vector + m_bStartDisabled = 0x4CC # bool + m_flStrength = 0x4D0 # float + m_nFalloffShape = 0x4D4 # int32_t + m_flFalloffExponent = 0x4D8 # float + +class CEnvWind: + m_EnvWindShared = 0x4B0 # CEnvWindShared + +class CEnvWindShared: + m_flStartTime = 0x8 # GameTime_t + m_iWindSeed = 0xC # uint32_t + m_iMinWind = 0x10 # uint16_t + m_iMaxWind = 0x12 # uint16_t + m_windRadius = 0x14 # int32_t + m_iMinGust = 0x18 # uint16_t + m_iMaxGust = 0x1A # uint16_t + m_flMinGustDelay = 0x1C # float + m_flMaxGustDelay = 0x20 # float + m_flGustDuration = 0x24 # float + m_iGustDirChange = 0x28 # uint16_t + m_location = 0x2C # Vector + m_iszGustSound = 0x38 # int32_t + m_iWindDir = 0x3C # int32_t + m_flWindSpeed = 0x40 # float + m_currentWindVector = 0x44 # Vector + m_CurrentSwayVector = 0x50 # Vector + m_PrevSwayVector = 0x5C # Vector + m_iInitialWindDir = 0x68 # uint16_t + m_flInitialWindSpeed = 0x6C # float + m_OnGustStart = 0x70 # CEntityIOOutput + m_OnGustEnd = 0x98 # CEntityIOOutput + m_flVariationTime = 0xC0 # GameTime_t + m_flSwayTime = 0xC4 # GameTime_t + m_flSimTime = 0xC8 # GameTime_t + m_flSwitchTime = 0xCC # GameTime_t + m_flAveWindSpeed = 0xD0 # float + m_bGusting = 0xD4 # bool + m_flWindAngleVariation = 0xD8 # float + m_flWindSpeedVariation = 0xDC # float + m_iEntIndex = 0xE0 # CEntityIndex + +class CEnvWindShared_WindAveEvent_t: + m_flStartWindSpeed = 0x0 # float + m_flAveWindSpeed = 0x4 # float + +class CEnvWindShared_WindVariationEvent_t: + m_flWindAngleVariation = 0x0 # float + m_flWindSpeedVariation = 0x4 # float + +class CFilterAttributeInt: + m_sAttributeName = 0x508 # CUtlStringToken + +class CFilterClass: + m_iFilterClass = 0x508 # CUtlSymbolLarge + +class CFilterContext: + m_iFilterContext = 0x508 # CUtlSymbolLarge + +class CFilterEnemy: + m_iszEnemyName = 0x508 # CUtlSymbolLarge + m_flRadius = 0x510 # float + m_flOuterRadius = 0x514 # float + m_nMaxSquadmatesPerEnemy = 0x518 # int32_t + m_iszPlayerName = 0x520 # CUtlSymbolLarge + +class CFilterMassGreater: + m_fFilterMass = 0x508 # float + +class CFilterModel: + m_iFilterModel = 0x508 # CUtlSymbolLarge + +class CFilterMultiple: + m_nFilterType = 0x508 # filter_t + m_iFilterName = 0x510 # CUtlSymbolLarge[10] + m_hFilter = 0x560 # CHandle[10] + m_nFilterCount = 0x588 # int32_t + +class CFilterName: + m_iFilterName = 0x508 # CUtlSymbolLarge + +class CFilterProximity: + m_flRadius = 0x508 # float + +class CFire: + m_hEffect = 0x700 # CHandle + m_hOwner = 0x704 # CHandle + m_nFireType = 0x708 # int32_t + m_flFuel = 0x70C # float + m_flDamageTime = 0x710 # GameTime_t + m_lastDamage = 0x714 # GameTime_t + m_flFireSize = 0x718 # float + m_flLastNavUpdateTime = 0x71C # GameTime_t + m_flHeatLevel = 0x720 # float + m_flHeatAbsorb = 0x724 # float + m_flDamageScale = 0x728 # float + m_flMaxHeat = 0x72C # float + m_flLastHeatLevel = 0x730 # float + m_flAttackTime = 0x734 # float + m_bEnabled = 0x738 # bool + m_bStartDisabled = 0x739 # bool + m_bDidActivate = 0x73A # bool + m_OnIgnited = 0x740 # CEntityIOOutput + m_OnExtinguished = 0x768 # CEntityIOOutput + +class CFireSmoke: + m_nFlameModelIndex = 0x4C0 # int32_t + m_nFlameFromAboveModelIndex = 0x4C4 # int32_t + +class CFiringModeFloat: + m_flValues = 0x0 # float[2] + +class CFiringModeInt: + m_nValues = 0x0 # int32_t[2] + +class CFish: + m_pool = 0x890 # CHandle + m_id = 0x894 # uint32_t + m_x = 0x898 # float + m_y = 0x89C # float + m_z = 0x8A0 # float + m_angle = 0x8A4 # float + m_angleChange = 0x8A8 # float + m_forward = 0x8AC # Vector + m_perp = 0x8B8 # Vector + m_poolOrigin = 0x8C4 # Vector + m_waterLevel = 0x8D0 # float + m_speed = 0x8D4 # float + m_desiredSpeed = 0x8D8 # float + m_calmSpeed = 0x8DC # float + m_panicSpeed = 0x8E0 # float + m_avoidRange = 0x8E4 # float + m_turnTimer = 0x8E8 # CountdownTimer + m_turnClockwise = 0x900 # bool + m_goTimer = 0x908 # CountdownTimer + m_moveTimer = 0x920 # CountdownTimer + m_panicTimer = 0x938 # CountdownTimer + m_disperseTimer = 0x950 # CountdownTimer + m_proximityTimer = 0x968 # CountdownTimer + m_visible = 0x980 # CUtlVector + +class CFishPool: + m_fishCount = 0x4C0 # int32_t + m_maxRange = 0x4C4 # float + m_swimDepth = 0x4C8 # float + m_waterLevel = 0x4CC # float + m_isDormant = 0x4D0 # bool + m_fishes = 0x4D8 # CUtlVector> + m_visTimer = 0x4F0 # CountdownTimer + +class CFists: + m_bPlayingUninterruptableAct = 0xDD8 # bool + m_nUninterruptableActivity = 0xDDC # PlayerAnimEvent_t + m_bRestorePrevWep = 0xDE0 # bool + m_hWeaponBeforePrevious = 0xDE4 # CHandle + m_hWeaponPrevious = 0xDE8 # CHandle + m_bDelayedHardPunchIncoming = 0xDEC # bool + m_bDestroyAfterTaunt = 0xDED # bool + +class CFlashbangProjectile: + m_flTimeToDetonate = 0xA28 # float + m_numOpponentsHit = 0xA2C # uint8_t + m_numTeammatesHit = 0xA2D # uint8_t + +class CFogController: + m_fog = 0x4B0 # fogparams_t + m_bUseAngles = 0x518 # bool + m_iChangedVariables = 0x51C # int32_t + +class CFogTrigger: + m_fog = 0x8A8 # fogparams_t + +class CFogVolume: + m_fogName = 0x700 # CUtlSymbolLarge + m_postProcessName = 0x708 # CUtlSymbolLarge + m_colorCorrectionName = 0x710 # CUtlSymbolLarge + m_bDisabled = 0x720 # bool + m_bInFogVolumesList = 0x721 # bool + +class CFootstepControl: + m_source = 0x8A8 # CUtlSymbolLarge + m_destination = 0x8B0 # CUtlSymbolLarge + +class CFuncBrush: + m_iSolidity = 0x700 # BrushSolidities_e + m_iDisabled = 0x704 # int32_t + m_bSolidBsp = 0x708 # bool + m_iszExcludedClass = 0x710 # CUtlSymbolLarge + m_bInvertExclusion = 0x718 # bool + m_bScriptedMovement = 0x719 # bool + +class CFuncConveyor: + m_szConveyorModels = 0x700 # CUtlSymbolLarge + m_flTransitionDurationSeconds = 0x708 # float + m_angMoveEntitySpace = 0x70C # QAngle + m_vecMoveDirEntitySpace = 0x718 # Vector + m_flTargetSpeed = 0x724 # float + m_nTransitionStartTick = 0x728 # GameTick_t + m_nTransitionDurationTicks = 0x72C # int32_t + m_flTransitionStartSpeed = 0x730 # float + m_hConveyorModels = 0x738 # CNetworkUtlVectorBase> + +class CFuncElectrifiedVolume: + m_EffectName = 0x720 # CUtlSymbolLarge + m_EffectInterpenetrateName = 0x728 # CUtlSymbolLarge + m_EffectZapName = 0x730 # CUtlSymbolLarge + m_iszEffectSource = 0x738 # CUtlSymbolLarge + +class CFuncInteractionLayerClip: + m_bDisabled = 0x700 # bool + m_iszInteractsAs = 0x708 # CUtlSymbolLarge + m_iszInteractsWith = 0x710 # CUtlSymbolLarge + +class CFuncLadder: + m_vecLadderDir = 0x700 # Vector + m_Dismounts = 0x710 # CUtlVector> + m_vecLocalTop = 0x728 # Vector + m_vecPlayerMountPositionTop = 0x734 # Vector + m_vecPlayerMountPositionBottom = 0x740 # Vector + m_flAutoRideSpeed = 0x74C # float + m_bDisabled = 0x750 # bool + m_bFakeLadder = 0x751 # bool + m_bHasSlack = 0x752 # bool + m_surfacePropName = 0x758 # CUtlSymbolLarge + m_OnPlayerGotOnLadder = 0x760 # CEntityIOOutput + m_OnPlayerGotOffLadder = 0x788 # CEntityIOOutput + +class CFuncMonitor: + m_targetCamera = 0x720 # CUtlString + m_nResolutionEnum = 0x728 # int32_t + m_bRenderShadows = 0x72C # bool + m_bUseUniqueColorTarget = 0x72D # bool + m_brushModelName = 0x730 # CUtlString + m_hTargetCamera = 0x738 # CHandle + m_bEnabled = 0x73C # bool + m_bDraw3DSkybox = 0x73D # bool + m_bStartEnabled = 0x73E # bool + +class CFuncMoveLinear: + m_authoredPosition = 0x780 # MoveLinearAuthoredPos_t + m_angMoveEntitySpace = 0x784 # QAngle + m_vecMoveDirParentSpace = 0x790 # Vector + m_soundStart = 0x7A0 # CUtlSymbolLarge + m_soundStop = 0x7A8 # CUtlSymbolLarge + m_currentSound = 0x7B0 # CUtlSymbolLarge + m_flBlockDamage = 0x7B8 # float + m_flStartPosition = 0x7BC # float + m_flMoveDistance = 0x7C0 # float + m_OnFullyOpen = 0x7D0 # CEntityIOOutput + m_OnFullyClosed = 0x7F8 # CEntityIOOutput + m_bCreateMovableNavMesh = 0x820 # bool + m_bCreateNavObstacle = 0x821 # bool + +class CFuncNavBlocker: + m_bDisabled = 0x700 # bool + m_nBlockedTeamNumber = 0x704 # int32_t + +class CFuncNavObstruction: + m_bDisabled = 0x708 # bool + +class CFuncPlat: + m_sNoise = 0x7A8 # CUtlSymbolLarge + +class CFuncPlatRot: + m_end = 0x7B0 # QAngle + m_start = 0x7BC # QAngle + +class CFuncRotating: + m_vecMoveAng = 0x700 # QAngle + m_flFanFriction = 0x70C # float + m_flAttenuation = 0x710 # float + m_flVolume = 0x714 # float + m_flTargetSpeed = 0x718 # float + m_flMaxSpeed = 0x71C # float + m_flBlockDamage = 0x720 # float + m_flTimeScale = 0x724 # float + m_NoiseRunning = 0x728 # CUtlSymbolLarge + m_bReversed = 0x730 # bool + m_angStart = 0x73C # QAngle + m_bStopAtStartPos = 0x748 # bool + m_vecClientOrigin = 0x74C # Vector + m_vecClientAngles = 0x758 # QAngle + +class CFuncShatterglass: + m_hGlassMaterialDamaged = 0x700 # CStrongHandle + m_hGlassMaterialUndamaged = 0x708 # CStrongHandle + m_hConcreteMaterialEdgeFace = 0x710 # CStrongHandle + m_hConcreteMaterialEdgeCaps = 0x718 # CStrongHandle + m_hConcreteMaterialEdgeFins = 0x720 # CStrongHandle + m_matPanelTransform = 0x728 # matrix3x4_t + m_matPanelTransformWsTemp = 0x758 # matrix3x4_t + m_vecShatterGlassShards = 0x788 # CUtlVector + m_PanelSize = 0x7A0 # Vector2D + m_vecPanelNormalWs = 0x7A8 # Vector + m_nNumShardsEverCreated = 0x7B4 # int32_t + m_flLastShatterSoundEmitTime = 0x7B8 # GameTime_t + m_flLastCleanupTime = 0x7BC # GameTime_t + m_flInitAtTime = 0x7C0 # GameTime_t + m_flGlassThickness = 0x7C4 # float + m_flSpawnInvulnerability = 0x7C8 # float + m_bBreakSilent = 0x7CC # bool + m_bBreakShardless = 0x7CD # bool + m_bBroken = 0x7CE # bool + m_bHasRateLimitedShards = 0x7CF # bool + m_bGlassNavIgnore = 0x7D0 # bool + m_bGlassInFrame = 0x7D1 # bool + m_bStartBroken = 0x7D2 # bool + m_iInitialDamageType = 0x7D3 # uint8_t + m_szDamagePositioningEntityName01 = 0x7D8 # CUtlSymbolLarge + m_szDamagePositioningEntityName02 = 0x7E0 # CUtlSymbolLarge + m_szDamagePositioningEntityName03 = 0x7E8 # CUtlSymbolLarge + m_szDamagePositioningEntityName04 = 0x7F0 # CUtlSymbolLarge + m_vInitialDamagePositions = 0x7F8 # CUtlVector + m_vExtraDamagePositions = 0x810 # CUtlVector + m_OnBroken = 0x828 # CEntityIOOutput + m_iSurfaceType = 0x851 # uint8_t + +class CFuncTankTrain: + m_OnDeath = 0x850 # CEntityIOOutput + +class CFuncTimescale: + m_flDesiredTimescale = 0x4B0 # float + m_flAcceleration = 0x4B4 # float + m_flMinBlendRate = 0x4B8 # float + m_flBlendDeltaMultiplier = 0x4BC # float + m_isStarted = 0x4C0 # bool + +class CFuncTrackChange: + m_trackTop = 0x7C8 # CPathTrack* + m_trackBottom = 0x7D0 # CPathTrack* + m_train = 0x7D8 # CFuncTrackTrain* + m_trackTopName = 0x7E0 # CUtlSymbolLarge + m_trackBottomName = 0x7E8 # CUtlSymbolLarge + m_trainName = 0x7F0 # CUtlSymbolLarge + m_code = 0x7F8 # TRAIN_CODE + m_targetState = 0x7FC # int32_t + m_use = 0x800 # int32_t + +class CFuncTrackTrain: + m_ppath = 0x700 # CHandle + m_length = 0x704 # float + m_vPosPrev = 0x708 # Vector + m_angPrev = 0x714 # QAngle + m_controlMins = 0x720 # Vector + m_controlMaxs = 0x72C # Vector + m_lastBlockPos = 0x738 # Vector + m_lastBlockTick = 0x744 # int32_t + m_flVolume = 0x748 # float + m_flBank = 0x74C # float + m_oldSpeed = 0x750 # float + m_flBlockDamage = 0x754 # float + m_height = 0x758 # float + m_maxSpeed = 0x75C # float + m_dir = 0x760 # float + m_iszSoundMove = 0x768 # CUtlSymbolLarge + m_iszSoundMovePing = 0x770 # CUtlSymbolLarge + m_iszSoundStart = 0x778 # CUtlSymbolLarge + m_iszSoundStop = 0x780 # CUtlSymbolLarge + m_strPathTarget = 0x788 # CUtlSymbolLarge + m_flMoveSoundMinDuration = 0x790 # float + m_flMoveSoundMaxDuration = 0x794 # float + m_flNextMoveSoundTime = 0x798 # GameTime_t + m_flMoveSoundMinPitch = 0x79C # float + m_flMoveSoundMaxPitch = 0x7A0 # float + m_eOrientationType = 0x7A4 # TrainOrientationType_t + m_eVelocityType = 0x7A8 # TrainVelocityType_t + m_OnStart = 0x7B8 # CEntityIOOutput + m_OnNext = 0x7E0 # CEntityIOOutput + m_OnArrivedAtDestinationNode = 0x808 # CEntityIOOutput + m_bManualSpeedChanges = 0x830 # bool + m_flDesiredSpeed = 0x834 # float + m_flSpeedChangeTime = 0x838 # GameTime_t + m_flAccelSpeed = 0x83C # float + m_flDecelSpeed = 0x840 # float + m_bAccelToSpeed = 0x844 # bool + m_flTimeScale = 0x848 # float + m_flNextMPSoundTime = 0x84C # GameTime_t + +class CFuncTrain: + m_hCurrentTarget = 0x7A8 # CHandle + m_activated = 0x7AC # bool + m_hEnemy = 0x7B0 # CHandle + m_flBlockDamage = 0x7B4 # float + m_flNextBlockTime = 0x7B8 # GameTime_t + m_iszLastTarget = 0x7C0 # CUtlSymbolLarge + +class CFuncVPhysicsClip: + m_bDisabled = 0x700 # bool + +class CFuncWall: + m_nState = 0x700 # int32_t + +class CFuncWater: + m_BuoyancyHelper = 0x700 # CBuoyancyHelper + +class CGameChoreoServices: + m_hOwner = 0x8 # CHandle + m_hScriptedSequence = 0xC # CHandle + m_scriptState = 0x10 # IChoreoServices::ScriptState_t + m_choreoState = 0x14 # IChoreoServices::ChoreoState_t + m_flTimeStartedState = 0x18 # GameTime_t + +class CGameGibManager: + m_bAllowNewGibs = 0x4D0 # bool + m_iCurrentMaxPieces = 0x4D4 # int32_t + m_iMaxPieces = 0x4D8 # int32_t + m_iLastFrame = 0x4DC # int32_t + +class CGamePlayerEquip: + m_weaponNames = 0x710 # CUtlSymbolLarge[32] + m_weaponCount = 0x810 # int32_t[32] + +class CGamePlayerZone: + m_OnPlayerInZone = 0x708 # CEntityIOOutput + m_OnPlayerOutZone = 0x730 # CEntityIOOutput + m_PlayersInCount = 0x758 # CEntityOutputTemplate + m_PlayersOutCount = 0x780 # CEntityOutputTemplate + +class CGameRules: + m_szQuestName = 0x8 # char[128] + m_nQuestPhase = 0x88 # int32_t + +class CGameSceneNode: + m_nodeToWorld = 0x10 # CTransform + m_pOwner = 0x30 # CEntityInstance* + m_pParent = 0x38 # CGameSceneNode* + m_pChild = 0x40 # CGameSceneNode* + m_pNextSibling = 0x48 # CGameSceneNode* + m_hParent = 0x70 # CGameSceneNodeHandle + m_vecOrigin = 0x80 # CNetworkOriginCellCoordQuantizedVector + m_angRotation = 0xB8 # QAngle + m_flScale = 0xC4 # float + m_vecAbsOrigin = 0xC8 # Vector + m_angAbsRotation = 0xD4 # QAngle + m_flAbsScale = 0xE0 # float + m_nParentAttachmentOrBone = 0xE4 # int16_t + m_bDebugAbsOriginChanges = 0xE6 # bool + m_bDormant = 0xE7 # bool + m_bForceParentToBeNetworked = 0xE8 # bool + m_bDirtyHierarchy = 0x0 # bitfield:1 + m_bDirtyBoneMergeInfo = 0x0 # bitfield:1 + m_bNetworkedPositionChanged = 0x0 # bitfield:1 + m_bNetworkedAnglesChanged = 0x0 # bitfield:1 + m_bNetworkedScaleChanged = 0x0 # bitfield:1 + m_bWillBeCallingPostDataUpdate = 0x0 # bitfield:1 + m_bNotifyBoneTransformsChanged = 0x0 # bitfield:1 + m_bBoneMergeFlex = 0x0 # bitfield:1 + m_nLatchAbsOrigin = 0x0 # bitfield:2 + m_bDirtyBoneMergeBoneToRoot = 0x0 # bitfield:1 + m_nHierarchicalDepth = 0xEB # uint8_t + m_nHierarchyType = 0xEC # uint8_t + m_nDoNotSetAnimTimeInInvalidatePhysicsCount = 0xED # uint8_t + m_name = 0xF0 # CUtlStringToken + m_hierarchyAttachName = 0x130 # CUtlStringToken + m_flZOffset = 0x134 # float + m_vRenderOrigin = 0x138 # Vector + +class CGameSceneNodeHandle: + m_hOwner = 0x8 # CEntityHandle + m_name = 0xC # CUtlStringToken + +class CGameScriptedMoveData: + m_vDest = 0x0 # Vector + m_vSrc = 0xC # Vector + m_angSrc = 0x18 # QAngle + m_angDst = 0x24 # QAngle + m_angCurrent = 0x30 # QAngle + m_flAngRate = 0x3C # float + m_flDuration = 0x40 # float + m_flStartTime = 0x44 # GameTime_t + m_nPrevMoveType = 0x48 # MoveType_t + m_bActive = 0x49 # bool + m_bTeleportOnEnd = 0x4A # bool + m_bEndOnDestinationReached = 0x4B # bool + m_bIgnoreRotation = 0x4C # bool + m_nType = 0x50 # ScriptedMoveType_t + m_bSuccess = 0x54 # bool + m_nForcedCrouchState = 0x58 # ForcedCrouchState_t + m_bIgnoreCollisions = 0x5C # bool + +class CGameText: + m_iszMessage = 0x710 # CUtlSymbolLarge + m_textParms = 0x718 # hudtextparms_t + +class CGenericConstraint: + m_nLinearMotionX = 0x510 # JointMotion_t + m_nLinearMotionY = 0x514 # JointMotion_t + m_nLinearMotionZ = 0x518 # JointMotion_t + m_flLinearFrequencyX = 0x51C # float + m_flLinearFrequencyY = 0x520 # float + m_flLinearFrequencyZ = 0x524 # float + m_flLinearDampingRatioX = 0x528 # float + m_flLinearDampingRatioY = 0x52C # float + m_flLinearDampingRatioZ = 0x530 # float + m_flMaxLinearImpulseX = 0x534 # float + m_flMaxLinearImpulseY = 0x538 # float + m_flMaxLinearImpulseZ = 0x53C # float + m_flBreakAfterTimeX = 0x540 # float + m_flBreakAfterTimeY = 0x544 # float + m_flBreakAfterTimeZ = 0x548 # float + m_flBreakAfterTimeStartTimeX = 0x54C # GameTime_t + m_flBreakAfterTimeStartTimeY = 0x550 # GameTime_t + m_flBreakAfterTimeStartTimeZ = 0x554 # GameTime_t + m_flBreakAfterTimeThresholdX = 0x558 # float + m_flBreakAfterTimeThresholdY = 0x55C # float + m_flBreakAfterTimeThresholdZ = 0x560 # float + m_flNotifyForceX = 0x564 # float + m_flNotifyForceY = 0x568 # float + m_flNotifyForceZ = 0x56C # float + m_flNotifyForceMinTimeX = 0x570 # float + m_flNotifyForceMinTimeY = 0x574 # float + m_flNotifyForceMinTimeZ = 0x578 # float + m_flNotifyForceLastTimeX = 0x57C # GameTime_t + m_flNotifyForceLastTimeY = 0x580 # GameTime_t + m_flNotifyForceLastTimeZ = 0x584 # GameTime_t + m_bAxisNotifiedX = 0x588 # bool + m_bAxisNotifiedY = 0x589 # bool + m_bAxisNotifiedZ = 0x58A # bool + m_nAngularMotionX = 0x58C # JointMotion_t + m_nAngularMotionY = 0x590 # JointMotion_t + m_nAngularMotionZ = 0x594 # JointMotion_t + m_flAngularFrequencyX = 0x598 # float + m_flAngularFrequencyY = 0x59C # float + m_flAngularFrequencyZ = 0x5A0 # float + m_flAngularDampingRatioX = 0x5A4 # float + m_flAngularDampingRatioY = 0x5A8 # float + m_flAngularDampingRatioZ = 0x5AC # float + m_flMaxAngularImpulseX = 0x5B0 # float + m_flMaxAngularImpulseY = 0x5B4 # float + m_flMaxAngularImpulseZ = 0x5B8 # float + m_NotifyForceReachedX = 0x5C0 # CEntityIOOutput + m_NotifyForceReachedY = 0x5E8 # CEntityIOOutput + m_NotifyForceReachedZ = 0x610 # CEntityIOOutput + +class CGlowProperty: + m_fGlowColor = 0x8 # Vector + m_iGlowType = 0x30 # int32_t + m_iGlowTeam = 0x34 # int32_t + m_nGlowRange = 0x38 # int32_t + m_nGlowRangeMin = 0x3C # int32_t + m_glowColorOverride = 0x40 # Color + m_bFlashing = 0x44 # bool + m_flGlowTime = 0x48 # float + m_flGlowStartTime = 0x4C # float + m_bEligibleForScreenHighlight = 0x50 # bool + m_bGlowing = 0x51 # bool + +class CGradientFog: + m_hGradientFogTexture = 0x4B0 # CStrongHandle + m_flFogStartDistance = 0x4B8 # float + m_flFogEndDistance = 0x4BC # float + m_bHeightFogEnabled = 0x4C0 # bool + m_flFogStartHeight = 0x4C4 # float + m_flFogEndHeight = 0x4C8 # float + m_flFarZ = 0x4CC # float + m_flFogMaxOpacity = 0x4D0 # float + m_flFogFalloffExponent = 0x4D4 # float + m_flFogVerticalExponent = 0x4D8 # float + m_fogColor = 0x4DC # Color + m_flFogStrength = 0x4E0 # float + m_flFadeTime = 0x4E4 # float + m_bStartDisabled = 0x4E8 # bool + m_bIsEnabled = 0x4E9 # bool + m_bGradientFogNeedsTextures = 0x4EA # bool + +class CGunTarget: + m_on = 0x780 # bool + m_hTargetEnt = 0x784 # CHandle + m_OnDeath = 0x788 # CEntityIOOutput + +class CHandleTest: + m_Handle = 0x4B0 # CHandle + m_bSendHandle = 0x4B4 # bool + +class CHintMessage: + m_hintString = 0x8 # char* + m_args = 0x10 # CUtlVector + m_duration = 0x28 # float + +class CHintMessageQueue: + m_tmMessageEnd = 0x8 # float + m_messages = 0x10 # CUtlVector + m_pPlayerController = 0x28 # CBasePlayerController* + +class CHitboxComponent: + m_bvDisabledHitGroups = 0x24 # uint32_t[1] + +class CHostage: + m_OnHostageBeginGrab = 0x9E8 # CEntityIOOutput + m_OnFirstPickedUp = 0xA10 # CEntityIOOutput + m_OnDroppedNotRescued = 0xA38 # CEntityIOOutput + m_OnRescued = 0xA60 # CEntityIOOutput + m_entitySpottedState = 0xA88 # EntitySpottedState_t + m_nSpotRules = 0xAA0 # int32_t + m_uiHostageSpawnExclusionGroupMask = 0xAA4 # uint32_t + m_nHostageSpawnRandomFactor = 0xAA8 # uint32_t + m_bRemove = 0xAAC # bool + m_vel = 0xAB0 # Vector + m_isRescued = 0xABC # bool + m_jumpedThisFrame = 0xABD # bool + m_nHostageState = 0xAC0 # int32_t + m_leader = 0xAC4 # CHandle + m_lastLeader = 0xAC8 # CHandle + m_reuseTimer = 0xAD0 # CountdownTimer + m_hasBeenUsed = 0xAE8 # bool + m_accel = 0xAEC # Vector + m_isRunning = 0xAF8 # bool + m_isCrouching = 0xAF9 # bool + m_jumpTimer = 0xB00 # CountdownTimer + m_isWaitingForLeader = 0xB18 # bool + m_repathTimer = 0x2B28 # CountdownTimer + m_inhibitDoorTimer = 0x2B40 # CountdownTimer + m_inhibitObstacleAvoidanceTimer = 0x2BD0 # CountdownTimer + m_wiggleTimer = 0x2BF0 # CountdownTimer + m_isAdjusted = 0x2C0C # bool + m_bHandsHaveBeenCut = 0x2C0D # bool + m_hHostageGrabber = 0x2C10 # CHandle + m_fLastGrabTime = 0x2C14 # GameTime_t + m_vecPositionWhenStartedDroppingToGround = 0x2C18 # Vector + m_vecGrabbedPos = 0x2C24 # Vector + m_flRescueStartTime = 0x2C30 # GameTime_t + m_flGrabSuccessTime = 0x2C34 # GameTime_t + m_flDropStartTime = 0x2C38 # GameTime_t + m_nApproachRewardPayouts = 0x2C3C # int32_t + m_nPickupEventCount = 0x2C40 # int32_t + m_vecSpawnGroundPos = 0x2C44 # Vector + +class CHostageExpresserShim: + m_pExpresser = 0x9D0 # CAI_Expresser* + +class CInButtonState: + m_pButtonStates = 0x8 # uint64_t[3] + +class CInferno: + m_fireXDelta = 0x710 # int32_t[64] + m_fireYDelta = 0x810 # int32_t[64] + m_fireZDelta = 0x910 # int32_t[64] + m_fireParentXDelta = 0xA10 # int32_t[64] + m_fireParentYDelta = 0xB10 # int32_t[64] + m_fireParentZDelta = 0xC10 # int32_t[64] + m_bFireIsBurning = 0xD10 # bool[64] + m_BurnNormal = 0xD50 # Vector[64] + m_fireCount = 0x1050 # int32_t + m_nInfernoType = 0x1054 # int32_t + m_nFireEffectTickBegin = 0x1058 # int32_t + m_nFireLifetime = 0x105C # float + m_bInPostEffectTime = 0x1060 # bool + m_nFiresExtinguishCount = 0x1064 # int32_t + m_bWasCreatedInSmoke = 0x1068 # bool + m_extent = 0x1270 # Extent + m_damageTimer = 0x1288 # CountdownTimer + m_damageRampTimer = 0x12A0 # CountdownTimer + m_splashVelocity = 0x12B8 # Vector + m_InitialSplashVelocity = 0x12C4 # Vector + m_startPos = 0x12D0 # Vector + m_vecOriginalSpawnLocation = 0x12DC # Vector + m_activeTimer = 0x12E8 # IntervalTimer + m_fireSpawnOffset = 0x12F8 # int32_t + m_nMaxFlames = 0x12FC # int32_t + m_BookkeepingTimer = 0x1300 # CountdownTimer + m_NextSpreadTimer = 0x1318 # CountdownTimer + m_nSourceItemDefIndex = 0x1330 # uint16_t + +class CInfoDynamicShadowHint: + m_bDisabled = 0x4B0 # bool + m_flRange = 0x4B4 # float + m_nImportance = 0x4B8 # int32_t + m_nLightChoice = 0x4BC # int32_t + m_hLight = 0x4C0 # CHandle + +class CInfoDynamicShadowHintBox: + m_vBoxMins = 0x4C8 # Vector + m_vBoxMaxs = 0x4D4 # Vector + +class CInfoGameEventProxy: + m_iszEventName = 0x4B0 # CUtlSymbolLarge + m_flRange = 0x4B8 # float + +class CInfoOffscreenPanoramaTexture: + m_bDisabled = 0x4B0 # bool + m_nResolutionX = 0x4B4 # int32_t + m_nResolutionY = 0x4B8 # int32_t + m_szLayoutFileName = 0x4C0 # CUtlSymbolLarge + m_RenderAttrName = 0x4C8 # CUtlSymbolLarge + m_TargetEntities = 0x4D0 # CNetworkUtlVectorBase> + m_nTargetChangeCount = 0x4E8 # int32_t + m_vecCSSClasses = 0x4F0 # CNetworkUtlVectorBase + m_szTargetsName = 0x508 # CUtlSymbolLarge + m_AdditionalTargetEntities = 0x510 # CUtlVector> + +class CInfoPlayerStart: + m_bDisabled = 0x4B0 # bool + +class CInfoSpawnGroupLoadUnload: + m_OnSpawnGroupLoadStarted = 0x4B0 # CEntityIOOutput + m_OnSpawnGroupLoadFinished = 0x4D8 # CEntityIOOutput + m_OnSpawnGroupUnloadStarted = 0x500 # CEntityIOOutput + m_OnSpawnGroupUnloadFinished = 0x528 # CEntityIOOutput + m_iszSpawnGroupName = 0x550 # CUtlSymbolLarge + m_iszSpawnGroupFilterName = 0x558 # CUtlSymbolLarge + m_iszLandmarkName = 0x560 # CUtlSymbolLarge + m_sFixedSpawnGroupName = 0x568 # CUtlString + m_flTimeoutInterval = 0x570 # float + m_bStreamingStarted = 0x574 # bool + m_bUnloadingStarted = 0x575 # bool + +class CInfoVisibilityBox: + m_nMode = 0x4B4 # int32_t + m_vBoxSize = 0x4B8 # Vector + m_bEnabled = 0x4C4 # bool + +class CInfoWorldLayer: + m_pOutputOnEntitiesSpawned = 0x4B0 # CEntityIOOutput + m_worldName = 0x4D8 # CUtlSymbolLarge + m_layerName = 0x4E0 # CUtlSymbolLarge + m_bWorldLayerVisible = 0x4E8 # bool + m_bEntitiesSpawned = 0x4E9 # bool + m_bCreateAsChildSpawnGroup = 0x4EA # bool + m_hLayerSpawnGroup = 0x4EC # uint32_t + +class CInstancedSceneEntity: + m_hOwner = 0xA08 # CHandle + m_bHadOwner = 0xA0C # bool + m_flPostSpeakDelay = 0xA10 # float + m_flPreDelay = 0xA14 # float + m_bIsBackground = 0xA18 # bool + +class CInstructorEventEntity: + m_iszName = 0x4B0 # CUtlSymbolLarge + m_iszHintTargetEntity = 0x4B8 # CUtlSymbolLarge + m_hTargetPlayer = 0x4C0 # CHandle + +class CIronSightController: + m_bIronSightAvailable = 0x8 # bool + m_flIronSightAmount = 0xC # float + m_flIronSightAmountGained = 0x10 # float + m_flIronSightAmountBiased = 0x14 # float + +class CItem: + m_OnPlayerTouch = 0x898 # CEntityIOOutput + m_bActivateWhenAtRest = 0x8C0 # bool + m_OnCacheInteraction = 0x8C8 # CEntityIOOutput + m_OnPlayerPickup = 0x8F0 # CEntityIOOutput + m_OnGlovePulled = 0x918 # CEntityIOOutput + m_vOriginalSpawnOrigin = 0x940 # Vector + m_vOriginalSpawnAngles = 0x94C # QAngle + m_bPhysStartAsleep = 0x958 # bool + +class CItemDefuser: + m_entitySpottedState = 0x968 # EntitySpottedState_t + m_nSpotRules = 0x980 # int32_t + +class CItemDogtags: + m_OwningPlayer = 0x968 # CHandle + m_KillingPlayer = 0x96C # CHandle + +class CItemGeneric: + m_bHasTriggerRadius = 0x970 # bool + m_bHasPickupRadius = 0x971 # bool + m_flPickupRadiusSqr = 0x974 # float + m_flTriggerRadiusSqr = 0x978 # float + m_flLastPickupCheck = 0x97C # GameTime_t + m_bPlayerCounterListenerAdded = 0x980 # bool + m_bPlayerInTriggerRadius = 0x981 # bool + m_hSpawnParticleEffect = 0x988 # CStrongHandle + m_pAmbientSoundEffect = 0x990 # CUtlSymbolLarge + m_bAutoStartAmbientSound = 0x998 # bool + m_pSpawnScriptFunction = 0x9A0 # CUtlSymbolLarge + m_hPickupParticleEffect = 0x9A8 # CStrongHandle + m_pPickupSoundEffect = 0x9B0 # CUtlSymbolLarge + m_pPickupScriptFunction = 0x9B8 # CUtlSymbolLarge + m_hTimeoutParticleEffect = 0x9C0 # CStrongHandle + m_pTimeoutSoundEffect = 0x9C8 # CUtlSymbolLarge + m_pTimeoutScriptFunction = 0x9D0 # CUtlSymbolLarge + m_pPickupFilterName = 0x9D8 # CUtlSymbolLarge + m_hPickupFilter = 0x9E0 # CHandle + m_OnPickup = 0x9E8 # CEntityIOOutput + m_OnTimeout = 0xA10 # CEntityIOOutput + m_OnTriggerStartTouch = 0xA38 # CEntityIOOutput + m_OnTriggerTouch = 0xA60 # CEntityIOOutput + m_OnTriggerEndTouch = 0xA88 # CEntityIOOutput + m_pAllowPickupScriptFunction = 0xAB0 # CUtlSymbolLarge + m_flPickupRadius = 0xAB8 # float + m_flTriggerRadius = 0xABC # float + m_pTriggerSoundEffect = 0xAC0 # CUtlSymbolLarge + m_bGlowWhenInTrigger = 0xAC8 # bool + m_glowColor = 0xAC9 # Color + m_bUseable = 0xACD # bool + m_hTriggerHelper = 0xAD0 # CHandle + +class CItemGenericTriggerHelper: + m_hParentItem = 0x700 # CHandle + +class CKeepUpright: + m_worldGoalAxis = 0x4B8 # Vector + m_localTestAxis = 0x4C4 # Vector + m_nameAttach = 0x4D8 # CUtlSymbolLarge + m_attachedObject = 0x4E0 # CHandle + m_angularLimit = 0x4E4 # float + m_bActive = 0x4E8 # bool + m_bDampAllRotation = 0x4E9 # bool + +class CLightComponent: + __m_pChainEntity = 0x48 # CNetworkVarChainer + m_Color = 0x85 # Color + m_SecondaryColor = 0x89 # Color + m_flBrightness = 0x90 # float + m_flBrightnessScale = 0x94 # float + m_flBrightnessMult = 0x98 # float + m_flRange = 0x9C # float + m_flFalloff = 0xA0 # float + m_flAttenuation0 = 0xA4 # float + m_flAttenuation1 = 0xA8 # float + m_flAttenuation2 = 0xAC # float + m_flTheta = 0xB0 # float + m_flPhi = 0xB4 # float + m_hLightCookie = 0xB8 # CStrongHandle + m_nCascades = 0xC0 # int32_t + m_nCastShadows = 0xC4 # int32_t + m_nShadowWidth = 0xC8 # int32_t + m_nShadowHeight = 0xCC # int32_t + m_bRenderDiffuse = 0xD0 # bool + m_nRenderSpecular = 0xD4 # int32_t + m_bRenderTransmissive = 0xD8 # bool + m_flOrthoLightWidth = 0xDC # float + m_flOrthoLightHeight = 0xE0 # float + m_nStyle = 0xE4 # int32_t + m_Pattern = 0xE8 # CUtlString + m_nCascadeRenderStaticObjects = 0xF0 # int32_t + m_flShadowCascadeCrossFade = 0xF4 # float + m_flShadowCascadeDistanceFade = 0xF8 # float + m_flShadowCascadeDistance0 = 0xFC # float + m_flShadowCascadeDistance1 = 0x100 # float + m_flShadowCascadeDistance2 = 0x104 # float + m_flShadowCascadeDistance3 = 0x108 # float + m_nShadowCascadeResolution0 = 0x10C # int32_t + m_nShadowCascadeResolution1 = 0x110 # int32_t + m_nShadowCascadeResolution2 = 0x114 # int32_t + m_nShadowCascadeResolution3 = 0x118 # int32_t + m_bUsesBakedShadowing = 0x11C # bool + m_nShadowPriority = 0x120 # int32_t + m_nBakedShadowIndex = 0x124 # int32_t + m_bRenderToCubemaps = 0x128 # bool + m_LightGroups = 0x130 # CUtlSymbolLarge + m_nDirectLight = 0x138 # int32_t + m_nIndirectLight = 0x13C # int32_t + m_flFadeMinDist = 0x140 # float + m_flFadeMaxDist = 0x144 # float + m_flShadowFadeMinDist = 0x148 # float + m_flShadowFadeMaxDist = 0x14C # float + m_bEnabled = 0x150 # bool + m_bFlicker = 0x151 # bool + m_bPrecomputedFieldsValid = 0x152 # bool + m_vPrecomputedBoundsMins = 0x154 # Vector + m_vPrecomputedBoundsMaxs = 0x160 # Vector + m_vPrecomputedOBBOrigin = 0x16C # Vector + m_vPrecomputedOBBAngles = 0x178 # QAngle + m_vPrecomputedOBBExtent = 0x184 # Vector + m_flPrecomputedMaxRange = 0x190 # float + m_nFogLightingMode = 0x194 # int32_t + m_flFogContributionStength = 0x198 # float + m_flNearClipPlane = 0x19C # float + m_SkyColor = 0x1A0 # Color + m_flSkyIntensity = 0x1A4 # float + m_SkyAmbientBounce = 0x1A8 # Color + m_bUseSecondaryColor = 0x1AC # bool + m_bMixedShadows = 0x1AD # bool + m_flLightStyleStartTime = 0x1B0 # GameTime_t + m_flCapsuleLength = 0x1B4 # float + m_flMinRoughness = 0x1B8 # float + m_bPvsModifyEntity = 0x1C8 # bool + +class CLightEntity: + m_CLightComponent = 0x700 # CLightComponent* + +class CLightGlow: + m_nHorizontalSize = 0x700 # uint32_t + m_nVerticalSize = 0x704 # uint32_t + m_nMinDist = 0x708 # uint32_t + m_nMaxDist = 0x70C # uint32_t + m_nOuterMaxDist = 0x710 # uint32_t + m_flGlowProxySize = 0x714 # float + m_flHDRColorScale = 0x718 # float + +class CLogicAchievement: + m_bDisabled = 0x4B0 # bool + m_iszAchievementEventID = 0x4B8 # CUtlSymbolLarge + m_OnFired = 0x4C0 # CEntityIOOutput + +class CLogicActiveAutosave: + m_TriggerHitPoints = 0x4C0 # int32_t + m_flTimeToTrigger = 0x4C4 # float + m_flStartTime = 0x4C8 # GameTime_t + m_flDangerousTime = 0x4CC # float + +class CLogicAuto: + m_OnMapSpawn = 0x4B0 # CEntityIOOutput + m_OnDemoMapSpawn = 0x4D8 # CEntityIOOutput + m_OnNewGame = 0x500 # CEntityIOOutput + m_OnLoadGame = 0x528 # CEntityIOOutput + m_OnMapTransition = 0x550 # CEntityIOOutput + m_OnBackgroundMap = 0x578 # CEntityIOOutput + m_OnMultiNewMap = 0x5A0 # CEntityIOOutput + m_OnMultiNewRound = 0x5C8 # CEntityIOOutput + m_OnVREnabled = 0x5F0 # CEntityIOOutput + m_OnVRNotEnabled = 0x618 # CEntityIOOutput + m_globalstate = 0x640 # CUtlSymbolLarge + +class CLogicAutosave: + m_bForceNewLevelUnit = 0x4B0 # bool + m_minHitPoints = 0x4B4 # int32_t + m_minHitPointsToCommit = 0x4B8 # int32_t + +class CLogicBranch: + m_bInValue = 0x4B0 # bool + m_Listeners = 0x4B8 # CUtlVector> + m_OnTrue = 0x4D0 # CEntityIOOutput + m_OnFalse = 0x4F8 # CEntityIOOutput + +class CLogicBranchList: + m_nLogicBranchNames = 0x4B0 # CUtlSymbolLarge[16] + m_LogicBranchList = 0x530 # CUtlVector> + m_eLastState = 0x548 # CLogicBranchList::LogicBranchListenerLastState_t + m_OnAllTrue = 0x550 # CEntityIOOutput + m_OnAllFalse = 0x578 # CEntityIOOutput + m_OnMixed = 0x5A0 # CEntityIOOutput + +class CLogicCase: + m_nCase = 0x4B0 # CUtlSymbolLarge[32] + m_nShuffleCases = 0x5B0 # int32_t + m_nLastShuffleCase = 0x5B4 # int32_t + m_uchShuffleCaseMap = 0x5B8 # uint8_t[32] + m_OnCase = 0x5D8 # CEntityIOOutput[32] + m_OnDefault = 0xAD8 # CEntityOutputTemplate> + +class CLogicCollisionPair: + m_nameAttach1 = 0x4B0 # CUtlSymbolLarge + m_nameAttach2 = 0x4B8 # CUtlSymbolLarge + m_disabled = 0x4C0 # bool + m_succeeded = 0x4C1 # bool + +class CLogicCompare: + m_flInValue = 0x4B0 # float + m_flCompareValue = 0x4B4 # float + m_OnLessThan = 0x4B8 # CEntityOutputTemplate + m_OnEqualTo = 0x4E0 # CEntityOutputTemplate + m_OnNotEqualTo = 0x508 # CEntityOutputTemplate + m_OnGreaterThan = 0x530 # CEntityOutputTemplate + +class CLogicDistanceAutosave: + m_iszTargetEntity = 0x4B0 # CUtlSymbolLarge + m_flDistanceToPlayer = 0x4B8 # float + m_bForceNewLevelUnit = 0x4BC # bool + m_bCheckCough = 0x4BD # bool + m_bThinkDangerous = 0x4BE # bool + m_flDangerousTime = 0x4C0 # float + +class CLogicDistanceCheck: + m_iszEntityA = 0x4B0 # CUtlSymbolLarge + m_iszEntityB = 0x4B8 # CUtlSymbolLarge + m_flZone1Distance = 0x4C0 # float + m_flZone2Distance = 0x4C4 # float + m_InZone1 = 0x4C8 # CEntityIOOutput + m_InZone2 = 0x4F0 # CEntityIOOutput + m_InZone3 = 0x518 # CEntityIOOutput + +class CLogicGameEvent: + m_iszEventName = 0x4B0 # CUtlSymbolLarge + +class CLogicGameEventListener: + m_OnEventFired = 0x4C0 # CEntityIOOutput + m_iszGameEventName = 0x4E8 # CUtlSymbolLarge + m_iszGameEventItem = 0x4F0 # CUtlSymbolLarge + m_bEnabled = 0x4F8 # bool + m_bStartDisabled = 0x4F9 # bool + +class CLogicLineToEntity: + m_Line = 0x4B0 # CEntityOutputTemplate + m_SourceName = 0x4D8 # CUtlSymbolLarge + m_StartEntity = 0x4E0 # CHandle + m_EndEntity = 0x4E4 # CHandle + +class CLogicMeasureMovement: + m_strMeasureTarget = 0x4B0 # CUtlSymbolLarge + m_strMeasureReference = 0x4B8 # CUtlSymbolLarge + m_strTargetReference = 0x4C0 # CUtlSymbolLarge + m_hMeasureTarget = 0x4C8 # CHandle + m_hMeasureReference = 0x4CC # CHandle + m_hTarget = 0x4D0 # CHandle + m_hTargetReference = 0x4D4 # CHandle + m_flScale = 0x4D8 # float + m_nMeasureType = 0x4DC # int32_t + +class CLogicNPCCounter: + m_OnMinCountAll = 0x4B0 # CEntityIOOutput + m_OnMaxCountAll = 0x4D8 # CEntityIOOutput + m_OnFactorAll = 0x500 # CEntityOutputTemplate + m_OnMinPlayerDistAll = 0x528 # CEntityOutputTemplate + m_OnMinCount_1 = 0x550 # CEntityIOOutput + m_OnMaxCount_1 = 0x578 # CEntityIOOutput + m_OnFactor_1 = 0x5A0 # CEntityOutputTemplate + m_OnMinPlayerDist_1 = 0x5C8 # CEntityOutputTemplate + m_OnMinCount_2 = 0x5F0 # CEntityIOOutput + m_OnMaxCount_2 = 0x618 # CEntityIOOutput + m_OnFactor_2 = 0x640 # CEntityOutputTemplate + m_OnMinPlayerDist_2 = 0x668 # CEntityOutputTemplate + m_OnMinCount_3 = 0x690 # CEntityIOOutput + m_OnMaxCount_3 = 0x6B8 # CEntityIOOutput + m_OnFactor_3 = 0x6E0 # CEntityOutputTemplate + m_OnMinPlayerDist_3 = 0x708 # CEntityOutputTemplate + m_hSource = 0x730 # CEntityHandle + m_iszSourceEntityName = 0x738 # CUtlSymbolLarge + m_flDistanceMax = 0x740 # float + m_bDisabled = 0x744 # bool + m_nMinCountAll = 0x748 # int32_t + m_nMaxCountAll = 0x74C # int32_t + m_nMinFactorAll = 0x750 # int32_t + m_nMaxFactorAll = 0x754 # int32_t + m_iszNPCClassname_1 = 0x760 # CUtlSymbolLarge + m_nNPCState_1 = 0x768 # int32_t + m_bInvertState_1 = 0x76C # bool + m_nMinCount_1 = 0x770 # int32_t + m_nMaxCount_1 = 0x774 # int32_t + m_nMinFactor_1 = 0x778 # int32_t + m_nMaxFactor_1 = 0x77C # int32_t + m_flDefaultDist_1 = 0x784 # float + m_iszNPCClassname_2 = 0x788 # CUtlSymbolLarge + m_nNPCState_2 = 0x790 # int32_t + m_bInvertState_2 = 0x794 # bool + m_nMinCount_2 = 0x798 # int32_t + m_nMaxCount_2 = 0x79C # int32_t + m_nMinFactor_2 = 0x7A0 # int32_t + m_nMaxFactor_2 = 0x7A4 # int32_t + m_flDefaultDist_2 = 0x7AC # float + m_iszNPCClassname_3 = 0x7B0 # CUtlSymbolLarge + m_nNPCState_3 = 0x7B8 # int32_t + m_bInvertState_3 = 0x7BC # bool + m_nMinCount_3 = 0x7C0 # int32_t + m_nMaxCount_3 = 0x7C4 # int32_t + m_nMinFactor_3 = 0x7C8 # int32_t + m_nMaxFactor_3 = 0x7CC # int32_t + m_flDefaultDist_3 = 0x7D4 # float + +class CLogicNPCCounterAABB: + m_vDistanceOuterMins = 0x7F0 # Vector + m_vDistanceOuterMaxs = 0x7FC # Vector + m_vOuterMins = 0x808 # Vector + m_vOuterMaxs = 0x814 # Vector + +class CLogicNavigation: + m_isOn = 0x4B8 # bool + m_navProperty = 0x4BC # navproperties_t + +class CLogicPlayerProxy: + m_hPlayer = 0x4B0 # CHandle + m_PlayerHasAmmo = 0x4B8 # CEntityIOOutput + m_PlayerHasNoAmmo = 0x4E0 # CEntityIOOutput + m_PlayerDied = 0x508 # CEntityIOOutput + m_RequestedPlayerHealth = 0x530 # CEntityOutputTemplate + +class CLogicRelay: + m_OnTrigger = 0x4B0 # CEntityIOOutput + m_OnSpawn = 0x4D8 # CEntityIOOutput + m_bDisabled = 0x500 # bool + m_bWaitForRefire = 0x501 # bool + m_bTriggerOnce = 0x502 # bool + m_bFastRetrigger = 0x503 # bool + m_bPassthoughCaller = 0x504 # bool + +class CMapInfo: + m_iBuyingStatus = 0x4B0 # int32_t + m_flBombRadius = 0x4B4 # float + m_iPetPopulation = 0x4B8 # int32_t + m_bUseNormalSpawnsForDM = 0x4BC # bool + m_bDisableAutoGeneratedDMSpawns = 0x4BD # bool + m_flBotMaxVisionDistance = 0x4C0 # float + m_iHostageCount = 0x4C4 # int32_t + m_bFadePlayerVisibilityFarZ = 0x4C8 # bool + +class CMapVetoPickController: + m_bPlayedIntroVcd = 0x4B0 # bool + m_bNeedToPlayFiveSecondsRemaining = 0x4B1 # bool + m_dblPreMatchDraftSequenceTime = 0x4D0 # double + m_bPreMatchDraftStateChanged = 0x4D8 # bool + m_nDraftType = 0x4DC # int32_t + m_nTeamWinningCoinToss = 0x4E0 # int32_t + m_nTeamWithFirstChoice = 0x4E4 # int32_t[64] + m_nVoteMapIdsList = 0x5E4 # int32_t[7] + m_nAccountIDs = 0x600 # int32_t[64] + m_nMapId0 = 0x700 # int32_t[64] + m_nMapId1 = 0x800 # int32_t[64] + m_nMapId2 = 0x900 # int32_t[64] + m_nMapId3 = 0xA00 # int32_t[64] + m_nMapId4 = 0xB00 # int32_t[64] + m_nMapId5 = 0xC00 # int32_t[64] + m_nStartingSide0 = 0xD00 # int32_t[64] + m_nCurrentPhase = 0xE00 # int32_t + m_nPhaseStartTick = 0xE04 # int32_t + m_nPhaseDurationTicks = 0xE08 # int32_t + m_OnMapVetoed = 0xE10 # CEntityOutputTemplate + m_OnMapPicked = 0xE38 # CEntityOutputTemplate + m_OnSidesPicked = 0xE60 # CEntityOutputTemplate + m_OnNewPhaseStarted = 0xE88 # CEntityOutputTemplate + m_OnLevelTransition = 0xEB0 # CEntityOutputTemplate + +class CMarkupVolume: + m_bEnabled = 0x700 # bool + +class CMarkupVolumeTagged: + m_bIsGroup = 0x738 # bool + m_bGroupByPrefab = 0x739 # bool + m_bGroupByVolume = 0x73A # bool + m_bGroupOtherGroups = 0x73B # bool + m_bIsInGroup = 0x73C # bool + +class CMarkupVolumeTagged_NavGame: + m_bFloodFillAttribute = 0x758 # bool + +class CMarkupVolumeWithRef: + m_bUseRef = 0x740 # bool + m_vRefPos = 0x744 # Vector + m_flRefDot = 0x750 # float + +class CMathColorBlend: + m_flInMin = 0x4B0 # float + m_flInMax = 0x4B4 # float + m_OutColor1 = 0x4B8 # Color + m_OutColor2 = 0x4BC # Color + m_OutValue = 0x4C0 # CEntityOutputTemplate + +class CMathCounter: + m_flMin = 0x4B0 # float + m_flMax = 0x4B4 # float + m_bHitMin = 0x4B8 # bool + m_bHitMax = 0x4B9 # bool + m_bDisabled = 0x4BA # bool + m_OutValue = 0x4C0 # CEntityOutputTemplate + m_OnGetValue = 0x4E8 # CEntityOutputTemplate + m_OnHitMin = 0x510 # CEntityIOOutput + m_OnHitMax = 0x538 # CEntityIOOutput + m_OnChangedFromMin = 0x560 # CEntityIOOutput + m_OnChangedFromMax = 0x588 # CEntityIOOutput + +class CMathRemap: + m_flInMin = 0x4B0 # float + m_flInMax = 0x4B4 # float + m_flOut1 = 0x4B8 # float + m_flOut2 = 0x4BC # float + m_flOldInValue = 0x4C0 # float + m_bEnabled = 0x4C4 # bool + m_OutValue = 0x4C8 # CEntityOutputTemplate + m_OnRoseAboveMin = 0x4F0 # CEntityIOOutput + m_OnRoseAboveMax = 0x518 # CEntityIOOutput + m_OnFellBelowMin = 0x540 # CEntityIOOutput + m_OnFellBelowMax = 0x568 # CEntityIOOutput + +class CMelee: + m_flThrowAt = 0xDD8 # GameTime_t + m_hThrower = 0xDDC # CHandle + m_bDidThrowDamage = 0xDE0 # bool + +class CMessage: + m_iszMessage = 0x4B0 # CUtlSymbolLarge + m_MessageVolume = 0x4B8 # float + m_MessageAttenuation = 0x4BC # int32_t + m_Radius = 0x4C0 # float + m_sNoise = 0x4C8 # CUtlSymbolLarge + m_OnShowMessage = 0x4D0 # CEntityIOOutput + +class CMessageEntity: + m_radius = 0x4B0 # int32_t + m_messageText = 0x4B8 # CUtlSymbolLarge + m_drawText = 0x4C0 # bool + m_bDeveloperOnly = 0x4C1 # bool + m_bEnabled = 0x4C2 # bool + +class CModelState: + m_hModel = 0xA0 # CStrongHandle + m_ModelName = 0xA8 # CUtlSymbolLarge + m_bClientClothCreationSuppressed = 0xE8 # bool + m_MeshGroupMask = 0x180 # uint64_t + m_nIdealMotionType = 0x222 # int8_t + m_nForceLOD = 0x223 # int8_t + m_nClothUpdateFlags = 0x224 # int8_t + +class CMolotovProjectile: + m_bIsIncGrenade = 0xA28 # bool + m_bDetonated = 0xA34 # bool + m_stillTimer = 0xA38 # IntervalTimer + m_bHasBouncedOffPlayer = 0xB18 # bool + +class CMomentaryRotButton: + m_Position = 0x8C8 # CEntityOutputTemplate + m_OnUnpressed = 0x8F0 # CEntityIOOutput + m_OnFullyOpen = 0x918 # CEntityIOOutput + m_OnFullyClosed = 0x940 # CEntityIOOutput + m_OnReachedPosition = 0x968 # CEntityIOOutput + m_lastUsed = 0x990 # int32_t + m_start = 0x994 # QAngle + m_end = 0x9A0 # QAngle + m_IdealYaw = 0x9AC # float + m_sNoise = 0x9B0 # CUtlSymbolLarge + m_bUpdateTarget = 0x9B8 # bool + m_direction = 0x9BC # int32_t + m_returnSpeed = 0x9C0 # float + m_flStartPosition = 0x9C4 # float + +class CMotorController: + m_speed = 0x8 # float + m_maxTorque = 0xC # float + m_axis = 0x10 # Vector + m_inertiaFactor = 0x1C # float + +class CMultiLightProxy: + m_iszLightNameFilter = 0x4B0 # CUtlSymbolLarge + m_iszLightClassFilter = 0x4B8 # CUtlSymbolLarge + m_flLightRadiusFilter = 0x4C0 # float + m_flBrightnessDelta = 0x4C4 # float + m_bPerformScreenFade = 0x4C8 # bool + m_flTargetBrightnessMultiplier = 0x4CC # float + m_flCurrentBrightnessMultiplier = 0x4D0 # float + m_vecLights = 0x4D8 # CUtlVector> + +class CMultiSource: + m_rgEntities = 0x4B0 # CHandle[32] + m_rgTriggered = 0x530 # int32_t[32] + m_OnTrigger = 0x5B0 # CEntityIOOutput + m_iTotal = 0x5D8 # int32_t + m_globalstate = 0x5E0 # CUtlSymbolLarge + +class CMultiplayer_Expresser: + m_bAllowMultipleScenes = 0x70 # bool + +class CNavHullPresetVData: + m_vecNavHulls = 0x0 # CUtlVector + +class CNavHullVData: + m_bAgentEnabled = 0x0 # bool + m_agentRadius = 0x4 # float + m_agentHeight = 0x8 # float + m_agentShortHeightEnabled = 0xC # bool + m_agentShortHeight = 0x10 # float + m_agentMaxClimb = 0x14 # float + m_agentMaxSlope = 0x18 # int32_t + m_agentMaxJumpDownDist = 0x1C # float + m_agentMaxJumpHorizDistBase = 0x20 # float + m_agentMaxJumpUpDist = 0x24 # float + m_agentBorderErosion = 0x28 # int32_t + +class CNavLinkAnimgraphVar: + m_strAnimgraphVar = 0x0 # CUtlString + m_unAlignmentDegrees = 0x8 # uint32_t + +class CNavLinkAreaEntity: + m_flWidth = 0x4B0 # float + m_vLocatorOffset = 0x4B4 # Vector + m_qLocatorAnglesOffset = 0x4C0 # QAngle + m_strMovementForward = 0x4D0 # CUtlSymbolLarge + m_strMovementReverse = 0x4D8 # CUtlSymbolLarge + m_nNavLinkIdForward = 0x4E0 # int32_t + m_nNavLinkIdReverse = 0x4E4 # int32_t + m_bEnabled = 0x4E8 # bool + m_strFilterName = 0x4F0 # CUtlSymbolLarge + m_hFilter = 0x4F8 # CHandle + m_OnNavLinkStart = 0x500 # CEntityIOOutput + m_OnNavLinkFinish = 0x528 # CEntityIOOutput + m_bIsTerminus = 0x550 # bool + +class CNavLinkMovementVData: + m_bIsInterpolated = 0x0 # bool + m_unRecommendedDistance = 0x4 # uint32_t + m_vecAnimgraphVars = 0x8 # CUtlVector + +class CNavSpaceInfo: + m_bCreateFlightSpace = 0x4B0 # bool + +class CNavVolumeBreadthFirstSearch: + m_vStartPos = 0xA0 # Vector + m_flSearchDist = 0xAC # float + +class CNavVolumeSphere: + m_vCenter = 0x70 # Vector + m_flRadius = 0x7C # float + +class CNavVolumeSphericalShell: + m_flRadiusInner = 0x80 # float + +class CNavVolumeVector: + m_bHasBeenPreFiltered = 0x78 # bool + +class CNetworkOriginCellCoordQuantizedVector: + m_cellX = 0x10 # uint16_t + m_cellY = 0x12 # uint16_t + m_cellZ = 0x14 # uint16_t + m_nOutsideWorld = 0x16 # uint16_t + m_vecX = 0x18 # CNetworkedQuantizedFloat + m_vecY = 0x20 # CNetworkedQuantizedFloat + m_vecZ = 0x28 # CNetworkedQuantizedFloat + +class CNetworkOriginQuantizedVector: + m_vecX = 0x10 # CNetworkedQuantizedFloat + m_vecY = 0x18 # CNetworkedQuantizedFloat + m_vecZ = 0x20 # CNetworkedQuantizedFloat + +class CNetworkTransmitComponent: + m_nTransmitStateOwnedCounter = 0x16C # uint8_t + +class CNetworkVelocityVector: + m_vecX = 0x10 # CNetworkedQuantizedFloat + m_vecY = 0x18 # CNetworkedQuantizedFloat + m_vecZ = 0x20 # CNetworkedQuantizedFloat + +class CNetworkViewOffsetVector: + m_vecX = 0x10 # CNetworkedQuantizedFloat + m_vecY = 0x18 # CNetworkedQuantizedFloat + m_vecZ = 0x20 # CNetworkedQuantizedFloat + +class CNetworkedSequenceOperation: + m_hSequence = 0x8 # HSequence + m_flPrevCycle = 0xC # float + m_flCycle = 0x10 # float + m_flWeight = 0x14 # CNetworkedQuantizedFloat + m_bSequenceChangeNetworked = 0x1C # bool + m_bDiscontinuity = 0x1D # bool + m_flPrevCycleFromDiscontinuity = 0x20 # float + m_flPrevCycleForAnimEventDetection = 0x24 # float + +class COmniLight: + m_flInnerAngle = 0x938 # float + m_flOuterAngle = 0x93C # float + m_bShowLight = 0x940 # bool + +class COrnamentProp: + m_initialOwner = 0xB08 # CUtlSymbolLarge + +class CParticleSystem: + m_szSnapshotFileName = 0x700 # char[512] + m_bActive = 0x900 # bool + m_bFrozen = 0x901 # bool + m_flFreezeTransitionDuration = 0x904 # float + m_nStopType = 0x908 # int32_t + m_bAnimateDuringGameplayPause = 0x90C # bool + m_iEffectIndex = 0x910 # CStrongHandle + m_flStartTime = 0x918 # GameTime_t + m_flPreSimTime = 0x91C # float + m_vServerControlPoints = 0x920 # Vector[4] + m_iServerControlPointAssignments = 0x950 # uint8_t[4] + m_hControlPointEnts = 0x954 # CHandle[64] + m_bNoSave = 0xA54 # bool + m_bNoFreeze = 0xA55 # bool + m_bNoRamp = 0xA56 # bool + m_bStartActive = 0xA57 # bool + m_iszEffectName = 0xA58 # CUtlSymbolLarge + m_iszControlPointNames = 0xA60 # CUtlSymbolLarge[64] + m_nDataCP = 0xC60 # int32_t + m_vecDataCPValue = 0xC64 # Vector + m_nTintCP = 0xC70 # int32_t + m_clrTint = 0xC74 # Color + +class CPathCorner: + m_flWait = 0x4B0 # float + m_flRadius = 0x4B4 # float + m_OnPass = 0x4B8 # CEntityIOOutput + +class CPathKeyFrame: + m_Origin = 0x4B0 # Vector + m_Angles = 0x4BC # QAngle + m_qAngle = 0x4D0 # Quaternion + m_iNextKey = 0x4E0 # CUtlSymbolLarge + m_flNextTime = 0x4E8 # float + m_pNextKey = 0x4F0 # CPathKeyFrame* + m_pPrevKey = 0x4F8 # CPathKeyFrame* + m_flSpeed = 0x500 # float + +class CPathParticleRope: + m_bStartActive = 0x4B0 # bool + m_flMaxSimulationTime = 0x4B4 # float + m_iszEffectName = 0x4B8 # CUtlSymbolLarge + m_PathNodes_Name = 0x4C0 # CUtlVector + m_flParticleSpacing = 0x4D8 # float + m_flSlack = 0x4DC # float + m_flRadius = 0x4E0 # float + m_ColorTint = 0x4E4 # Color + m_nEffectState = 0x4E8 # int32_t + m_iEffectIndex = 0x4F0 # CStrongHandle + m_PathNodes_Position = 0x4F8 # CNetworkUtlVectorBase + m_PathNodes_TangentIn = 0x510 # CNetworkUtlVectorBase + m_PathNodes_TangentOut = 0x528 # CNetworkUtlVectorBase + m_PathNodes_Color = 0x540 # CNetworkUtlVectorBase + m_PathNodes_PinEnabled = 0x558 # CNetworkUtlVectorBase + m_PathNodes_RadiusScale = 0x570 # CNetworkUtlVectorBase + +class CPathTrack: + m_pnext = 0x4B0 # CPathTrack* + m_pprevious = 0x4B8 # CPathTrack* + m_paltpath = 0x4C0 # CPathTrack* + m_flRadius = 0x4C8 # float + m_length = 0x4CC # float + m_altName = 0x4D0 # CUtlSymbolLarge + m_nIterVal = 0x4D8 # int32_t + m_eOrientationType = 0x4DC # TrackOrientationType_t + m_OnPass = 0x4E0 # CEntityIOOutput + +class CPhysBallSocket: + m_flFriction = 0x508 # float + m_bEnableSwingLimit = 0x50C # bool + m_flSwingLimit = 0x510 # float + m_bEnableTwistLimit = 0x514 # bool + m_flMinTwistAngle = 0x518 # float + m_flMaxTwistAngle = 0x51C # float + +class CPhysBox: + m_damageType = 0x7C0 # int32_t + m_massScale = 0x7C4 # float + m_damageToEnableMotion = 0x7C8 # int32_t + m_flForceToEnableMotion = 0x7CC # float + m_angPreferredCarryAngles = 0x7D0 # QAngle + m_bNotSolidToWorld = 0x7DC # bool + m_bEnableUseOutput = 0x7DD # bool + m_iExploitableByPlayer = 0x7E0 # int32_t + m_flTouchOutputPerEntityDelay = 0x7E4 # float + m_OnDamaged = 0x7E8 # CEntityIOOutput + m_OnAwakened = 0x810 # CEntityIOOutput + m_OnMotionEnabled = 0x838 # CEntityIOOutput + m_OnPlayerUse = 0x860 # CEntityIOOutput + m_OnStartTouch = 0x888 # CEntityIOOutput + m_hCarryingPlayer = 0x8B0 # CHandle + +class CPhysConstraint: + m_nameAttach1 = 0x4B8 # CUtlSymbolLarge + m_nameAttach2 = 0x4C0 # CUtlSymbolLarge + m_breakSound = 0x4C8 # CUtlSymbolLarge + m_forceLimit = 0x4D0 # float + m_torqueLimit = 0x4D4 # float + m_teleportTick = 0x4D8 # uint32_t + m_minTeleportDistance = 0x4DC # float + m_OnBreak = 0x4E0 # CEntityIOOutput + +class CPhysExplosion: + m_bExplodeOnSpawn = 0x4B0 # bool + m_flMagnitude = 0x4B4 # float + m_flDamage = 0x4B8 # float + m_radius = 0x4BC # float + m_targetEntityName = 0x4C0 # CUtlSymbolLarge + m_flInnerRadius = 0x4C8 # float + m_flPushScale = 0x4CC # float + m_bConvertToDebrisWhenPossible = 0x4D0 # bool + m_OnPushedPlayer = 0x4D8 # CEntityIOOutput + +class CPhysFixed: + m_flLinearFrequency = 0x508 # float + m_flLinearDampingRatio = 0x50C # float + m_flAngularFrequency = 0x510 # float + m_flAngularDampingRatio = 0x514 # float + m_bEnableLinearConstraint = 0x518 # bool + m_bEnableAngularConstraint = 0x519 # bool + +class CPhysForce: + m_nameAttach = 0x4B8 # CUtlSymbolLarge + m_force = 0x4C0 # float + m_forceTime = 0x4C4 # float + m_attachedObject = 0x4C8 # CHandle + m_wasRestored = 0x4CC # bool + m_integrator = 0x4D0 # CConstantForceController + +class CPhysHinge: + m_soundInfo = 0x510 # ConstraintSoundInfo + m_NotifyMinLimitReached = 0x598 # CEntityIOOutput + m_NotifyMaxLimitReached = 0x5C0 # CEntityIOOutput + m_bAtMinLimit = 0x5E8 # bool + m_bAtMaxLimit = 0x5E9 # bool + m_hinge = 0x5EC # constraint_hingeparams_t + m_hingeFriction = 0x62C # float + m_systemLoadScale = 0x630 # float + m_bIsAxisLocal = 0x634 # bool + m_flMinRotation = 0x638 # float + m_flMaxRotation = 0x63C # float + m_flInitialRotation = 0x640 # float + m_flMotorFrequency = 0x644 # float + m_flMotorDampingRatio = 0x648 # float + m_flAngleSpeed = 0x64C # float + m_flAngleSpeedThreshold = 0x650 # float + m_OnStartMoving = 0x658 # CEntityIOOutput + m_OnStopMoving = 0x680 # CEntityIOOutput + +class CPhysImpact: + m_damage = 0x4B0 # float + m_distance = 0x4B4 # float + m_directionEntityName = 0x4B8 # CUtlSymbolLarge + +class CPhysLength: + m_offset = 0x508 # Vector[2] + m_vecAttach = 0x520 # Vector + m_addLength = 0x52C # float + m_minLength = 0x530 # float + m_totalLength = 0x534 # float + m_bEnableCollision = 0x538 # bool + +class CPhysMagnet: + m_OnMagnetAttach = 0x890 # CEntityIOOutput + m_OnMagnetDetach = 0x8B8 # CEntityIOOutput + m_massScale = 0x8E0 # float + m_forceLimit = 0x8E4 # float + m_torqueLimit = 0x8E8 # float + m_MagnettedEntities = 0x8F0 # CUtlVector + m_bActive = 0x908 # bool + m_bHasHitSomething = 0x909 # bool + m_flTotalMass = 0x90C # float + m_flRadius = 0x910 # float + m_flNextSuckTime = 0x914 # GameTime_t + m_iMaxObjectsAttached = 0x918 # int32_t + +class CPhysMotor: + m_nameAttach = 0x4B0 # CUtlSymbolLarge + m_hAttachedObject = 0x4B8 # CHandle + m_spinUp = 0x4BC # float + m_additionalAcceleration = 0x4C0 # float + m_angularAcceleration = 0x4C4 # float + m_lastTime = 0x4C8 # GameTime_t + m_motor = 0x4E0 # CMotorController + +class CPhysPulley: + m_position2 = 0x508 # Vector + m_offset = 0x514 # Vector[2] + m_addLength = 0x52C # float + m_gearRatio = 0x530 # float + +class CPhysSlideConstraint: + m_axisEnd = 0x510 # Vector + m_slideFriction = 0x51C # float + m_systemLoadScale = 0x520 # float + m_initialOffset = 0x524 # float + m_bEnableLinearConstraint = 0x528 # bool + m_bEnableAngularConstraint = 0x529 # bool + m_flMotorFrequency = 0x52C # float + m_flMotorDampingRatio = 0x530 # float + m_bUseEntityPivot = 0x534 # bool + m_soundInfo = 0x538 # ConstraintSoundInfo + +class CPhysThruster: + m_localOrigin = 0x510 # Vector + +class CPhysTorque: + m_axis = 0x510 # Vector + +class CPhysWheelConstraint: + m_flSuspensionFrequency = 0x508 # float + m_flSuspensionDampingRatio = 0x50C # float + m_flSuspensionHeightOffset = 0x510 # float + m_bEnableSuspensionLimit = 0x514 # bool + m_flMinSuspensionOffset = 0x518 # float + m_flMaxSuspensionOffset = 0x51C # float + m_bEnableSteeringLimit = 0x520 # bool + m_flMinSteeringAngle = 0x524 # float + m_flMaxSteeringAngle = 0x528 # float + m_flSteeringAxisFriction = 0x52C # float + m_flSpinAxisFriction = 0x530 # float + +class CPhysicsEntitySolver: + m_hMovingEntity = 0x4B8 # CHandle + m_hPhysicsBlocker = 0x4BC # CHandle + m_separationDuration = 0x4C0 # float + m_cancelTime = 0x4C4 # GameTime_t + +class CPhysicsProp: + m_MotionEnabled = 0xA10 # CEntityIOOutput + m_OnAwakened = 0xA38 # CEntityIOOutput + m_OnAwake = 0xA60 # CEntityIOOutput + m_OnAsleep = 0xA88 # CEntityIOOutput + m_OnPlayerUse = 0xAB0 # CEntityIOOutput + m_OnPlayerPickup = 0xAD8 # CEntityIOOutput + m_OnOutOfWorld = 0xB00 # CEntityIOOutput + m_massScale = 0xB28 # float + m_inertiaScale = 0xB2C # float + m_buoyancyScale = 0xB30 # float + m_damageType = 0xB34 # int32_t + m_damageToEnableMotion = 0xB38 # int32_t + m_flForceToEnableMotion = 0xB3C # float + m_bThrownByPlayer = 0xB40 # bool + m_bDroppedByPlayer = 0xB41 # bool + m_bTouchedByPlayer = 0xB42 # bool + m_bFirstCollisionAfterLaunch = 0xB43 # bool + m_iExploitableByPlayer = 0xB44 # int32_t + m_bHasBeenAwakened = 0xB48 # bool + m_bIsOverrideProp = 0xB49 # bool + m_fNextCheckDisableMotionContactsTime = 0xB4C # GameTime_t + m_iInitialGlowState = 0xB50 # int32_t + m_nGlowRange = 0xB54 # int32_t + m_nGlowRangeMin = 0xB58 # int32_t + m_glowColor = 0xB5C # Color + m_bForceNavIgnore = 0xB60 # bool + m_bNoNavmeshBlocker = 0xB61 # bool + m_bForceNpcExclude = 0xB62 # bool + m_bShouldAutoConvertBackFromDebris = 0xB63 # bool + m_bMuteImpactEffects = 0xB64 # bool + m_bAcceptDamageFromHeldObjects = 0xB6C # bool + m_bEnableUseOutput = 0xB6D # bool + m_bAwake = 0xB6E # bool + m_nCollisionGroupOverride = 0xB70 # int32_t + +class CPhysicsPropRespawnable: + m_vOriginalSpawnOrigin = 0xB78 # Vector + m_vOriginalSpawnAngles = 0xB84 # QAngle + m_vOriginalMins = 0xB90 # Vector + m_vOriginalMaxs = 0xB9C # Vector + m_flRespawnDuration = 0xBA8 # float + +class CPhysicsShake: + m_force = 0x8 # Vector + +class CPhysicsSpring: + m_flFrequency = 0x4B8 # float + m_flDampingRatio = 0x4BC # float + m_flRestLength = 0x4C0 # float + m_nameAttachStart = 0x4C8 # CUtlSymbolLarge + m_nameAttachEnd = 0x4D0 # CUtlSymbolLarge + m_start = 0x4D8 # Vector + m_end = 0x4E4 # Vector + m_teleportTick = 0x4F0 # uint32_t + +class CPhysicsWire: + m_nDensity = 0x4B0 # int32_t + +class CPlantedC4: + m_bBombTicking = 0x890 # bool + m_flC4Blow = 0x894 # GameTime_t + m_nBombSite = 0x898 # int32_t + m_nSourceSoundscapeHash = 0x89C # int32_t + m_OnBombDefused = 0x8A0 # CEntityIOOutput + m_OnBombBeginDefuse = 0x8C8 # CEntityIOOutput + m_OnBombDefuseAborted = 0x8F0 # CEntityIOOutput + m_bCannotBeDefused = 0x918 # bool + m_entitySpottedState = 0x920 # EntitySpottedState_t + m_nSpotRules = 0x938 # int32_t + m_bTrainingPlacedByPlayer = 0x93C # bool + m_bHasExploded = 0x93D # bool + m_flTimerLength = 0x940 # float + m_bBeingDefused = 0x944 # bool + m_fLastDefuseTime = 0x94C # GameTime_t + m_flDefuseLength = 0x954 # float + m_flDefuseCountDown = 0x958 # GameTime_t + m_bBombDefused = 0x95C # bool + m_hBombDefuser = 0x960 # CHandle + m_hControlPanel = 0x964 # CHandle + m_iProgressBarTime = 0x968 # int32_t + m_bVoiceAlertFired = 0x96C # bool + m_bVoiceAlertPlayed = 0x96D # bool[4] + m_flNextBotBeepTime = 0x974 # GameTime_t + m_bPlantedAfterPickup = 0x97C # bool + m_angCatchUpToPlayerEye = 0x980 # QAngle + m_flLastSpinDetectionTime = 0x98C # GameTime_t + +class CPlatTrigger: + m_pPlatform = 0x700 # CHandle + +class CPlayerControllerComponent: + __m_pChainEntity = 0x8 # CNetworkVarChainer + +class CPlayerPawnComponent: + __m_pChainEntity = 0x8 # CNetworkVarChainer + +class CPlayerPing: + m_hPlayer = 0x4B8 # CHandle + m_hPingedEntity = 0x4BC # CHandle + m_iType = 0x4C0 # int32_t + m_bUrgent = 0x4C4 # bool + m_szPlaceName = 0x4C5 # char[18] + +class CPlayerSprayDecal: + m_nUniqueID = 0x700 # int32_t + m_unAccountID = 0x704 # uint32_t + m_unTraceID = 0x708 # uint32_t + m_rtGcTime = 0x70C # uint32_t + m_vecEndPos = 0x710 # Vector + m_vecStart = 0x71C # Vector + m_vecLeft = 0x728 # Vector + m_vecNormal = 0x734 # Vector + m_nPlayer = 0x740 # int32_t + m_nEntity = 0x744 # int32_t + m_nHitbox = 0x748 # int32_t + m_flCreationTime = 0x74C # float + m_nTintID = 0x750 # int32_t + m_nVersion = 0x754 # uint8_t + m_ubSignature = 0x755 # uint8_t[128] + +class CPlayerVisibility: + m_flVisibilityStrength = 0x4B0 # float + m_flFogDistanceMultiplier = 0x4B4 # float + m_flFogMaxDensityMultiplier = 0x4B8 # float + m_flFadeTime = 0x4BC # float + m_bStartDisabled = 0x4C0 # bool + m_bIsEnabled = 0x4C1 # bool + +class CPlayer_CameraServices: + m_vecCsViewPunchAngle = 0x40 # QAngle + m_nCsViewPunchAngleTick = 0x4C # GameTick_t + m_flCsViewPunchAngleTickRatio = 0x50 # float + m_PlayerFog = 0x58 # fogplayerparams_t + m_hColorCorrectionCtrl = 0x98 # CHandle + m_hViewEntity = 0x9C # CHandle + m_hTonemapController = 0xA0 # CHandle + m_audio = 0xA8 # audioparams_t + m_PostProcessingVolumes = 0x120 # CNetworkUtlVectorBase> + m_flOldPlayerZ = 0x138 # float + m_flOldPlayerViewOffsetZ = 0x13C # float + m_hTriggerSoundscapeList = 0x158 # CUtlVector> + +class CPlayer_MovementServices: + m_nImpulse = 0x40 # int32_t + m_nButtons = 0x48 # CInButtonState + m_nQueuedButtonDownMask = 0x68 # uint64_t + m_nQueuedButtonChangeMask = 0x70 # uint64_t + m_nButtonDoublePressed = 0x78 # uint64_t + m_pButtonPressedCmdNumber = 0x80 # uint32_t[64] + m_nLastCommandNumberProcessed = 0x180 # uint32_t + m_nToggleButtonDownMask = 0x188 # uint64_t + m_flMaxspeed = 0x190 # float + m_arrForceSubtickMoveWhen = 0x194 # float[4] + m_flForwardMove = 0x1A4 # float + m_flLeftMove = 0x1A8 # float + m_flUpMove = 0x1AC # float + m_vecLastMovementImpulses = 0x1B0 # Vector + m_vecOldViewAngles = 0x1BC # QAngle + +class CPlayer_MovementServices_Humanoid: + m_flStepSoundTime = 0x1D0 # float + m_flFallVelocity = 0x1D4 # float + m_bInCrouch = 0x1D8 # bool + m_nCrouchState = 0x1DC # uint32_t + m_flCrouchTransitionStartTime = 0x1E0 # GameTime_t + m_bDucked = 0x1E4 # bool + m_bDucking = 0x1E5 # bool + m_bInDuckJump = 0x1E6 # bool + m_groundNormal = 0x1E8 # Vector + m_flSurfaceFriction = 0x1F4 # float + m_surfaceProps = 0x1F8 # CUtlStringToken + m_nStepside = 0x208 # int32_t + m_iTargetVolume = 0x20C # int32_t + m_vecSmoothedVelocity = 0x210 # Vector + +class CPlayer_ObserverServices: + m_iObserverMode = 0x40 # uint8_t + m_hObserverTarget = 0x44 # CHandle + m_iObserverLastMode = 0x48 # ObserverMode_t + m_bForcedObserverMode = 0x4C # bool + +class CPlayer_WeaponServices: + m_bAllowSwitchToNoWeapon = 0x40 # bool + m_hMyWeapons = 0x48 # CNetworkUtlVectorBase> + m_hActiveWeapon = 0x60 # CHandle + m_hLastWeapon = 0x64 # CHandle + m_iAmmo = 0x68 # uint16_t[32] + m_bPreventWeaponPickup = 0xA8 # bool + +class CPointAngleSensor: + m_bDisabled = 0x4B0 # bool + m_nLookAtName = 0x4B8 # CUtlSymbolLarge + m_hTargetEntity = 0x4C0 # CHandle + m_hLookAtEntity = 0x4C4 # CHandle + m_flDuration = 0x4C8 # float + m_flDotTolerance = 0x4CC # float + m_flFacingTime = 0x4D0 # GameTime_t + m_bFired = 0x4D4 # bool + m_OnFacingLookat = 0x4D8 # CEntityIOOutput + m_OnNotFacingLookat = 0x500 # CEntityIOOutput + m_TargetDir = 0x528 # CEntityOutputTemplate + m_FacingPercentage = 0x550 # CEntityOutputTemplate + +class CPointAngularVelocitySensor: + m_hTargetEntity = 0x4B0 # CHandle + m_flThreshold = 0x4B4 # float + m_nLastCompareResult = 0x4B8 # int32_t + m_nLastFireResult = 0x4BC # int32_t + m_flFireTime = 0x4C0 # GameTime_t + m_flFireInterval = 0x4C4 # float + m_flLastAngVelocity = 0x4C8 # float + m_lastOrientation = 0x4CC # QAngle + m_vecAxis = 0x4D8 # Vector + m_bUseHelper = 0x4E4 # bool + m_AngularVelocity = 0x4E8 # CEntityOutputTemplate + m_OnLessThan = 0x510 # CEntityIOOutput + m_OnLessThanOrEqualTo = 0x538 # CEntityIOOutput + m_OnGreaterThan = 0x560 # CEntityIOOutput + m_OnGreaterThanOrEqualTo = 0x588 # CEntityIOOutput + m_OnEqualTo = 0x5B0 # CEntityIOOutput + +class CPointCamera: + m_FOV = 0x4B0 # float + m_Resolution = 0x4B4 # float + m_bFogEnable = 0x4B8 # bool + m_FogColor = 0x4B9 # Color + m_flFogStart = 0x4C0 # float + m_flFogEnd = 0x4C4 # float + m_flFogMaxDensity = 0x4C8 # float + m_bActive = 0x4CC # bool + m_bUseScreenAspectRatio = 0x4CD # bool + m_flAspectRatio = 0x4D0 # float + m_bNoSky = 0x4D4 # bool + m_fBrightness = 0x4D8 # float + m_flZFar = 0x4DC # float + m_flZNear = 0x4E0 # float + m_bCanHLTVUse = 0x4E4 # bool + m_bDofEnabled = 0x4E5 # bool + m_flDofNearBlurry = 0x4E8 # float + m_flDofNearCrisp = 0x4EC # float + m_flDofFarCrisp = 0x4F0 # float + m_flDofFarBlurry = 0x4F4 # float + m_flDofTiltToGround = 0x4F8 # float + m_TargetFOV = 0x4FC # float + m_DegreesPerSecond = 0x500 # float + m_bIsOn = 0x504 # bool + m_pNext = 0x508 # CPointCamera* + +class CPointCameraVFOV: + m_flVerticalFOV = 0x510 # float + +class CPointClientUIDialog: + m_hActivator = 0x8B0 # CHandle + m_bStartEnabled = 0x8B4 # bool + +class CPointClientUIWorldPanel: + m_bIgnoreInput = 0x8B0 # bool + m_bLit = 0x8B1 # bool + m_bFollowPlayerAcrossTeleport = 0x8B2 # bool + m_flWidth = 0x8B4 # float + m_flHeight = 0x8B8 # float + m_flDPI = 0x8BC # float + m_flInteractDistance = 0x8C0 # float + m_flDepthOffset = 0x8C4 # float + m_unOwnerContext = 0x8C8 # uint32_t + m_unHorizontalAlign = 0x8CC # uint32_t + m_unVerticalAlign = 0x8D0 # uint32_t + m_unOrientation = 0x8D4 # uint32_t + m_bAllowInteractionFromAllSceneWorlds = 0x8D8 # bool + m_vecCSSClasses = 0x8E0 # CNetworkUtlVectorBase + m_bOpaque = 0x8F8 # bool + m_bNoDepth = 0x8F9 # bool + m_bRenderBackface = 0x8FA # bool + m_bUseOffScreenIndicator = 0x8FB # bool + m_bExcludeFromSaveGames = 0x8FC # bool + m_bGrabbable = 0x8FD # bool + m_bOnlyRenderToTexture = 0x8FE # bool + m_bDisableMipGen = 0x8FF # bool + m_nExplicitImageLayout = 0x900 # int32_t + +class CPointClientUIWorldTextPanel: + m_messageText = 0x908 # char[512] + +class CPointCommentaryNode: + m_iszPreCommands = 0x890 # CUtlSymbolLarge + m_iszPostCommands = 0x898 # CUtlSymbolLarge + m_iszCommentaryFile = 0x8A0 # CUtlSymbolLarge + m_iszViewTarget = 0x8A8 # CUtlSymbolLarge + m_hViewTarget = 0x8B0 # CHandle + m_hViewTargetAngles = 0x8B4 # CHandle + m_iszViewPosition = 0x8B8 # CUtlSymbolLarge + m_hViewPosition = 0x8C0 # CHandle + m_hViewPositionMover = 0x8C4 # CHandle + m_bPreventMovement = 0x8C8 # bool + m_bUnderCrosshair = 0x8C9 # bool + m_bUnstoppable = 0x8CA # bool + m_flFinishedTime = 0x8CC # GameTime_t + m_vecFinishOrigin = 0x8D0 # Vector + m_vecOriginalAngles = 0x8DC # QAngle + m_vecFinishAngles = 0x8E8 # QAngle + m_bPreventChangesWhileMoving = 0x8F4 # bool + m_bDisabled = 0x8F5 # bool + m_vecTeleportOrigin = 0x8F8 # Vector + m_flAbortedPlaybackAt = 0x904 # GameTime_t + m_pOnCommentaryStarted = 0x908 # CEntityIOOutput + m_pOnCommentaryStopped = 0x930 # CEntityIOOutput + m_bActive = 0x958 # bool + m_flStartTime = 0x95C # GameTime_t + m_flStartTimeInCommentary = 0x960 # float + m_iszTitle = 0x968 # CUtlSymbolLarge + m_iszSpeakers = 0x970 # CUtlSymbolLarge + m_iNodeNumber = 0x978 # int32_t + m_iNodeNumberMax = 0x97C # int32_t + m_bListenedTo = 0x980 # bool + +class CPointEntityFinder: + m_hEntity = 0x4B0 # CHandle + m_iFilterName = 0x4B8 # CUtlSymbolLarge + m_hFilter = 0x4C0 # CHandle + m_iRefName = 0x4C8 # CUtlSymbolLarge + m_hReference = 0x4D0 # CHandle + m_FindMethod = 0x4D4 # EntFinderMethod_t + m_OnFoundEntity = 0x4D8 # CEntityIOOutput + +class CPointGamestatsCounter: + m_strStatisticName = 0x4B0 # CUtlSymbolLarge + m_bDisabled = 0x4B8 # bool + +class CPointGiveAmmo: + m_pActivator = 0x4B0 # CHandle + +class CPointHurt: + m_nDamage = 0x4B0 # int32_t + m_bitsDamageType = 0x4B4 # int32_t + m_flRadius = 0x4B8 # float + m_flDelay = 0x4BC # float + m_strTarget = 0x4C0 # CUtlSymbolLarge + m_pActivator = 0x4C8 # CHandle + +class CPointPrefab: + m_targetMapName = 0x4B0 # CUtlSymbolLarge + m_forceWorldGroupID = 0x4B8 # CUtlSymbolLarge + m_associatedRelayTargetName = 0x4C0 # CUtlSymbolLarge + m_fixupNames = 0x4C8 # bool + m_bLoadDynamic = 0x4C9 # bool + m_associatedRelayEntity = 0x4CC # CHandle + +class CPointProximitySensor: + m_bDisabled = 0x4B0 # bool + m_hTargetEntity = 0x4B4 # CHandle + m_Distance = 0x4B8 # CEntityOutputTemplate + +class CPointPulse: + m_sNameFixupStaticPrefix = 0x5C8 # CUtlSymbolLarge + m_sNameFixupParent = 0x5D0 # CUtlSymbolLarge + m_sNameFixupLocal = 0x5D8 # CUtlSymbolLarge + +class CPointPush: + m_bEnabled = 0x4B0 # bool + m_flMagnitude = 0x4B4 # float + m_flRadius = 0x4B8 # float + m_flInnerRadius = 0x4BC # float + m_flConeOfInfluence = 0x4C0 # float + m_iszFilterName = 0x4C8 # CUtlSymbolLarge + m_hFilter = 0x4D0 # CHandle + +class CPointTeleport: + m_vSaveOrigin = 0x4B0 # Vector + m_vSaveAngles = 0x4BC # QAngle + m_bTeleportParentedEntities = 0x4C8 # bool + m_bTeleportUseCurrentAngle = 0x4C9 # bool + +class CPointTemplate: + m_iszWorldName = 0x4B0 # CUtlSymbolLarge + m_iszSource2EntityLumpName = 0x4B8 # CUtlSymbolLarge + m_iszEntityFilterName = 0x4C0 # CUtlSymbolLarge + m_flTimeoutInterval = 0x4C8 # float + m_bAsynchronouslySpawnEntities = 0x4CC # bool + m_pOutputOnSpawned = 0x4D0 # CEntityIOOutput + m_clientOnlyEntityBehavior = 0x4F8 # PointTemplateClientOnlyEntityBehavior_t + m_ownerSpawnGroupType = 0x4FC # PointTemplateOwnerSpawnGroupType_t + m_createdSpawnGroupHandles = 0x500 # CUtlVector + m_SpawnedEntityHandles = 0x518 # CUtlVector + m_ScriptSpawnCallback = 0x530 # HSCRIPT + m_ScriptCallbackScope = 0x538 # HSCRIPT + +class CPointValueRemapper: + m_bDisabled = 0x4B0 # bool + m_bUpdateOnClient = 0x4B1 # bool + m_nInputType = 0x4B4 # ValueRemapperInputType_t + m_iszRemapLineStartName = 0x4B8 # CUtlSymbolLarge + m_iszRemapLineEndName = 0x4C0 # CUtlSymbolLarge + m_hRemapLineStart = 0x4C8 # CHandle + m_hRemapLineEnd = 0x4CC # CHandle + m_flMaximumChangePerSecond = 0x4D0 # float + m_flDisengageDistance = 0x4D4 # float + m_flEngageDistance = 0x4D8 # float + m_bRequiresUseKey = 0x4DC # bool + m_nOutputType = 0x4E0 # ValueRemapperOutputType_t + m_iszOutputEntityName = 0x4E8 # CUtlSymbolLarge + m_iszOutputEntity2Name = 0x4F0 # CUtlSymbolLarge + m_iszOutputEntity3Name = 0x4F8 # CUtlSymbolLarge + m_iszOutputEntity4Name = 0x500 # CUtlSymbolLarge + m_hOutputEntities = 0x508 # CNetworkUtlVectorBase> + m_nHapticsType = 0x520 # ValueRemapperHapticsType_t + m_nMomentumType = 0x524 # ValueRemapperMomentumType_t + m_flMomentumModifier = 0x528 # float + m_flSnapValue = 0x52C # float + m_flCurrentMomentum = 0x530 # float + m_nRatchetType = 0x534 # ValueRemapperRatchetType_t + m_flRatchetOffset = 0x538 # float + m_flInputOffset = 0x53C # float + m_bEngaged = 0x540 # bool + m_bFirstUpdate = 0x541 # bool + m_flPreviousValue = 0x544 # float + m_flPreviousUpdateTickTime = 0x548 # GameTime_t + m_vecPreviousTestPoint = 0x54C # Vector + m_hUsingPlayer = 0x558 # CHandle + m_flCustomOutputValue = 0x55C # float + m_iszSoundEngage = 0x560 # CUtlSymbolLarge + m_iszSoundDisengage = 0x568 # CUtlSymbolLarge + m_iszSoundReachedValueZero = 0x570 # CUtlSymbolLarge + m_iszSoundReachedValueOne = 0x578 # CUtlSymbolLarge + m_iszSoundMovingLoop = 0x580 # CUtlSymbolLarge + m_Position = 0x590 # CEntityOutputTemplate + m_PositionDelta = 0x5B8 # CEntityOutputTemplate + m_OnReachedValueZero = 0x5E0 # CEntityIOOutput + m_OnReachedValueOne = 0x608 # CEntityIOOutput + m_OnReachedValueCustom = 0x630 # CEntityIOOutput + m_OnEngage = 0x658 # CEntityIOOutput + m_OnDisengage = 0x680 # CEntityIOOutput + +class CPointVelocitySensor: + m_hTargetEntity = 0x4B0 # CHandle + m_vecAxis = 0x4B4 # Vector + m_bEnabled = 0x4C0 # bool + m_fPrevVelocity = 0x4C4 # float + m_flAvgInterval = 0x4C8 # float + m_Velocity = 0x4D0 # CEntityOutputTemplate + +class CPointWorldText: + m_messageText = 0x700 # char[512] + m_FontName = 0x900 # char[64] + m_bEnabled = 0x940 # bool + m_bFullbright = 0x941 # bool + m_flWorldUnitsPerPx = 0x944 # float + m_flFontSize = 0x948 # float + m_flDepthOffset = 0x94C # float + m_Color = 0x950 # Color + m_nJustifyHorizontal = 0x954 # PointWorldTextJustifyHorizontal_t + m_nJustifyVertical = 0x958 # PointWorldTextJustifyVertical_t + m_nReorientMode = 0x95C # PointWorldTextReorientMode_t + +class CPostProcessingVolume: + m_hPostSettings = 0x8B8 # CStrongHandle + m_flFadeDuration = 0x8C0 # float + m_flMinLogExposure = 0x8C4 # float + m_flMaxLogExposure = 0x8C8 # float + m_flMinExposure = 0x8CC # float + m_flMaxExposure = 0x8D0 # float + m_flExposureCompensation = 0x8D4 # float + m_flExposureFadeSpeedUp = 0x8D8 # float + m_flExposureFadeSpeedDown = 0x8DC # float + m_flTonemapEVSmoothingRange = 0x8E0 # float + m_bMaster = 0x8E4 # bool + m_bExposureControl = 0x8E5 # bool + m_flRate = 0x8E8 # float + m_flTonemapPercentTarget = 0x8EC # float + m_flTonemapPercentBrightPixels = 0x8F0 # float + m_flTonemapMinAvgLum = 0x8F4 # float + +class CPrecipitationVData: + m_szParticlePrecipitationEffect = 0x28 # CResourceNameTyped> + m_flInnerDistance = 0x108 # float + m_nAttachType = 0x10C # ParticleAttachment_t + m_bBatchSameVolumeType = 0x110 # bool + m_nRTEnvCP = 0x114 # int32_t + m_nRTEnvCPComponent = 0x118 # int32_t + m_szModifier = 0x120 # CUtlString + +class CProjectedDecal: + m_nTexture = 0x4B0 # int32_t + m_flDistance = 0x4B4 # float + +class CPropDoorRotating: + m_vecAxis = 0xD98 # Vector + m_flDistance = 0xDA4 # float + m_eSpawnPosition = 0xDA8 # PropDoorRotatingSpawnPos_t + m_eOpenDirection = 0xDAC # PropDoorRotatingOpenDirection_e + m_eCurrentOpenDirection = 0xDB0 # PropDoorRotatingOpenDirection_e + m_flAjarAngle = 0xDB4 # float + m_angRotationAjarDeprecated = 0xDB8 # QAngle + m_angRotationClosed = 0xDC4 # QAngle + m_angRotationOpenForward = 0xDD0 # QAngle + m_angRotationOpenBack = 0xDDC # QAngle + m_angGoal = 0xDE8 # QAngle + m_vecForwardBoundsMin = 0xDF4 # Vector + m_vecForwardBoundsMax = 0xE00 # Vector + m_vecBackBoundsMin = 0xE0C # Vector + m_vecBackBoundsMax = 0xE18 # Vector + m_bAjarDoorShouldntAlwaysOpen = 0xE24 # bool + m_hEntityBlocker = 0xE28 # CHandle + +class CPropDoorRotatingBreakable: + m_bBreakable = 0xE30 # bool + m_isAbleToCloseAreaPortals = 0xE31 # bool + m_currentDamageState = 0xE34 # int32_t + m_damageStates = 0xE38 # CUtlVector + +class CPulseCell_Inflow_GameEvent: + m_EventName = 0x70 # CBufferString + +class CPulseCell_Outflow_PlayVCD: + m_vcdFilename = 0x48 # CUtlString + m_OnFinished = 0x50 # CPulse_OutflowConnection + m_Triggers = 0x60 # CUtlVector + +class CPulseCell_SoundEventStart: + m_Type = 0x48 # SoundEventStartType_t + +class CPulseCell_Step_EntFire: + m_Input = 0x48 # CUtlString + +class CPulseCell_Step_SetAnimGraphParam: + m_ParamName = 0x48 # CUtlString + +class CPulseCell_Value_FindEntByName: + m_EntityType = 0x48 # CUtlString + +class CRR_Response: + m_Type = 0x0 # uint8_t + m_szResponseName = 0x1 # char[192] + m_szMatchingRule = 0xC1 # char[128] + m_Params = 0x148 # ResponseParams + m_fMatchScore = 0x168 # float + m_szSpeakerContext = 0x170 # char* + m_szWorldContext = 0x178 # char* + m_Followup = 0x180 # ResponseFollowup + m_pchCriteriaNames = 0x1B8 # CUtlVector + m_pchCriteriaValues = 0x1D0 # CUtlVector + +class CRagdollConstraint: + m_xmin = 0x508 # float + m_xmax = 0x50C # float + m_ymin = 0x510 # float + m_ymax = 0x514 # float + m_zmin = 0x518 # float + m_zmax = 0x51C # float + m_xfriction = 0x520 # float + m_yfriction = 0x524 # float + m_zfriction = 0x528 # float + +class CRagdollMagnet: + m_bDisabled = 0x4B0 # bool + m_radius = 0x4B4 # float + m_force = 0x4B8 # float + m_axis = 0x4BC # Vector + +class CRagdollManager: + m_iCurrentMaxRagdollCount = 0x4B0 # int8_t + m_iMaxRagdollCount = 0x4B4 # int32_t + m_bSaveImportant = 0x4B8 # bool + +class CRagdollProp: + m_ragdoll = 0x898 # ragdoll_t + m_bStartDisabled = 0x8D0 # bool + m_ragPos = 0x8D8 # CNetworkUtlVectorBase + m_ragAngles = 0x8F0 # CNetworkUtlVectorBase + m_hRagdollSource = 0x908 # CHandle + m_lastUpdateTickCount = 0x90C # uint32_t + m_allAsleep = 0x910 # bool + m_bFirstCollisionAfterLaunch = 0x911 # bool + m_hDamageEntity = 0x914 # CHandle + m_hKiller = 0x918 # CHandle + m_hPhysicsAttacker = 0x91C # CHandle + m_flLastPhysicsInfluenceTime = 0x920 # GameTime_t + m_flFadeOutStartTime = 0x924 # GameTime_t + m_flFadeTime = 0x928 # float + m_vecLastOrigin = 0x92C # Vector + m_flAwakeTime = 0x938 # GameTime_t + m_flLastOriginChangeTime = 0x93C # GameTime_t + m_nBloodColor = 0x940 # int32_t + m_strOriginClassName = 0x948 # CUtlSymbolLarge + m_strSourceClassName = 0x950 # CUtlSymbolLarge + m_bHasBeenPhysgunned = 0x958 # bool + m_bShouldTeleportPhysics = 0x959 # bool + m_flBlendWeight = 0x95C # float + m_flDefaultFadeScale = 0x960 # float + m_ragdollMins = 0x968 # CUtlVector + m_ragdollMaxs = 0x980 # CUtlVector + m_bShouldDeleteActivationRecord = 0x998 # bool + m_bValidatePoweredRagdollPose = 0x9F8 # bool + +class CRagdollPropAttached: + m_boneIndexAttached = 0xA38 # uint32_t + m_ragdollAttachedObjectIndex = 0xA3C # uint32_t + m_attachmentPointBoneSpace = 0xA40 # Vector + m_attachmentPointRagdollSpace = 0xA4C # Vector + m_bShouldDetach = 0xA58 # bool + m_bShouldDeleteAttachedActivationRecord = 0xA68 # bool + +class CRandSimTimer: + m_minInterval = 0x8 # float + m_maxInterval = 0xC # float + +class CRandStopwatch: + m_minInterval = 0xC # float + m_maxInterval = 0x10 # float + +class CRangeFloat: + m_pValue = 0x0 # float[2] + +class CRangeInt: + m_pValue = 0x0 # int32_t[2] + +class CRectLight: + m_bShowLight = 0x938 # bool + +class CRemapFloat: + m_pValue = 0x0 # float[4] + +class CRenderComponent: + __m_pChainEntity = 0x10 # CNetworkVarChainer + m_bIsRenderingWithViewModels = 0x50 # bool + m_nSplitscreenFlags = 0x54 # uint32_t + m_bEnableRendering = 0x60 # bool + m_bInterpolationReadyToDraw = 0xB0 # bool + +class CResponseCriteriaSet: + m_nNumPrefixedContexts = 0x28 # int32_t + m_bOverrideOnAppend = 0x2C # bool + +class CResponseQueue: + m_ExpresserTargets = 0x50 # CUtlVector + +class CResponseQueue_CDeferredResponse: + m_contexts = 0x10 # CResponseCriteriaSet + m_fDispatchTime = 0x40 # float + m_hIssuer = 0x44 # CHandle + m_response = 0x50 # CRR_Response + m_bResponseValid = 0x238 # bool + +class CRetakeGameRules: + m_nMatchSeed = 0xF8 # int32_t + m_bBlockersPresent = 0xFC # bool + m_bRoundInProgress = 0xFD # bool + m_iFirstSecondHalfRound = 0x100 # int32_t + m_iBombSite = 0x104 # int32_t + +class CRevertSaved: + m_loadTime = 0x700 # float + m_Duration = 0x704 # float + m_HoldTime = 0x708 # float + +class CRopeKeyframe: + m_RopeFlags = 0x708 # uint16_t + m_iNextLinkName = 0x710 # CUtlSymbolLarge + m_Slack = 0x718 # int16_t + m_Width = 0x71C # float + m_TextureScale = 0x720 # float + m_nSegments = 0x724 # uint8_t + m_bConstrainBetweenEndpoints = 0x725 # bool + m_strRopeMaterialModel = 0x728 # CUtlSymbolLarge + m_iRopeMaterialModelIndex = 0x730 # CStrongHandle + m_Subdiv = 0x738 # uint8_t + m_nChangeCount = 0x739 # uint8_t + m_RopeLength = 0x73A # int16_t + m_fLockedPoints = 0x73C # uint8_t + m_bCreatedFromMapFile = 0x73D # bool + m_flScrollSpeed = 0x740 # float + m_bStartPointValid = 0x744 # bool + m_bEndPointValid = 0x745 # bool + m_hStartPoint = 0x748 # CHandle + m_hEndPoint = 0x74C # CHandle + m_iStartAttachment = 0x750 # AttachmentHandle_t + m_iEndAttachment = 0x751 # AttachmentHandle_t + +class CRotDoor: + m_bSolidBsp = 0x988 # bool + +class CRuleEntity: + m_iszMaster = 0x700 # CUtlSymbolLarge + +class CRulePointEntity: + m_Score = 0x708 # int32_t + +class CSAdditionalMatchStats_t: + m_numRoundsSurvived = 0x14 # int32_t + m_maxNumRoundsSurvived = 0x18 # int32_t + m_numRoundsSurvivedTotal = 0x1C # int32_t + m_iRoundsWonWithoutPurchase = 0x20 # int32_t + m_iRoundsWonWithoutPurchaseTotal = 0x24 # int32_t + m_numFirstKills = 0x28 # int32_t + m_numClutchKills = 0x2C # int32_t + m_numPistolKills = 0x30 # int32_t + m_numSniperKills = 0x34 # int32_t + m_iNumSuicides = 0x38 # int32_t + m_iNumTeamKills = 0x3C # int32_t + m_iTeamDamage = 0x40 # int32_t + +class CSAdditionalPerRoundStats_t: + m_numChickensKilled = 0x0 # int32_t + m_killsWhileBlind = 0x4 # int32_t + m_bombCarrierkills = 0x8 # int32_t + m_iBurnDamageInflicted = 0xC # int32_t + m_iDinks = 0x10 # int32_t + +class CSMatchStats_t: + m_iEnemy5Ks = 0x68 # int32_t + m_iEnemy4Ks = 0x6C # int32_t + m_iEnemy3Ks = 0x70 # int32_t + m_iEnemy2Ks = 0x74 # int32_t + m_iUtility_Count = 0x78 # int32_t + m_iUtility_Successes = 0x7C # int32_t + m_iUtility_Enemies = 0x80 # int32_t + m_iFlash_Count = 0x84 # int32_t + m_iFlash_Successes = 0x88 # int32_t + m_nHealthPointsRemovedTotal = 0x8C # int32_t + m_nHealthPointsDealtTotal = 0x90 # int32_t + m_nShotsFiredTotal = 0x94 # int32_t + m_nShotsOnTargetTotal = 0x98 # int32_t + m_i1v1Count = 0x9C # int32_t + m_i1v1Wins = 0xA0 # int32_t + m_i1v2Count = 0xA4 # int32_t + m_i1v2Wins = 0xA8 # int32_t + m_iEntryCount = 0xAC # int32_t + m_iEntryWins = 0xB0 # int32_t + +class CSPerRoundStats_t: + m_iKills = 0x30 # int32_t + m_iDeaths = 0x34 # int32_t + m_iAssists = 0x38 # int32_t + m_iDamage = 0x3C # int32_t + m_iEquipmentValue = 0x40 # int32_t + m_iMoneySaved = 0x44 # int32_t + m_iKillReward = 0x48 # int32_t + m_iLiveTime = 0x4C # int32_t + m_iHeadShotKills = 0x50 # int32_t + m_iObjective = 0x54 # int32_t + m_iCashEarned = 0x58 # int32_t + m_iUtilityDamage = 0x5C # int32_t + m_iEnemiesFlashed = 0x60 # int32_t + +class CSceneEntity: + m_iszSceneFile = 0x4B8 # CUtlSymbolLarge + m_iszResumeSceneFile = 0x4C0 # CUtlSymbolLarge + m_iszTarget1 = 0x4C8 # CUtlSymbolLarge + m_iszTarget2 = 0x4D0 # CUtlSymbolLarge + m_iszTarget3 = 0x4D8 # CUtlSymbolLarge + m_iszTarget4 = 0x4E0 # CUtlSymbolLarge + m_iszTarget5 = 0x4E8 # CUtlSymbolLarge + m_iszTarget6 = 0x4F0 # CUtlSymbolLarge + m_iszTarget7 = 0x4F8 # CUtlSymbolLarge + m_iszTarget8 = 0x500 # CUtlSymbolLarge + m_hTarget1 = 0x508 # CHandle + m_hTarget2 = 0x50C # CHandle + m_hTarget3 = 0x510 # CHandle + m_hTarget4 = 0x514 # CHandle + m_hTarget5 = 0x518 # CHandle + m_hTarget6 = 0x51C # CHandle + m_hTarget7 = 0x520 # CHandle + m_hTarget8 = 0x524 # CHandle + m_bIsPlayingBack = 0x528 # bool + m_bPaused = 0x529 # bool + m_bMultiplayer = 0x52A # bool + m_bAutogenerated = 0x52B # bool + m_flForceClientTime = 0x52C # float + m_flCurrentTime = 0x530 # float + m_flFrameTime = 0x534 # float + m_bCancelAtNextInterrupt = 0x538 # bool + m_fPitch = 0x53C # float + m_bAutomated = 0x540 # bool + m_nAutomatedAction = 0x544 # int32_t + m_flAutomationDelay = 0x548 # float + m_flAutomationTime = 0x54C # float + m_hWaitingForThisResumeScene = 0x550 # CHandle + m_bWaitingForResumeScene = 0x554 # bool + m_bPausedViaInput = 0x555 # bool + m_bPauseAtNextInterrupt = 0x556 # bool + m_bWaitingForActor = 0x557 # bool + m_bWaitingForInterrupt = 0x558 # bool + m_bInterruptedActorsScenes = 0x559 # bool + m_bBreakOnNonIdle = 0x55A # bool + m_hActorList = 0x560 # CNetworkUtlVectorBase> + m_hRemoveActorList = 0x578 # CUtlVector> + m_nSceneFlushCounter = 0x5A0 # int32_t + m_nSceneStringIndex = 0x5A4 # uint16_t + m_OnStart = 0x5A8 # CEntityIOOutput + m_OnCompletion = 0x5D0 # CEntityIOOutput + m_OnCanceled = 0x5F8 # CEntityIOOutput + m_OnPaused = 0x620 # CEntityIOOutput + m_OnResumed = 0x648 # CEntityIOOutput + m_OnTrigger = 0x670 # CEntityIOOutput[16] + m_hInterruptScene = 0x980 # CHandle + m_nInterruptCount = 0x984 # int32_t + m_bSceneMissing = 0x988 # bool + m_bInterrupted = 0x989 # bool + m_bCompletedEarly = 0x98A # bool + m_bInterruptSceneFinished = 0x98B # bool + m_bRestoring = 0x98C # bool + m_hNotifySceneCompletion = 0x990 # CUtlVector> + m_hListManagers = 0x9A8 # CUtlVector> + m_iszSoundName = 0x9E8 # CUtlSymbolLarge + m_hActor = 0x9F0 # CHandle + m_hActivator = 0x9F4 # CHandle + m_BusyActor = 0x9F8 # int32_t + m_iPlayerDeathBehavior = 0x9FC # SceneOnPlayerDeath_t + +class CSceneEventInfo: + m_iLayer = 0x0 # int32_t + m_iPriority = 0x4 # int32_t + m_hSequence = 0x8 # HSequence + m_flWeight = 0xC # float + m_bIsMoving = 0x10 # bool + m_bHasArrived = 0x11 # bool + m_flInitialYaw = 0x14 # float + m_flTargetYaw = 0x18 # float + m_flFacingYaw = 0x1C # float + m_nType = 0x20 # int32_t + m_flNext = 0x24 # GameTime_t + m_bIsGesture = 0x28 # bool + m_bShouldRemove = 0x29 # bool + m_hTarget = 0x54 # CHandle + m_nSceneEventId = 0x58 # uint32_t + m_bClientSide = 0x5C # bool + m_bStarted = 0x5D # bool + +class CSceneListManager: + m_hListManagers = 0x4B0 # CUtlVector> + m_iszScenes = 0x4C8 # CUtlSymbolLarge[16] + m_hScenes = 0x548 # CHandle[16] + +class CScriptComponent: + m_scriptClassName = 0x30 # CUtlSymbolLarge + +class CScriptItem: + m_OnPlayerPickup = 0x968 # CEntityIOOutput + m_MoveTypeOverride = 0x990 # MoveType_t + +class CScriptNavBlocker: + m_vExtent = 0x710 # Vector + +class CScriptTriggerHurt: + m_vExtent = 0x948 # Vector + +class CScriptTriggerMultiple: + m_vExtent = 0x8D0 # Vector + +class CScriptTriggerOnce: + m_vExtent = 0x8D0 # Vector + +class CScriptTriggerPush: + m_vExtent = 0x8D0 # Vector + +class CScriptUniformRandomStream: + m_hScriptScope = 0x8 # HSCRIPT + m_nInitialSeed = 0x9C # int32_t + +class CScriptedSequence: + m_iszEntry = 0x4B0 # CUtlSymbolLarge + m_iszPreIdle = 0x4B8 # CUtlSymbolLarge + m_iszPlay = 0x4C0 # CUtlSymbolLarge + m_iszPostIdle = 0x4C8 # CUtlSymbolLarge + m_iszModifierToAddOnPlay = 0x4D0 # CUtlSymbolLarge + m_iszNextScript = 0x4D8 # CUtlSymbolLarge + m_iszEntity = 0x4E0 # CUtlSymbolLarge + m_iszSyncGroup = 0x4E8 # CUtlSymbolLarge + m_nMoveTo = 0x4F0 # ScriptedMoveTo_t + m_bIsPlayingPreIdle = 0x4F4 # bool + m_bIsPlayingEntry = 0x4F5 # bool + m_bIsPlayingAction = 0x4F6 # bool + m_bIsPlayingPostIdle = 0x4F7 # bool + m_bLoopPreIdleSequence = 0x4F8 # bool + m_bLoopActionSequence = 0x4F9 # bool + m_bLoopPostIdleSequence = 0x4FA # bool + m_bSynchPostIdles = 0x4FB # bool + m_bIgnoreGravity = 0x4FC # bool + m_bDisableNPCCollisions = 0x4FD # bool + m_bKeepAnimgraphLockedPost = 0x4FE # bool + m_bDontAddModifiers = 0x4FF # bool + m_flRadius = 0x500 # float + m_flRepeat = 0x504 # float + m_flPlayAnimFadeInTime = 0x508 # float + m_flMoveInterpTime = 0x50C # float + m_flAngRate = 0x510 # float + m_iDelay = 0x514 # int32_t + m_startTime = 0x518 # GameTime_t + m_bWaitForBeginSequence = 0x51C # bool + m_saved_effects = 0x520 # int32_t + m_savedFlags = 0x524 # int32_t + m_savedCollisionGroup = 0x528 # int32_t + m_interruptable = 0x52C # bool + m_sequenceStarted = 0x52D # bool + m_bPrevAnimatedEveryTick = 0x52E # bool + m_bForcedAnimatedEveryTick = 0x52F # bool + m_bPositionRelativeToOtherEntity = 0x530 # bool + m_hTargetEnt = 0x534 # CHandle + m_hNextCine = 0x538 # CHandle + m_bThinking = 0x53C # bool + m_bInitiatedSelfDelete = 0x53D # bool + m_bIsTeleportingDueToMoveTo = 0x53E # bool + m_bAllowCustomInterruptConditions = 0x53F # bool + m_hLastFoundEntity = 0x540 # CHandle + m_hForcedTarget = 0x544 # CHandle + m_bDontCancelOtherSequences = 0x548 # bool + m_bForceSynch = 0x549 # bool + m_bTargetWasAsleep = 0x54A # bool + m_bPreventUpdateYawOnFinish = 0x54B # bool + m_bEnsureOnNavmeshOnFinish = 0x54C # bool + m_onDeathBehavior = 0x550 # ScriptedOnDeath_t + m_ConflictResponse = 0x554 # ScriptedConflictResponse_t + m_OnBeginSequence = 0x558 # CEntityIOOutput + m_OnActionStartOrLoop = 0x580 # CEntityIOOutput + m_OnEndSequence = 0x5A8 # CEntityIOOutput + m_OnPostIdleEndSequence = 0x5D0 # CEntityIOOutput + m_OnCancelSequence = 0x5F8 # CEntityIOOutput + m_OnCancelFailedSequence = 0x620 # CEntityIOOutput + m_OnScriptEvent = 0x648 # CEntityIOOutput[8] + m_matOtherToMain = 0x790 # CTransform + m_hInteractionMainEntity = 0x7B0 # CHandle + m_iPlayerDeathBehavior = 0x7B4 # int32_t + +class CSensorGrenadeProjectile: + m_fExpireTime = 0xA28 # GameTime_t + m_fNextDetectPlayerSound = 0xA2C # GameTime_t + m_hDisplayGrenade = 0xA30 # CHandle + +class CShatterGlassShard: + m_hShardHandle = 0x8 # uint32_t + m_vecPanelVertices = 0x10 # CUtlVector + m_vLocalPanelSpaceOrigin = 0x28 # Vector2D + m_hModel = 0x30 # CStrongHandle + m_hPhysicsEntity = 0x38 # CHandle + m_hParentPanel = 0x3C # CHandle + m_hParentShard = 0x40 # uint32_t + m_ShatterStressType = 0x44 # ShatterGlassStressType + m_vecStressVelocity = 0x48 # Vector + m_bCreatedModel = 0x54 # bool + m_flLongestEdge = 0x58 # float + m_flShortestEdge = 0x5C # float + m_flLongestAcross = 0x60 # float + m_flShortestAcross = 0x64 # float + m_flSumOfAllEdges = 0x68 # float + m_flArea = 0x6C # float + m_nOnFrameEdge = 0x70 # OnFrame + m_nParentPanelsNthShard = 0x74 # int32_t + m_nSubShardGeneration = 0x78 # int32_t + m_vecAverageVertPosition = 0x7C # Vector2D + m_bAverageVertPositionIsValid = 0x84 # bool + m_vecPanelSpaceStressPositionA = 0x88 # Vector2D + m_vecPanelSpaceStressPositionB = 0x90 # Vector2D + m_bStressPositionAIsValid = 0x98 # bool + m_bStressPositionBIsValid = 0x99 # bool + m_bFlaggedForRemoval = 0x9A # bool + m_flPhysicsEntitySpawnedAtTime = 0x9C # GameTime_t + m_bShatterRateLimited = 0xA0 # bool + m_hEntityHittingMe = 0xA4 # CHandle + m_vecNeighbors = 0xA8 # CUtlVector + +class CShatterGlassShardPhysics: + m_bDebris = 0xB78 # bool + m_hParentShard = 0xB7C # uint32_t + m_ShardDesc = 0xB80 # shard_model_desc_t + +class CSimTimer: + m_interval = 0x8 # float + +class CSimpleSimTimer: + m_next = 0x0 # GameTime_t + m_nWorldGroupId = 0x4 # WorldGroupId_t + +class CSingleplayRules: + m_bSinglePlayerGameEnding = 0x90 # bool + +class CSkeletonAnimationController: + m_pSkeletonInstance = 0x8 # CSkeletonInstance* + +class CSkeletonInstance: + m_modelState = 0x160 # CModelState + m_bIsAnimationEnabled = 0x390 # bool + m_bUseParentRenderBounds = 0x391 # bool + m_bDisableSolidCollisionsForHierarchy = 0x392 # bool + m_bDirtyMotionType = 0x0 # bitfield:1 + m_bIsGeneratingLatchedParentSpaceState = 0x0 # bitfield:1 + m_materialGroup = 0x394 # CUtlStringToken + m_nHitboxSet = 0x398 # uint8_t + +class CSkillDamage: + m_flDamage = 0x0 # CSkillFloat + m_flPhysicsForceDamage = 0x10 # float + +class CSkillFloat: + m_pValue = 0x0 # float[4] + +class CSkillInt: + m_pValue = 0x0 # int32_t[4] + +class CSkyCamera: + m_skyboxData = 0x4B0 # sky3dparams_t + m_skyboxSlotToken = 0x540 # CUtlStringToken + m_bUseAngles = 0x544 # bool + m_pNext = 0x548 # CSkyCamera* + +class CSkyboxReference: + m_worldGroupId = 0x4B0 # WorldGroupId_t + m_hSkyCamera = 0x4B4 # CHandle + +class CSmokeGrenadeProjectile: + m_nSmokeEffectTickBegin = 0xA40 # int32_t + m_bDidSmokeEffect = 0xA44 # bool + m_nRandomSeed = 0xA48 # int32_t + m_vSmokeColor = 0xA4C # Vector + m_vSmokeDetonationPos = 0xA58 # Vector + m_VoxelFrameData = 0xA68 # CUtlVector + m_flLastBounce = 0xA80 # GameTime_t + m_fllastSimulationTime = 0xA84 # GameTime_t + +class CSmoothFunc: + m_flSmoothAmplitude = 0x8 # float + m_flSmoothBias = 0xC # float + m_flSmoothDuration = 0x10 # float + m_flSmoothRemainingTime = 0x14 # float + m_nSmoothDir = 0x18 # int32_t + +class CSound: + m_hOwner = 0x0 # CHandle + m_hTarget = 0x4 # CHandle + m_iVolume = 0x8 # int32_t + m_flOcclusionScale = 0xC # float + m_iType = 0x10 # int32_t + m_iNextAudible = 0x14 # int32_t + m_flExpireTime = 0x18 # GameTime_t + m_iNext = 0x1C # int16_t + m_bNoExpirationTime = 0x1E # bool + m_ownerChannelIndex = 0x20 # int32_t + m_vecOrigin = 0x24 # Vector + m_bHasOwner = 0x30 # bool + +class CSoundAreaEntityBase: + m_bDisabled = 0x4B0 # bool + m_iszSoundAreaType = 0x4B8 # CUtlSymbolLarge + m_vPos = 0x4C0 # Vector + +class CSoundAreaEntityOrientedBox: + m_vMin = 0x4D0 # Vector + m_vMax = 0x4DC # Vector + +class CSoundAreaEntitySphere: + m_flRadius = 0x4D0 # float + +class CSoundEnt: + m_iFreeSound = 0x4B0 # int32_t + m_iActiveSound = 0x4B4 # int32_t + m_cLastActiveSounds = 0x4B8 # int32_t + m_SoundPool = 0x4BC # CSound[128] + +class CSoundEnvelope: + m_current = 0x0 # float + m_target = 0x4 # float + m_rate = 0x8 # float + m_forceupdate = 0xC # bool + +class CSoundEventAABBEntity: + m_vMins = 0x558 # Vector + m_vMaxs = 0x564 # Vector + +class CSoundEventEntity: + m_bStartOnSpawn = 0x4B0 # bool + m_bToLocalPlayer = 0x4B1 # bool + m_bStopOnNew = 0x4B2 # bool + m_bSaveRestore = 0x4B3 # bool + m_bSavedIsPlaying = 0x4B4 # bool + m_flSavedElapsedTime = 0x4B8 # float + m_iszSourceEntityName = 0x4C0 # CUtlSymbolLarge + m_iszAttachmentName = 0x4C8 # CUtlSymbolLarge + m_onGUIDChanged = 0x4D0 # CEntityOutputTemplate + m_onSoundFinished = 0x4F8 # CEntityIOOutput + m_iszSoundName = 0x540 # CUtlSymbolLarge + m_hSource = 0x550 # CEntityHandle + +class CSoundEventOBBEntity: + m_vMins = 0x558 # Vector + m_vMaxs = 0x564 # Vector + +class CSoundEventParameter: + m_iszParamName = 0x4B8 # CUtlSymbolLarge + m_flFloatValue = 0x4C0 # float + +class CSoundEventPathCornerEntity: + m_iszPathCorner = 0x558 # CUtlSymbolLarge + m_iCountMax = 0x560 # int32_t + m_flDistanceMax = 0x564 # float + m_flDistMaxSqr = 0x568 # float + m_flDotProductMax = 0x56C # float + bPlaying = 0x570 # bool + +class CSoundOpvarSetAABBEntity: + m_vDistanceInnerMins = 0x648 # Vector + m_vDistanceInnerMaxs = 0x654 # Vector + m_vDistanceOuterMins = 0x660 # Vector + m_vDistanceOuterMaxs = 0x66C # Vector + m_nAABBDirection = 0x678 # int32_t + m_vInnerMins = 0x67C # Vector + m_vInnerMaxs = 0x688 # Vector + m_vOuterMins = 0x694 # Vector + m_vOuterMaxs = 0x6A0 # Vector + +class CSoundOpvarSetEntity: + m_iszStackName = 0x4B8 # CUtlSymbolLarge + m_iszOperatorName = 0x4C0 # CUtlSymbolLarge + m_iszOpvarName = 0x4C8 # CUtlSymbolLarge + m_nOpvarType = 0x4D0 # int32_t + m_nOpvarIndex = 0x4D4 # int32_t + m_flOpvarValue = 0x4D8 # float + m_OpvarValueString = 0x4E0 # CUtlSymbolLarge + m_bSetOnSpawn = 0x4E8 # bool + +class CSoundOpvarSetOBBWindEntity: + m_vMins = 0x548 # Vector + m_vMaxs = 0x554 # Vector + m_vDistanceMins = 0x560 # Vector + m_vDistanceMaxs = 0x56C # Vector + m_flWindMin = 0x578 # float + m_flWindMax = 0x57C # float + m_flWindMapMin = 0x580 # float + m_flWindMapMax = 0x584 # float + +class CSoundOpvarSetPathCornerEntity: + m_flDistMinSqr = 0x660 # float + m_flDistMaxSqr = 0x664 # float + m_iszPathCornerEntityName = 0x668 # CUtlSymbolLarge + +class CSoundOpvarSetPointBase: + m_bDisabled = 0x4B0 # bool + m_hSource = 0x4B4 # CEntityHandle + m_iszSourceEntityName = 0x4C0 # CUtlSymbolLarge + m_vLastPosition = 0x518 # Vector + m_iszStackName = 0x528 # CUtlSymbolLarge + m_iszOperatorName = 0x530 # CUtlSymbolLarge + m_iszOpvarName = 0x538 # CUtlSymbolLarge + m_iOpvarIndex = 0x540 # int32_t + m_bUseAutoCompare = 0x544 # bool + +class CSoundOpvarSetPointEntity: + m_OnEnter = 0x548 # CEntityIOOutput + m_OnExit = 0x570 # CEntityIOOutput + m_bAutoDisable = 0x598 # bool + m_flDistanceMin = 0x5DC # float + m_flDistanceMax = 0x5E0 # float + m_flDistanceMapMin = 0x5E4 # float + m_flDistanceMapMax = 0x5E8 # float + m_flOcclusionRadius = 0x5EC # float + m_flOcclusionMin = 0x5F0 # float + m_flOcclusionMax = 0x5F4 # float + m_flValSetOnDisable = 0x5F8 # float + m_bSetValueOnDisable = 0x5FC # bool + m_nSimulationMode = 0x600 # int32_t + m_nVisibilitySamples = 0x604 # int32_t + m_vDynamicProxyPoint = 0x608 # Vector + m_flDynamicMaximumOcclusion = 0x614 # float + m_hDynamicEntity = 0x618 # CEntityHandle + m_iszDynamicEntityName = 0x620 # CUtlSymbolLarge + m_flPathingDistanceNormFactor = 0x628 # float + m_vPathingSourcePos = 0x62C # Vector + m_vPathingListenerPos = 0x638 # Vector + m_nPathingSourceIndex = 0x644 # int32_t + +class CSoundPatch: + m_pitch = 0x8 # CSoundEnvelope + m_volume = 0x18 # CSoundEnvelope + m_shutdownTime = 0x30 # float + m_flLastTime = 0x34 # float + m_iszSoundScriptName = 0x38 # CUtlSymbolLarge + m_hEnt = 0x40 # CHandle + m_soundEntityIndex = 0x44 # CEntityIndex + m_soundOrigin = 0x48 # Vector + m_isPlaying = 0x54 # int32_t + m_Filter = 0x58 # CCopyRecipientFilter + m_flCloseCaptionDuration = 0x80 # float + m_bUpdatedSoundOrigin = 0x84 # bool + m_iszClassName = 0x88 # CUtlSymbolLarge + +class CSoundStackSave: + m_iszStackName = 0x4B0 # CUtlSymbolLarge + +class CSpotlightEnd: + m_flLightScale = 0x700 # float + m_Radius = 0x704 # float + m_vSpotlightDir = 0x708 # Vector + m_vSpotlightOrg = 0x714 # Vector + +class CSprite: + m_hSpriteMaterial = 0x700 # CStrongHandle + m_hAttachedToEntity = 0x708 # CHandle + m_nAttachment = 0x70C # AttachmentHandle_t + m_flSpriteFramerate = 0x710 # float + m_flFrame = 0x714 # float + m_flDieTime = 0x718 # GameTime_t + m_nBrightness = 0x728 # uint32_t + m_flBrightnessDuration = 0x72C # float + m_flSpriteScale = 0x730 # float + m_flScaleDuration = 0x734 # float + m_bWorldSpaceScale = 0x738 # bool + m_flGlowProxySize = 0x73C # float + m_flHDRColorScale = 0x740 # float + m_flLastTime = 0x744 # GameTime_t + m_flMaxFrame = 0x748 # float + m_flStartScale = 0x74C # float + m_flDestScale = 0x750 # float + m_flScaleTimeStart = 0x754 # GameTime_t + m_nStartBrightness = 0x758 # int32_t + m_nDestBrightness = 0x75C # int32_t + m_flBrightnessTimeStart = 0x760 # GameTime_t + m_nSpriteWidth = 0x764 # int32_t + m_nSpriteHeight = 0x768 # int32_t + +class CStopwatch: + m_interval = 0xC # float + +class CStopwatchBase: + m_fIsRunning = 0x8 # bool + +class CSun: + m_vDirection = 0x700 # Vector + m_clrOverlay = 0x70C # Color + m_iszEffectName = 0x710 # CUtlSymbolLarge + m_iszSSEffectName = 0x718 # CUtlSymbolLarge + m_bOn = 0x720 # bool + m_bmaxColor = 0x721 # bool + m_flSize = 0x724 # float + m_flRotation = 0x728 # float + m_flHazeScale = 0x72C # float + m_flAlphaHaze = 0x730 # float + m_flAlphaHdr = 0x734 # float + m_flAlphaScale = 0x738 # float + m_flHDRColorScale = 0x73C # float + m_flFarZScale = 0x740 # float + +class CTakeDamageInfo: + m_vecDamageForce = 0x8 # Vector + m_vecDamagePosition = 0x14 # Vector + m_vecReportedPosition = 0x20 # Vector + m_vecDamageDirection = 0x2C # Vector + m_hInflictor = 0x38 # CHandle + m_hAttacker = 0x3C # CHandle + m_hAbility = 0x40 # CHandle + m_flDamage = 0x44 # float + m_bitsDamageType = 0x48 # int32_t + m_iDamageCustom = 0x4C # int32_t + m_iAmmoType = 0x50 # AmmoIndex_t + m_flOriginalDamage = 0x60 # float + m_bShouldBleed = 0x64 # bool + m_bShouldSpark = 0x65 # bool + m_nDamageFlags = 0x70 # TakeDamageFlags_t + m_nNumObjectsPenetrated = 0x74 # int32_t + m_hScriptInstance = 0x78 # HSCRIPT + m_bInTakeDamageFlow = 0x94 # bool + +class CTakeDamageResult: + m_nHealthLost = 0x0 # int32_t + m_nDamageTaken = 0x4 # int32_t + +class CTakeDamageSummaryScopeGuard: + m_vecSummaries = 0x8 # CUtlVector + +class CTankTargetChange: + m_newTarget = 0x4B0 # CVariantBase + m_newTargetName = 0x4C0 # CUtlSymbolLarge + +class CTankTrainAI: + m_hTrain = 0x4B0 # CHandle + m_hTargetEntity = 0x4B4 # CHandle + m_soundPlaying = 0x4B8 # int32_t + m_startSoundName = 0x4D0 # CUtlSymbolLarge + m_engineSoundName = 0x4D8 # CUtlSymbolLarge + m_movementSoundName = 0x4E0 # CUtlSymbolLarge + m_targetEntityName = 0x4E8 # CUtlSymbolLarge + +class CTeam: + m_aPlayerControllers = 0x4B0 # CNetworkUtlVectorBase> + m_aPlayers = 0x4C8 # CNetworkUtlVectorBase> + m_iScore = 0x4E0 # int32_t + m_szTeamname = 0x4E4 # char[129] + +class CTestEffect: + m_iLoop = 0x4B0 # int32_t + m_iBeam = 0x4B4 # int32_t + m_pBeam = 0x4B8 # CBeam*[24] + m_flBeamTime = 0x578 # GameTime_t[24] + m_flStartTime = 0x5D8 # GameTime_t + +class CTextureBasedAnimatable: + m_bLoop = 0x700 # bool + m_flFPS = 0x704 # float + m_hPositionKeys = 0x708 # CStrongHandle + m_hRotationKeys = 0x710 # CStrongHandle + m_vAnimationBoundsMin = 0x718 # Vector + m_vAnimationBoundsMax = 0x724 # Vector + m_flStartTime = 0x730 # float + m_flStartFrame = 0x734 # float + +class CTimeline: + m_flValues = 0x10 # float[64] + m_nValueCounts = 0x110 # int32_t[64] + m_nBucketCount = 0x210 # int32_t + m_flInterval = 0x214 # float + m_flFinalValue = 0x218 # float + m_nCompressionType = 0x21C # TimelineCompression_t + m_bStopped = 0x220 # bool + +class CTimerEntity: + m_OnTimer = 0x4B0 # CEntityIOOutput + m_OnTimerHigh = 0x4D8 # CEntityIOOutput + m_OnTimerLow = 0x500 # CEntityIOOutput + m_iDisabled = 0x528 # int32_t + m_flInitialDelay = 0x52C # float + m_flRefireTime = 0x530 # float + m_bUpDownState = 0x534 # bool + m_iUseRandomTime = 0x538 # int32_t + m_bPauseAfterFiring = 0x53C # bool + m_flLowerRandomBound = 0x540 # float + m_flUpperRandomBound = 0x544 # float + m_flRemainingTime = 0x548 # float + m_bPaused = 0x54C # bool + +class CTonemapController2: + m_flAutoExposureMin = 0x4B0 # float + m_flAutoExposureMax = 0x4B4 # float + m_flTonemapPercentTarget = 0x4B8 # float + m_flTonemapPercentBrightPixels = 0x4BC # float + m_flTonemapMinAvgLum = 0x4C0 # float + m_flExposureAdaptationSpeedUp = 0x4C4 # float + m_flExposureAdaptationSpeedDown = 0x4C8 # float + m_flTonemapEVSmoothingRange = 0x4CC # float + +class CTonemapTrigger: + m_tonemapControllerName = 0x8A8 # CUtlSymbolLarge + m_hTonemapController = 0x8B0 # CEntityHandle + +class CTriggerActiveWeaponDetect: + m_OnTouchedActiveWeapon = 0x8A8 # CEntityIOOutput + m_iszWeaponClassName = 0x8D0 # CUtlSymbolLarge + +class CTriggerBrush: + m_OnStartTouch = 0x700 # CEntityIOOutput + m_OnEndTouch = 0x728 # CEntityIOOutput + m_OnUse = 0x750 # CEntityIOOutput + m_iInputFilter = 0x778 # int32_t + m_iDontMessageParent = 0x77C # int32_t + +class CTriggerBuoyancy: + m_BuoyancyHelper = 0x8A8 # CBuoyancyHelper + m_flFluidDensity = 0x8C8 # float + +class CTriggerDetectBulletFire: + m_bPlayerFireOnly = 0x8A8 # bool + m_OnDetectedBulletFire = 0x8B0 # CEntityIOOutput + +class CTriggerDetectExplosion: + m_OnDetectedExplosion = 0x8E0 # CEntityIOOutput + +class CTriggerFan: + m_vFanOrigin = 0x8A8 # Vector + m_vFanEnd = 0x8B4 # Vector + m_vNoise = 0x8C0 # Vector + m_flForce = 0x8CC # float + m_flPlayerForce = 0x8D0 # float + m_flRampTime = 0x8D4 # float + m_bFalloff = 0x8D8 # bool + m_bPushPlayer = 0x8D9 # bool + m_bRampDown = 0x8DA # bool + m_bAddNoise = 0x8DB # bool + m_RampTimer = 0x8E0 # CountdownTimer + +class CTriggerGameEvent: + m_strStartTouchEventName = 0x8A8 # CUtlString + m_strEndTouchEventName = 0x8B0 # CUtlString + m_strTriggerID = 0x8B8 # CUtlString + +class CTriggerHurt: + m_flOriginalDamage = 0x8A8 # float + m_flDamage = 0x8AC # float + m_flDamageCap = 0x8B0 # float + m_flLastDmgTime = 0x8B4 # GameTime_t + m_flForgivenessDelay = 0x8B8 # float + m_bitsDamageInflict = 0x8BC # int32_t + m_damageModel = 0x8C0 # int32_t + m_bNoDmgForce = 0x8C4 # bool + m_vDamageForce = 0x8C8 # Vector + m_thinkAlways = 0x8D4 # bool + m_hurtThinkPeriod = 0x8D8 # float + m_OnHurt = 0x8E0 # CEntityIOOutput + m_OnHurtPlayer = 0x908 # CEntityIOOutput + m_hurtEntities = 0x930 # CUtlVector> + +class CTriggerImpact: + m_flMagnitude = 0x8D0 # float + m_flNoise = 0x8D4 # float + m_flViewkick = 0x8D8 # float + m_pOutputForce = 0x8E0 # CEntityOutputTemplate + +class CTriggerLerpObject: + m_iszLerpTarget = 0x8A8 # CUtlSymbolLarge + m_hLerpTarget = 0x8B0 # CHandle + m_iszLerpTargetAttachment = 0x8B8 # CUtlSymbolLarge + m_hLerpTargetAttachment = 0x8C0 # AttachmentHandle_t + m_flLerpDuration = 0x8C4 # float + m_bLerpRestoreMoveType = 0x8C8 # bool + m_bSingleLerpObject = 0x8C9 # bool + m_vecLerpingObjects = 0x8D0 # CUtlVector + m_iszLerpEffect = 0x8E8 # CUtlSymbolLarge + m_iszLerpSound = 0x8F0 # CUtlSymbolLarge + m_OnLerpStarted = 0x8F8 # CEntityIOOutput + m_OnLerpFinished = 0x920 # CEntityIOOutput + +class CTriggerLook: + m_hLookTarget = 0x8D0 # CHandle + m_flFieldOfView = 0x8D4 # float + m_flLookTime = 0x8D8 # float + m_flLookTimeTotal = 0x8DC # float + m_flLookTimeLast = 0x8E0 # GameTime_t + m_flTimeoutDuration = 0x8E4 # float + m_bTimeoutFired = 0x8E8 # bool + m_bIsLooking = 0x8E9 # bool + m_b2DFOV = 0x8EA # bool + m_bUseVelocity = 0x8EB # bool + m_hActivator = 0x8EC # CHandle + m_bTestOcclusion = 0x8F0 # bool + m_OnTimeout = 0x8F8 # CEntityIOOutput + m_OnStartLook = 0x920 # CEntityIOOutput + m_OnEndLook = 0x948 # CEntityIOOutput + +class CTriggerMultiple: + m_OnTrigger = 0x8A8 # CEntityIOOutput + +class CTriggerPhysics: + m_gravityScale = 0x8B8 # float + m_linearLimit = 0x8BC # float + m_linearDamping = 0x8C0 # float + m_angularLimit = 0x8C4 # float + m_angularDamping = 0x8C8 # float + m_linearForce = 0x8CC # float + m_flFrequency = 0x8D0 # float + m_flDampingRatio = 0x8D4 # float + m_vecLinearForcePointAt = 0x8D8 # Vector + m_bCollapseToForcePoint = 0x8E4 # bool + m_vecLinearForcePointAtWorld = 0x8E8 # Vector + m_vecLinearForceDirection = 0x8F4 # Vector + m_bConvertToDebrisWhenPossible = 0x900 # bool + +class CTriggerProximity: + m_hMeasureTarget = 0x8A8 # CHandle + m_iszMeasureTarget = 0x8B0 # CUtlSymbolLarge + m_fRadius = 0x8B8 # float + m_nTouchers = 0x8BC # int32_t + m_NearestEntityDistance = 0x8C0 # CEntityOutputTemplate + +class CTriggerPush: + m_angPushEntitySpace = 0x8A8 # QAngle + m_vecPushDirEntitySpace = 0x8B4 # Vector + m_bTriggerOnStartTouch = 0x8C0 # bool + m_flAlternateTicksFix = 0x8C4 # float + m_flPushSpeed = 0x8C8 # float + +class CTriggerRemove: + m_OnRemove = 0x8A8 # CEntityIOOutput + +class CTriggerSave: + m_bForceNewLevelUnit = 0x8A8 # bool + m_fDangerousTimer = 0x8AC # float + m_minHitPoints = 0x8B0 # int32_t + +class CTriggerSndSosOpvar: + m_hTouchingPlayers = 0x8A8 # CUtlVector> + m_flPosition = 0x8C0 # Vector + m_flCenterSize = 0x8CC # float + m_flMinVal = 0x8D0 # float + m_flMaxVal = 0x8D4 # float + m_flWait = 0x8D8 # float + m_opvarName = 0x8E0 # CUtlSymbolLarge + m_stackName = 0x8E8 # CUtlSymbolLarge + m_operatorName = 0x8F0 # CUtlSymbolLarge + m_bVolIs2D = 0x8F8 # bool + m_opvarNameChar = 0x8F9 # char[256] + m_stackNameChar = 0x9F9 # char[256] + m_operatorNameChar = 0xAF9 # char[256] + m_VecNormPos = 0xBFC # Vector + m_flNormCenterSize = 0xC08 # float + +class CTriggerSoundscape: + m_hSoundscape = 0x8A8 # CHandle + m_SoundscapeName = 0x8B0 # CUtlSymbolLarge + m_spectators = 0x8B8 # CUtlVector> + +class CTriggerTeleport: + m_iLandmark = 0x8A8 # CUtlSymbolLarge + m_bUseLandmarkAngles = 0x8B0 # bool + m_bMirrorPlayer = 0x8B1 # bool + +class CTriggerToggleSave: + m_bDisabled = 0x8A8 # bool + +class CTriggerVolume: + m_iFilterName = 0x700 # CUtlSymbolLarge + m_hFilter = 0x708 # CHandle + +class CVoteController: + m_iActiveIssueIndex = 0x4B0 # int32_t + m_iOnlyTeamToVote = 0x4B4 # int32_t + m_nVoteOptionCount = 0x4B8 # int32_t[5] + m_nPotentialVotes = 0x4CC # int32_t + m_bIsYesNoVote = 0x4D0 # bool + m_acceptingVotesTimer = 0x4D8 # CountdownTimer + m_executeCommandTimer = 0x4F0 # CountdownTimer + m_resetVoteTimer = 0x508 # CountdownTimer + m_nVotesCast = 0x520 # int32_t[64] + m_playerHoldingVote = 0x620 # CPlayerSlot + m_playerOverrideForVote = 0x624 # CPlayerSlot + m_nHighestCountIndex = 0x628 # int32_t + m_potentialIssues = 0x630 # CUtlVector + m_VoteOptions = 0x648 # CUtlVector + +class CWeaponBaseItem: + m_SequenceCompleteTimer = 0xDD8 # CountdownTimer + m_bRedraw = 0xDF0 # bool + +class CWeaponShield: + m_flBulletDamageAbsorbed = 0xDF8 # float + m_flLastBulletHitSoundTime = 0xDFC # GameTime_t + m_flDisplayHealth = 0xE00 # float + +class CWeaponTaser: + m_fFireTime = 0xDF8 # GameTime_t + +class CommandToolCommand_t: + m_bEnabled = 0x0 # bool + m_bOpened = 0x1 # bool + m_InternalId = 0x4 # uint32_t + m_ShortName = 0x8 # CUtlString + m_ExecMode = 0x10 # CommandExecMode_t + m_SpawnGroup = 0x18 # CUtlString + m_PeriodicExecDelay = 0x20 # float + m_SpecType = 0x24 # CommandEntitySpecType_t + m_EntitySpec = 0x28 # CUtlString + m_Commands = 0x30 # CUtlString + m_SetDebugBits = 0x38 # DebugOverlayBits_t + m_ClearDebugBits = 0x40 # DebugOverlayBits_t + +class ConceptHistory_t: + timeSpoken = 0x0 # float + m_response = 0x8 # CRR_Response + +class ConstraintSoundInfo: + m_vSampler = 0x8 # VelocitySampler + m_soundProfile = 0x20 # SimpleConstraintSoundProfile + m_forwardAxis = 0x40 # Vector + m_iszTravelSoundFwd = 0x50 # CUtlSymbolLarge + m_iszTravelSoundBack = 0x58 # CUtlSymbolLarge + m_iszReversalSounds = 0x68 # CUtlSymbolLarge[3] + m_bPlayTravelSound = 0x80 # bool + m_bPlayReversalSound = 0x81 # bool + +class CountdownTimer: + m_duration = 0x8 # float + m_timestamp = 0xC # GameTime_t + m_timescale = 0x10 # float + m_nWorldGroupId = 0x14 # WorldGroupId_t + +class EngineCountdownTimer: + m_duration = 0x8 # float + m_timestamp = 0xC # float + m_timescale = 0x10 # float + +class EntityRenderAttribute_t: + m_ID = 0x30 # CUtlStringToken + m_Values = 0x34 # Vector4D + +class EntitySpottedState_t: + m_bSpotted = 0x8 # bool + m_bSpottedByMask = 0xC # uint32_t[2] + +class Extent: + lo = 0x0 # Vector + hi = 0xC # Vector + +class FilterDamageType: + m_iDamageType = 0x508 # int32_t + +class FilterHealth: + m_bAdrenalineActive = 0x508 # bool + m_iHealthMin = 0x50C # int32_t + m_iHealthMax = 0x510 # int32_t + +class FilterTeam: + m_iFilterTeam = 0x508 # int32_t + +class GameAmmoTypeInfo_t: + m_nBuySize = 0x38 # int32_t + m_nCost = 0x3C # int32_t + +class GameTick_t: + m_Value = 0x0 # int32_t + +class GameTime_t: + m_Value = 0x0 # float + +class HullFlags_t: + m_bHull_Human = 0x0 # bool + m_bHull_SmallCentered = 0x1 # bool + m_bHull_WideHuman = 0x2 # bool + m_bHull_Tiny = 0x3 # bool + m_bHull_Medium = 0x4 # bool + m_bHull_TinyCentered = 0x5 # bool + m_bHull_Large = 0x6 # bool + m_bHull_LargeCentered = 0x7 # bool + m_bHull_MediumTall = 0x8 # bool + m_bHull_Small = 0x9 # bool + +class IntervalTimer: + m_timestamp = 0x8 # GameTime_t + m_nWorldGroupId = 0xC # WorldGroupId_t + +class ModelConfigHandle_t: + m_Value = 0x0 # uint32_t + +class ParticleIndex_t: + m_Value = 0x0 # int32_t + +class PhysicsRagdollPose_t: + __m_pChainEntity = 0x8 # CNetworkVarChainer + m_Transforms = 0x30 # CNetworkUtlVectorBase + m_hOwner = 0x48 # CHandle + +class RagdollCreationParams_t: + m_vForce = 0x0 # Vector + m_nForceBone = 0xC # int32_t + +class RelationshipOverride_t: + entity = 0x8 # CHandle + classType = 0xC # Class_T + +class Relationship_t: + disposition = 0x0 # Disposition_t + priority = 0x4 # int32_t + +class ResponseContext_t: + m_iszName = 0x0 # CUtlSymbolLarge + m_iszValue = 0x8 # CUtlSymbolLarge + m_fExpirationTime = 0x10 # GameTime_t + +class ResponseFollowup: + followup_concept = 0x0 # char* + followup_contexts = 0x8 # char* + followup_delay = 0x10 # float + followup_target = 0x14 # char* + followup_entityiotarget = 0x1C # char* + followup_entityioinput = 0x24 # char* + followup_entityiodelay = 0x2C # float + bFired = 0x30 # bool + +class ResponseParams: + odds = 0x10 # int16_t + flags = 0x12 # int16_t + m_pFollowup = 0x18 # ResponseFollowup* + +class SellbackPurchaseEntry_t: + m_unDefIdx = 0x30 # uint16_t + m_nCost = 0x34 # int32_t + m_nPrevArmor = 0x38 # int32_t + m_bPrevHelmet = 0x3C # bool + m_hItem = 0x40 # CEntityHandle + +class ServerAuthoritativeWeaponSlot_t: + unClass = 0x28 # uint16_t + unSlot = 0x2A # uint16_t + unItemDefIdx = 0x2C # uint16_t + +class SimpleConstraintSoundProfile: + eKeypoints = 0x8 # SimpleConstraintSoundProfile::SimpleConstraintsSoundProfileKeypoints_t + m_keyPoints = 0xC # float[2] + m_reversalSoundThresholds = 0x14 # float[3] + +class SpawnPoint: + m_iPriority = 0x4B0 # int32_t + m_bEnabled = 0x4B4 # bool + m_nType = 0x4B8 # int32_t + +class SpawnPointCoopEnemy: + m_szWeaponsToGive = 0x4C0 # CUtlSymbolLarge + m_szPlayerModelToUse = 0x4C8 # CUtlSymbolLarge + m_nArmorToSpawnWith = 0x4D0 # int32_t + m_nDefaultBehavior = 0x4D4 # SpawnPointCoopEnemy::BotDefaultBehavior_t + m_nBotDifficulty = 0x4D8 # int32_t + m_bIsAgressive = 0x4DC # bool + m_bStartAsleep = 0x4DD # bool + m_flHideRadius = 0x4E0 # float + m_szBehaviorTreeFile = 0x4F0 # CUtlSymbolLarge + +class SummaryTakeDamageInfo_t: + nSummarisedCount = 0x0 # int32_t + info = 0x8 # CTakeDamageInfo + result = 0xA0 # CTakeDamageResult + hTarget = 0xA8 # CHandle + +class VPhysicsCollisionAttribute_t: + m_nInteractsAs = 0x8 # uint64_t + m_nInteractsWith = 0x10 # uint64_t + m_nInteractsExclude = 0x18 # uint64_t + m_nEntityId = 0x20 # uint32_t + m_nOwnerId = 0x24 # uint32_t + m_nHierarchyId = 0x28 # uint16_t + m_nCollisionGroup = 0x2A # uint8_t + m_nCollisionFunctionMask = 0x2B # uint8_t + +class VelocitySampler: + m_prevSample = 0x0 # Vector + m_fPrevSampleTime = 0xC # GameTime_t + m_fIdealSampleRate = 0x10 # float + +class ViewAngleServerChange_t: + nType = 0x30 # FixAngleSet_t + qAngle = 0x34 # QAngle + nIndex = 0x40 # uint32_t + +class WeaponPurchaseCount_t: + m_nItemDefIndex = 0x30 # uint16_t + m_nCount = 0x32 # uint16_t + +class WeaponPurchaseTracker_t: + m_weaponPurchases = 0x8 # CUtlVectorEmbeddedNetworkVar + +class audioparams_t: + localSound = 0x8 # Vector[8] + soundscapeIndex = 0x68 # int32_t + localBits = 0x6C # uint8_t + soundscapeEntityListIndex = 0x70 # int32_t + soundEventHash = 0x74 # uint32_t + +class dynpitchvol_base_t: + preset = 0x0 # int32_t + pitchrun = 0x4 # int32_t + pitchstart = 0x8 # int32_t + spinup = 0xC # int32_t + spindown = 0x10 # int32_t + volrun = 0x14 # int32_t + volstart = 0x18 # int32_t + fadein = 0x1C # int32_t + fadeout = 0x20 # int32_t + lfotype = 0x24 # int32_t + lforate = 0x28 # int32_t + lfomodpitch = 0x2C # int32_t + lfomodvol = 0x30 # int32_t + cspinup = 0x34 # int32_t + cspincount = 0x38 # int32_t + pitch = 0x3C # int32_t + spinupsav = 0x40 # int32_t + spindownsav = 0x44 # int32_t + pitchfrac = 0x48 # int32_t + vol = 0x4C # int32_t + fadeinsav = 0x50 # int32_t + fadeoutsav = 0x54 # int32_t + volfrac = 0x58 # int32_t + lfofrac = 0x5C # int32_t + lfomult = 0x60 # int32_t + +class fogparams_t: + dirPrimary = 0x8 # Vector + colorPrimary = 0x14 # Color + colorSecondary = 0x18 # Color + colorPrimaryLerpTo = 0x1C # Color + colorSecondaryLerpTo = 0x20 # Color + start = 0x24 # float + end = 0x28 # float + farz = 0x2C # float + maxdensity = 0x30 # float + exponent = 0x34 # float + HDRColorScale = 0x38 # float + skyboxFogFactor = 0x3C # float + skyboxFogFactorLerpTo = 0x40 # float + startLerpTo = 0x44 # float + endLerpTo = 0x48 # float + maxdensityLerpTo = 0x4C # float + lerptime = 0x50 # GameTime_t + duration = 0x54 # float + blendtobackground = 0x58 # float + scattering = 0x5C # float + locallightscale = 0x60 # float + enable = 0x64 # bool + blend = 0x65 # bool + m_bNoReflectionFog = 0x66 # bool + m_bPadding = 0x67 # bool + +class fogplayerparams_t: + m_hCtrl = 0x8 # CHandle + m_flTransitionTime = 0xC # float + m_OldColor = 0x10 # Color + m_flOldStart = 0x14 # float + m_flOldEnd = 0x18 # float + m_flOldMaxDensity = 0x1C # float + m_flOldHDRColorScale = 0x20 # float + m_flOldFarZ = 0x24 # float + m_NewColor = 0x28 # Color + m_flNewStart = 0x2C # float + m_flNewEnd = 0x30 # float + m_flNewMaxDensity = 0x34 # float + m_flNewHDRColorScale = 0x38 # float + m_flNewFarZ = 0x3C # float + +class hudtextparms_t: + color1 = 0x0 # Color + color2 = 0x4 # Color + effect = 0x8 # uint8_t + channel = 0x9 # uint8_t + x = 0xC # float + y = 0x10 # float + +class lerpdata_t: + m_hEnt = 0x0 # CHandle + m_MoveType = 0x4 # MoveType_t + m_flStartTime = 0x8 # GameTime_t + m_vecStartOrigin = 0xC # Vector + m_qStartRot = 0x20 # Quaternion + m_nFXIndex = 0x30 # ParticleIndex_t + +class locksound_t: + sLockedSound = 0x8 # CUtlSymbolLarge + sUnlockedSound = 0x10 # CUtlSymbolLarge + flwaitSound = 0x18 # GameTime_t + +class magnetted_objects_t: + hEntity = 0x8 # CHandle + +class ragdoll_t: + list = 0x0 # CUtlVector + boneIndex = 0x18 # CUtlVector + allowStretch = 0x30 # bool + unused = 0x31 # bool + +class ragdollelement_t: + originParentSpace = 0x0 # Vector + parentIndex = 0x20 # int32_t + m_flRadius = 0x24 # float + +class shard_model_desc_t: + m_nModelID = 0x8 # int32_t + m_hMaterial = 0x10 # CStrongHandle + m_solid = 0x18 # ShardSolid_t + m_ShatterPanelMode = 0x19 # ShatterPanelMode + m_vecPanelSize = 0x1C # Vector2D + m_vecStressPositionA = 0x24 # Vector2D + m_vecStressPositionB = 0x2C # Vector2D + m_vecPanelVertices = 0x38 # CNetworkUtlVectorBase + m_flGlassHalfThickness = 0x50 # float + m_bHasParent = 0x54 # bool + m_bParentFrozen = 0x55 # bool + m_SurfacePropStringToken = 0x58 # CUtlStringToken + m_LightGroup = 0x5C # CUtlStringToken + +class sky3dparams_t: + scale = 0x8 # int16_t + origin = 0xC # Vector + bClip3DSkyBoxNearToWorldFar = 0x18 # bool + flClip3DSkyBoxNearToWorldFarOffset = 0x1C # float + fog = 0x20 # fogparams_t + m_nWorldGroupID = 0x88 # WorldGroupId_t + +class thinkfunc_t: + m_hFn = 0x8 # HSCRIPT + m_nContext = 0x10 # CUtlStringToken + m_nNextThinkTick = 0x14 # GameTick_t + m_nLastThinkTick = 0x18 # GameTick_t diff --git a/generated/server.dll.rs b/generated/server.dll.rs index d55659b..f63b39d 100644 --- a/generated/server.dll.rs +++ b/generated/server.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:32.557311800 UTC + * 2023-10-17 02:04:51.051900700 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod ActiveModelConfig_t { pub const m_Handle: usize = 0x28; // ModelConfigHandle_t pub const m_Name: usize = 0x30; // CUtlSymbolLarge diff --git a/generated/soundsystem.dll.cs b/generated/soundsystem.dll.cs index e21b64f..5a55922 100644 --- a/generated/soundsystem.dll.cs +++ b/generated/soundsystem.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.664413500 UTC + * 2023-10-17 02:04:50.029858700 UTC */ public static class CDSPMixgroupModifier { diff --git a/generated/soundsystem.dll.hpp b/generated/soundsystem.dll.hpp index 089a8bc..3fe3afc 100644 --- a/generated/soundsystem.dll.hpp +++ b/generated/soundsystem.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:50.026242900 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.660932900 UTC - */ - namespace CDSPMixgroupModifier { constexpr std::ptrdiff_t m_mixgroup = 0x0; // CUtlString constexpr std::ptrdiff_t m_flModifier = 0x8; // float diff --git a/generated/soundsystem.dll.py b/generated/soundsystem.dll.py new file mode 100644 index 0000000..8dd95f2 --- /dev/null +++ b/generated/soundsystem.dll.py @@ -0,0 +1,272 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:50.033735200 UTC +''' + +class CDSPMixgroupModifier: + m_mixgroup = 0x0 # CUtlString + m_flModifier = 0x8 # float + m_flModifierMin = 0xC # float + m_flSourceModifier = 0x10 # float + m_flSourceModifierMin = 0x14 # float + m_flListenerReverbModifierWhenSourceReverbIsActive = 0x18 # float + +class CDSPPresetMixgroupModifierTable: + m_table = 0x0 # CUtlVector + +class CDspPresetModifierList: + m_dspName = 0x0 # CUtlString + m_modifiers = 0x8 # CUtlVector + +class CSosGroupActionLimitSchema: + m_nMaxCount = 0x18 # int32_t + m_nStopType = 0x1C # SosActionStopType_t + m_nSortType = 0x20 # SosActionSortType_t + +class CSosGroupActionSchema: + m_name = 0x8 # CUtlString + m_actionType = 0x10 # ActionType_t + m_actionInstanceType = 0x14 # ActionType_t + +class CSosGroupActionSetSoundeventParameterSchema: + m_nMaxCount = 0x18 # int32_t + m_flMinValue = 0x1C # float + m_flMaxValue = 0x20 # float + m_opvarName = 0x28 # CUtlString + m_nSortType = 0x30 # SosActionSortType_t + +class CSosGroupActionTimeLimitSchema: + m_flMaxDuration = 0x18 # float + +class CSosGroupBranchPattern: + m_bMatchEventName = 0x8 # bool + m_bMatchEventSubString = 0x9 # bool + m_bMatchEntIndex = 0xA # bool + m_bMatchOpvar = 0xB # bool + +class CSosGroupMatchPattern: + m_matchSoundEventName = 0x10 # CUtlString + m_matchSoundEventSubString = 0x18 # CUtlString + m_flEntIndex = 0x20 # float + m_flOpvar = 0x24 # float + +class CSosSoundEventGroupListSchema: + m_groupList = 0x0 # CUtlVector + +class CSosSoundEventGroupSchema: + m_name = 0x0 # CUtlString + m_nType = 0x8 # SosGroupType_t + m_bIsBlocking = 0xC # bool + m_nBlockMaxCount = 0x10 # int32_t + m_bInvertMatch = 0x14 # bool + m_matchPattern = 0x18 # CSosGroupMatchPattern + m_branchPattern = 0x40 # CSosGroupBranchPattern + m_vActions = 0xB0 # CSosGroupActionSchema*[4] + +class CSoundEventMetaData: + m_soundEventVMix = 0x0 # CStrongHandle + +class SelectedEditItemInfo_t: + m_EditItems = 0x0 # CUtlVector + +class SosEditItemInfo_t: + itemType = 0x0 # SosEditItemType_t + itemName = 0x8 # CUtlString + itemTypeName = 0x10 # CUtlString + itemKVString = 0x20 # CUtlString + itemPos = 0x28 # Vector2D + +class VMixAutoFilterDesc_t: + m_flEnvelopeAmount = 0x0 # float + m_flAttackTimeMS = 0x4 # float + m_flReleaseTimeMS = 0x8 # float + m_filter = 0xC # VMixFilterDesc_t + m_flLFOAmount = 0x1C # float + m_flLFORate = 0x20 # float + m_flPhase = 0x24 # float + m_nLFOShape = 0x28 # VMixLFOShape_t + +class VMixBoxverbDesc_t: + m_flSizeMax = 0x0 # float + m_flSizeMin = 0x4 # float + m_flComplexity = 0x8 # float + m_flDiffusion = 0xC # float + m_flModDepth = 0x10 # float + m_flModRate = 0x14 # float + m_bParallel = 0x18 # bool + m_filterType = 0x1C # VMixFilterDesc_t + m_flWidth = 0x2C # float + m_flHeight = 0x30 # float + m_flDepth = 0x34 # float + m_flFeedbackScale = 0x38 # float + m_flFeedbackWidth = 0x3C # float + m_flFeedbackHeight = 0x40 # float + m_flFeedbackDepth = 0x44 # float + m_flOutputGain = 0x48 # float + m_flTaps = 0x4C # float + +class VMixConvolutionDesc_t: + m_fldbGain = 0x0 # float + m_flPreDelayMS = 0x4 # float + m_flWetMix = 0x8 # float + m_fldbLow = 0xC # float + m_fldbMid = 0x10 # float + m_fldbHigh = 0x14 # float + m_flLowCutoffFreq = 0x18 # float + m_flHighCutoffFreq = 0x1C # float + +class VMixDelayDesc_t: + m_feedbackFilter = 0x0 # VMixFilterDesc_t + m_bEnableFilter = 0x10 # bool + m_flDelay = 0x14 # float + m_flDirectGain = 0x18 # float + m_flDelayGain = 0x1C # float + m_flFeedbackGain = 0x20 # float + m_flWidth = 0x24 # float + +class VMixDiffusorDesc_t: + m_flSize = 0x0 # float + m_flComplexity = 0x4 # float + m_flFeedback = 0x8 # float + m_flOutputGain = 0xC # float + +class VMixDynamics3BandDesc_t: + m_fldbGainOutput = 0x0 # float + m_flRMSTimeMS = 0x4 # float + m_fldbKneeWidth = 0x8 # float + m_flDepth = 0xC # float + m_flWetMix = 0x10 # float + m_flTimeScale = 0x14 # float + m_flLowCutoffFreq = 0x18 # float + m_flHighCutoffFreq = 0x1C # float + m_bPeakMode = 0x20 # bool + m_bandDesc = 0x24 # VMixDynamicsBand_t[3] + +class VMixDynamicsBand_t: + m_fldbGainInput = 0x0 # float + m_fldbGainOutput = 0x4 # float + m_fldbThresholdBelow = 0x8 # float + m_fldbThresholdAbove = 0xC # float + m_flRatioBelow = 0x10 # float + m_flRatioAbove = 0x14 # float + m_flAttackTimeMS = 0x18 # float + m_flReleaseTimeMS = 0x1C # float + m_bEnable = 0x20 # bool + m_bSolo = 0x21 # bool + +class VMixDynamicsCompressorDesc_t: + m_fldbOutputGain = 0x0 # float + m_fldbCompressionThreshold = 0x4 # float + m_fldbKneeWidth = 0x8 # float + m_flCompressionRatio = 0xC # float + m_flAttackTimeMS = 0x10 # float + m_flReleaseTimeMS = 0x14 # float + m_flRMSTimeMS = 0x18 # float + m_flWetMix = 0x1C # float + m_bPeakMode = 0x20 # bool + +class VMixDynamicsDesc_t: + m_fldbGain = 0x0 # float + m_fldbNoiseGateThreshold = 0x4 # float + m_fldbCompressionThreshold = 0x8 # float + m_fldbLimiterThreshold = 0xC # float + m_fldbKneeWidth = 0x10 # float + m_flRatio = 0x14 # float + m_flLimiterRatio = 0x18 # float + m_flAttackTimeMS = 0x1C # float + m_flReleaseTimeMS = 0x20 # float + m_flRMSTimeMS = 0x24 # float + m_flWetMix = 0x28 # float + m_bPeakMode = 0x2C # bool + +class VMixEQ8Desc_t: + m_stages = 0x0 # VMixFilterDesc_t[8] + +class VMixEffectChainDesc_t: + m_flCrossfadeTime = 0x0 # float + +class VMixEnvelopeDesc_t: + m_flAttackTimeMS = 0x0 # float + m_flHoldTimeMS = 0x4 # float + m_flReleaseTimeMS = 0x8 # float + +class VMixFilterDesc_t: + m_nFilterType = 0x0 # VMixFilterType_t + m_nFilterSlope = 0x2 # VMixFilterSlope_t + m_bEnabled = 0x3 # bool + m_fldbGain = 0x4 # float + m_flCutoffFreq = 0x8 # float + m_flQ = 0xC # float + +class VMixFreeverbDesc_t: + m_flRoomSize = 0x0 # float + m_flDamp = 0x4 # float + m_flWidth = 0x8 # float + m_flLateReflections = 0xC # float + +class VMixModDelayDesc_t: + m_feedbackFilter = 0x0 # VMixFilterDesc_t + m_bPhaseInvert = 0x10 # bool + m_flGlideTime = 0x14 # float + m_flDelay = 0x18 # float + m_flOutputGain = 0x1C # float + m_flFeedbackGain = 0x20 # float + m_flModRate = 0x24 # float + m_flModDepth = 0x28 # float + m_bApplyAntialiasing = 0x2C # bool + +class VMixOscDesc_t: + oscType = 0x0 # VMixLFOShape_t + m_freq = 0x4 # float + m_flPhase = 0x8 # float + +class VMixPannerDesc_t: + m_type = 0x0 # VMixPannerType_t + m_flStrength = 0x4 # float + +class VMixPitchShiftDesc_t: + m_nGrainSampleCount = 0x0 # int32_t + m_flPitchShift = 0x4 # float + m_nQuality = 0x8 # int32_t + m_nProcType = 0xC # int32_t + +class VMixPlateverbDesc_t: + m_flPrefilter = 0x0 # float + m_flInputDiffusion1 = 0x4 # float + m_flInputDiffusion2 = 0x8 # float + m_flDecay = 0xC # float + m_flDamp = 0x10 # float + m_flFeedbackDiffusion1 = 0x14 # float + m_flFeedbackDiffusion2 = 0x18 # float + +class VMixShaperDesc_t: + m_nShape = 0x0 # int32_t + m_fldbDrive = 0x4 # float + m_fldbOutputGain = 0x8 # float + m_flWetMix = 0xC # float + m_nOversampleFactor = 0x10 # int32_t + +class VMixSubgraphSwitchDesc_t: + m_interpolationMode = 0x0 # VMixSubgraphSwitchInterpolationType_t + m_bOnlyTailsOnFadeOut = 0x4 # bool + m_flInterpolationTime = 0x8 # float + +class VMixUtilityDesc_t: + m_nOp = 0x0 # VMixChannelOperation_t + m_flInputPan = 0x4 # float + m_flOutputBalance = 0x8 # float + m_fldbOutputGain = 0xC # float + m_bBassMono = 0x10 # bool + m_flBassFreq = 0x14 # float + +class VMixVocoderDesc_t: + m_nBandCount = 0x0 # int32_t + m_flBandwidth = 0x4 # float + m_fldBModGain = 0x8 # float + m_flFreqRangeStart = 0xC # float + m_flFreqRangeEnd = 0x10 # float + m_fldBUnvoicedGain = 0x14 # float + m_flAttackTimeMS = 0x18 # float + m_flReleaseTimeMS = 0x1C # float + m_nDebugBand = 0x20 # int32_t + m_bPeakMode = 0x24 # bool diff --git a/generated/soundsystem.dll.rs b/generated/soundsystem.dll.rs index 60fa282..7a4589e 100644 --- a/generated/soundsystem.dll.rs +++ b/generated/soundsystem.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.668319800 UTC + * 2023-10-17 02:04:50.037373800 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod CDSPMixgroupModifier { pub const m_mixgroup: usize = 0x0; // CUtlString pub const m_flModifier: usize = 0x8; // float diff --git a/generated/vphysics2.dll.cs b/generated/vphysics2.dll.cs index 24d64a0..554502b 100644 --- a/generated/vphysics2.dll.cs +++ b/generated/vphysics2.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.630609100 UTC + * 2023-10-17 02:04:49.986319 UTC */ public static class CFeIndexedJiggleBone { diff --git a/generated/vphysics2.dll.hpp b/generated/vphysics2.dll.hpp index da920fd..521d852 100644 --- a/generated/vphysics2.dll.hpp +++ b/generated/vphysics2.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:49.978664900 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.622787900 UTC - */ - namespace CFeIndexedJiggleBone { constexpr std::ptrdiff_t m_nNode = 0x0; // uint32_t constexpr std::ptrdiff_t m_nJiggleParent = 0x4; // uint32_t diff --git a/generated/vphysics2.dll.py b/generated/vphysics2.dll.py new file mode 100644 index 0000000..502b894 --- /dev/null +++ b/generated/vphysics2.dll.py @@ -0,0 +1,657 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:49.994354200 UTC +''' + +class CFeIndexedJiggleBone: + m_nNode = 0x0 # uint32_t + m_nJiggleParent = 0x4 # uint32_t + m_jiggleBone = 0x8 # CFeJiggleBone + +class CFeJiggleBone: + m_nFlags = 0x0 # uint32_t + m_flLength = 0x4 # float + m_flTipMass = 0x8 # float + m_flYawStiffness = 0xC # float + m_flYawDamping = 0x10 # float + m_flPitchStiffness = 0x14 # float + m_flPitchDamping = 0x18 # float + m_flAlongStiffness = 0x1C # float + m_flAlongDamping = 0x20 # float + m_flAngleLimit = 0x24 # float + m_flMinYaw = 0x28 # float + m_flMaxYaw = 0x2C # float + m_flYawFriction = 0x30 # float + m_flYawBounce = 0x34 # float + m_flMinPitch = 0x38 # float + m_flMaxPitch = 0x3C # float + m_flPitchFriction = 0x40 # float + m_flPitchBounce = 0x44 # float + m_flBaseMass = 0x48 # float + m_flBaseStiffness = 0x4C # float + m_flBaseDamping = 0x50 # float + m_flBaseMinLeft = 0x54 # float + m_flBaseMaxLeft = 0x58 # float + m_flBaseLeftFriction = 0x5C # float + m_flBaseMinUp = 0x60 # float + m_flBaseMaxUp = 0x64 # float + m_flBaseUpFriction = 0x68 # float + m_flBaseMinForward = 0x6C # float + m_flBaseMaxForward = 0x70 # float + m_flBaseForwardFriction = 0x74 # float + m_flRadius0 = 0x78 # float + m_flRadius1 = 0x7C # float + m_vPoint0 = 0x80 # Vector + m_vPoint1 = 0x8C # Vector + m_nCollisionMask = 0x98 # uint16_t + +class CFeMorphLayer: + m_Name = 0x0 # CUtlString + m_nNameHash = 0x8 # uint32_t + m_Nodes = 0x10 # CUtlVector + m_InitPos = 0x28 # CUtlVector + m_Gravity = 0x40 # CUtlVector + m_GoalStrength = 0x58 # CUtlVector + m_GoalDamping = 0x70 # CUtlVector + +class CFeNamedJiggleBone: + m_strParentBone = 0x0 # CUtlString + m_transform = 0x10 # CTransform + m_nJiggleParent = 0x30 # uint32_t + m_jiggleBone = 0x34 # CFeJiggleBone + +class CFeVertexMapBuildArray: + m_Array = 0x0 # CUtlVector + +class CRegionSVM: + m_Planes = 0x0 # CUtlVector + m_Nodes = 0x18 # CUtlVector + +class CastSphereSATParams_t: + m_vRayStart = 0x0 # Vector + m_vRayDelta = 0xC # Vector + m_flRadius = 0x18 # float + m_flMaxFraction = 0x1C # float + m_flScale = 0x20 # float + m_pHull = 0x28 # RnHull_t* + +class CovMatrix3: + m_vDiag = 0x0 # Vector + m_flXY = 0xC # float + m_flXZ = 0x10 # float + m_flYZ = 0x14 # float + +class Dop26_t: + m_flSupport = 0x0 # float[26] + +class FeAnimStrayRadius_t: + nNode = 0x0 # uint16_t[2] + flMaxDist = 0x4 # float + flRelaxationFactor = 0x8 # float + +class FeAxialEdgeBend_t: + te = 0x0 # float + tv = 0x4 # float + flDist = 0x8 # float + flWeight = 0xC # float[4] + nNode = 0x1C # uint16_t[6] + +class FeBandBendLimit_t: + flDistMin = 0x0 # float + flDistMax = 0x4 # float + nNode = 0x8 # uint16_t[6] + +class FeBoxRigid_t: + tmFrame2 = 0x0 # CTransform + nNode = 0x20 # uint16_t + nCollisionMask = 0x22 # uint16_t + vSize = 0x24 # Vector + nVertexMapIndex = 0x30 # uint16_t + nFlags = 0x32 # uint16_t + +class FeBuildBoxRigid_t: + m_nPriority = 0x40 # int32_t + m_nVertexMapHash = 0x44 # uint32_t + +class FeBuildSphereRigid_t: + m_nPriority = 0x20 # int32_t + m_nVertexMapHash = 0x24 # uint32_t + +class FeBuildTaperedCapsuleRigid_t: + m_nPriority = 0x30 # int32_t + m_nVertexMapHash = 0x34 # uint32_t + +class FeCollisionPlane_t: + nCtrlParent = 0x0 # uint16_t + nChildNode = 0x2 # uint16_t + m_Plane = 0x4 # RnPlane_t + flStrength = 0x14 # float + +class FeCtrlOffset_t: + vOffset = 0x0 # Vector + nCtrlParent = 0xC # uint16_t + nCtrlChild = 0xE # uint16_t + +class FeCtrlOsOffset_t: + nCtrlParent = 0x0 # uint16_t + nCtrlChild = 0x2 # uint16_t + +class FeCtrlSoftOffset_t: + nCtrlParent = 0x0 # uint16_t + nCtrlChild = 0x2 # uint16_t + vOffset = 0x4 # Vector + flAlpha = 0x10 # float + +class FeEdgeDesc_t: + nEdge = 0x0 # uint16_t[2] + nSide = 0x4 # uint16_t[2][2] + nVirtElem = 0xC # uint16_t[2] + +class FeEffectDesc_t: + sName = 0x0 # CUtlString + nNameHash = 0x8 # uint32_t + nType = 0xC # int32_t + m_Params = 0x10 # KeyValues3 + +class FeFitInfluence_t: + nVertexNode = 0x0 # uint32_t + flWeight = 0x4 # float + nMatrixNode = 0x8 # uint32_t + +class FeFitMatrix_t: + bone = 0x0 # CTransform + vCenter = 0x20 # Vector + nEnd = 0x2C # uint16_t + nNode = 0x2E # uint16_t + nBeginDynamic = 0x30 # uint16_t + +class FeFitWeight_t: + flWeight = 0x0 # float + nNode = 0x4 # uint16_t + nDummy = 0x6 # uint16_t + +class FeFollowNode_t: + nParentNode = 0x0 # uint16_t + nChildNode = 0x2 # uint16_t + flWeight = 0x4 # float + +class FeKelagerBend2_t: + flWeight = 0x0 # float[3] + flHeight0 = 0xC # float + nNode = 0x10 # uint16_t[3] + nReserved = 0x16 # uint16_t + +class FeMorphLayerDepr_t: + m_Name = 0x0 # CUtlString + m_nNameHash = 0x8 # uint32_t + m_Nodes = 0x10 # CUtlVector + m_InitPos = 0x28 # CUtlVector + m_Gravity = 0x40 # CUtlVector + m_GoalStrength = 0x58 # CUtlVector + m_GoalDamping = 0x70 # CUtlVector + m_nFlags = 0x88 # uint32_t + +class FeNodeBase_t: + nNode = 0x0 # uint16_t + nDummy = 0x2 # uint16_t[3] + nNodeX0 = 0x8 # uint16_t + nNodeX1 = 0xA # uint16_t + nNodeY0 = 0xC # uint16_t + nNodeY1 = 0xE # uint16_t + qAdjust = 0x10 # QuaternionStorage + +class FeNodeIntegrator_t: + flPointDamping = 0x0 # float + flAnimationForceAttraction = 0x4 # float + flAnimationVertexAttraction = 0x8 # float + flGravity = 0xC # float + +class FeNodeReverseOffset_t: + vOffset = 0x0 # Vector + nBoneCtrl = 0xC # uint16_t + nTargetNode = 0xE # uint16_t + +class FeNodeWindBase_t: + nNodeX0 = 0x0 # uint16_t + nNodeX1 = 0x2 # uint16_t + nNodeY0 = 0x4 # uint16_t + nNodeY1 = 0x6 # uint16_t + +class FeProxyVertexMap_t: + m_Name = 0x0 # CUtlString + m_flWeight = 0x8 # float + +class FeQuad_t: + nNode = 0x0 # uint16_t[4] + flSlack = 0x8 # float + vShape = 0xC # Vector4D[4] + +class FeRigidColliderIndices_t: + m_nTaperedCapsuleRigidIndex = 0x0 # uint16_t + m_nSphereRigidIndex = 0x2 # uint16_t + m_nBoxRigidIndex = 0x4 # uint16_t + m_nCollisionPlaneIndex = 0x6 # uint16_t + +class FeRodConstraint_t: + nNode = 0x0 # uint16_t[2] + flMaxDist = 0x4 # float + flMinDist = 0x8 # float + flWeight0 = 0xC # float + flRelaxationFactor = 0x10 # float + +class FeSimdAnimStrayRadius_t: + nNode = 0x0 # uint16_t[4][2] + flMaxDist = 0x10 # fltx4 + flRelaxationFactor = 0x20 # fltx4 + +class FeSimdNodeBase_t: + nNode = 0x0 # uint16_t[4] + nNodeX0 = 0x8 # uint16_t[4] + nNodeX1 = 0x10 # uint16_t[4] + nNodeY0 = 0x18 # uint16_t[4] + nNodeY1 = 0x20 # uint16_t[4] + nDummy = 0x28 # uint16_t[4] + qAdjust = 0x30 # FourQuaternions + +class FeSimdQuad_t: + nNode = 0x0 # uint16_t[4][4] + f4Slack = 0x20 # fltx4 + vShape = 0x30 # FourVectors[4] + f4Weights = 0xF0 # fltx4[4] + +class FeSimdRodConstraint_t: + nNode = 0x0 # uint16_t[4][2] + f4MaxDist = 0x10 # fltx4 + f4MinDist = 0x20 # fltx4 + f4Weight0 = 0x30 # fltx4 + f4RelaxationFactor = 0x40 # fltx4 + +class FeSimdSpringIntegrator_t: + nNode = 0x0 # uint16_t[4][2] + flSpringRestLength = 0x10 # fltx4 + flSpringConstant = 0x20 # fltx4 + flSpringDamping = 0x30 # fltx4 + flNodeWeight0 = 0x40 # fltx4 + +class FeSimdTri_t: + nNode = 0x0 # uint32_t[4][3] + w1 = 0x30 # fltx4 + w2 = 0x40 # fltx4 + v1x = 0x50 # fltx4 + v2 = 0x60 # FourVectors2D + +class FeSoftParent_t: + nParent = 0x0 # int32_t + flAlpha = 0x4 # float + +class FeSourceEdge_t: + nNode = 0x0 # uint16_t[2] + +class FeSphereRigid_t: + vSphere = 0x0 # fltx4 + nNode = 0x10 # uint16_t + nCollisionMask = 0x12 # uint16_t + nVertexMapIndex = 0x14 # uint16_t + nFlags = 0x16 # uint16_t + +class FeSpringIntegrator_t: + nNode = 0x0 # uint16_t[2] + flSpringRestLength = 0x4 # float + flSpringConstant = 0x8 # float + flSpringDamping = 0xC # float + flNodeWeight0 = 0x10 # float + +class FeStiffHingeBuild_t: + flMaxAngle = 0x0 # float + flStrength = 0x4 # float + flMotionBias = 0x8 # float[3] + nNode = 0x14 # uint16_t[3] + +class FeTaperedCapsuleRigid_t: + vSphere = 0x0 # fltx4[2] + nNode = 0x20 # uint16_t + nCollisionMask = 0x22 # uint16_t + nVertexMapIndex = 0x24 # uint16_t + nFlags = 0x26 # uint16_t + +class FeTaperedCapsuleStretch_t: + nNode = 0x0 # uint16_t[2] + nCollisionMask = 0x4 # uint16_t + nDummy = 0x6 # uint16_t + flRadius = 0x8 # float[2] + +class FeTreeChildren_t: + nChild = 0x0 # uint16_t[2] + +class FeTri_t: + nNode = 0x0 # uint16_t[3] + w1 = 0x8 # float + w2 = 0xC # float + v1x = 0x10 # float + v2 = 0x14 # Vector2D + +class FeTwistConstraint_t: + nNodeOrient = 0x0 # uint16_t + nNodeEnd = 0x2 # uint16_t + flTwistRelax = 0x4 # float + flSwingRelax = 0x8 # float + +class FeVertexMapBuild_t: + m_VertexMapName = 0x0 # CUtlString + m_nNameHash = 0x8 # uint32_t + m_Color = 0xC # Color + m_flVolumetricSolveStrength = 0x10 # float + m_nScaleSourceNode = 0x14 # int32_t + m_Weights = 0x18 # CUtlVector + +class FeVertexMapDesc_t: + sName = 0x0 # CUtlString + nNameHash = 0x8 # uint32_t + nColor = 0xC # uint32_t + nFlags = 0x10 # uint32_t + nVertexBase = 0x14 # uint16_t + nVertexCount = 0x16 # uint16_t + nMapOffset = 0x18 # uint32_t + nNodeListOffset = 0x1C # uint32_t + vCenterOfMass = 0x20 # Vector + flVolumetricSolveStrength = 0x2C # float + nScaleSourceNode = 0x30 # int16_t + nNodeListCount = 0x32 # uint16_t + +class FeWeightedNode_t: + nNode = 0x0 # uint16_t + nWeight = 0x2 # uint16_t + +class FeWorldCollisionParams_t: + flWorldFriction = 0x0 # float + flGroundFriction = 0x4 # float + nListBegin = 0x8 # uint16_t + nListEnd = 0xA # uint16_t + +class FourCovMatrices3: + m_vDiag = 0x0 # FourVectors + m_flXY = 0x30 # fltx4 + m_flXZ = 0x40 # fltx4 + m_flYZ = 0x50 # fltx4 + +class FourVectors2D: + x = 0x0 # fltx4 + y = 0x10 # fltx4 + +class OldFeEdge_t: + m_flK = 0x0 # float[3] + invA = 0xC # float + t = 0x10 # float + flThetaRelaxed = 0x14 # float + flThetaFactor = 0x18 # float + c01 = 0x1C # float + c02 = 0x20 # float + c03 = 0x24 # float + c04 = 0x28 # float + flAxialModelDist = 0x2C # float + flAxialModelWeights = 0x30 # float[4] + m_nNode = 0x40 # uint16_t[4] + +class PhysFeModelDesc_t: + m_CtrlHash = 0x0 # CUtlVector + m_CtrlName = 0x18 # CUtlVector + m_nStaticNodeFlags = 0x30 # uint32_t + m_nDynamicNodeFlags = 0x34 # uint32_t + m_flLocalForce = 0x38 # float + m_flLocalRotation = 0x3C # float + m_nNodeCount = 0x40 # uint16_t + m_nStaticNodes = 0x42 # uint16_t + m_nRotLockStaticNodes = 0x44 # uint16_t + m_nFirstPositionDrivenNode = 0x46 # uint16_t + m_nSimdTriCount1 = 0x48 # uint16_t + m_nSimdTriCount2 = 0x4A # uint16_t + m_nSimdQuadCount1 = 0x4C # uint16_t + m_nSimdQuadCount2 = 0x4E # uint16_t + m_nQuadCount1 = 0x50 # uint16_t + m_nQuadCount2 = 0x52 # uint16_t + m_nTreeDepth = 0x54 # uint16_t + m_nNodeBaseJiggleboneDependsCount = 0x56 # uint16_t + m_nRopeCount = 0x58 # uint16_t + m_Ropes = 0x60 # CUtlVector + m_NodeBases = 0x78 # CUtlVector + m_SimdNodeBases = 0x90 # CUtlVector + m_Quads = 0xA8 # CUtlVector + m_SimdQuads = 0xC0 # CUtlVector + m_SimdTris = 0xD8 # CUtlVector + m_SimdRods = 0xF0 # CUtlVector + m_InitPose = 0x108 # CUtlVector + m_Rods = 0x120 # CUtlVector + m_Twists = 0x138 # CUtlVector + m_AxialEdges = 0x150 # CUtlVector + m_NodeInvMasses = 0x168 # CUtlVector + m_CtrlOffsets = 0x180 # CUtlVector + m_CtrlOsOffsets = 0x198 # CUtlVector + m_FollowNodes = 0x1B0 # CUtlVector + m_CollisionPlanes = 0x1C8 # CUtlVector + m_NodeIntegrator = 0x1E0 # CUtlVector + m_SpringIntegrator = 0x1F8 # CUtlVector + m_SimdSpringIntegrator = 0x210 # CUtlVector + m_WorldCollisionParams = 0x228 # CUtlVector + m_LegacyStretchForce = 0x240 # CUtlVector + m_NodeCollisionRadii = 0x258 # CUtlVector + m_DynNodeFriction = 0x270 # CUtlVector + m_LocalRotation = 0x288 # CUtlVector + m_LocalForce = 0x2A0 # CUtlVector + m_TaperedCapsuleStretches = 0x2B8 # CUtlVector + m_TaperedCapsuleRigids = 0x2D0 # CUtlVector + m_SphereRigids = 0x2E8 # CUtlVector + m_WorldCollisionNodes = 0x300 # CUtlVector + m_TreeParents = 0x318 # CUtlVector + m_TreeCollisionMasks = 0x330 # CUtlVector + m_TreeChildren = 0x348 # CUtlVector + m_FreeNodes = 0x360 # CUtlVector + m_FitMatrices = 0x378 # CUtlVector + m_FitWeights = 0x390 # CUtlVector + m_ReverseOffsets = 0x3A8 # CUtlVector + m_AnimStrayRadii = 0x3C0 # CUtlVector + m_SimdAnimStrayRadii = 0x3D8 # CUtlVector + m_KelagerBends = 0x3F0 # CUtlVector + m_CtrlSoftOffsets = 0x408 # CUtlVector + m_JiggleBones = 0x420 # CUtlVector + m_SourceElems = 0x438 # CUtlVector + m_GoalDampedSpringIntegrators = 0x450 # CUtlVector + m_Tris = 0x468 # CUtlVector + m_nTriCount1 = 0x480 # uint16_t + m_nTriCount2 = 0x482 # uint16_t + m_nReservedUint8 = 0x484 # uint8_t + m_nExtraPressureIterations = 0x485 # uint8_t + m_nExtraGoalIterations = 0x486 # uint8_t + m_nExtraIterations = 0x487 # uint8_t + m_BoxRigids = 0x488 # CUtlVector + m_DynNodeVertexSet = 0x4A0 # CUtlVector + m_VertexSetNames = 0x4B8 # CUtlVector + m_RigidColliderPriorities = 0x4D0 # CUtlVector + m_MorphLayers = 0x4E8 # CUtlVector + m_MorphSetData = 0x500 # CUtlVector + m_VertexMaps = 0x518 # CUtlVector + m_VertexMapValues = 0x530 # CUtlVector + m_Effects = 0x548 # CUtlVector + m_LockToParent = 0x560 # CUtlVector + m_LockToGoal = 0x578 # CUtlVector + m_DynNodeWindBases = 0x590 # CUtlVector + m_flInternalPressure = 0x5A8 # float + m_flDefaultTimeDilation = 0x5AC # float + m_flWindage = 0x5B0 # float + m_flWindDrag = 0x5B4 # float + m_flDefaultSurfaceStretch = 0x5B8 # float + m_flDefaultThreadStretch = 0x5BC # float + m_flDefaultGravityScale = 0x5C0 # float + m_flDefaultVelAirDrag = 0x5C4 # float + m_flDefaultExpAirDrag = 0x5C8 # float + m_flDefaultVelQuadAirDrag = 0x5CC # float + m_flDefaultExpQuadAirDrag = 0x5D0 # float + m_flRodVelocitySmoothRate = 0x5D4 # float + m_flQuadVelocitySmoothRate = 0x5D8 # float + m_flAddWorldCollisionRadius = 0x5DC # float + m_flDefaultVolumetricSolveAmount = 0x5E0 # float + m_nRodVelocitySmoothIterations = 0x5E4 # uint16_t + m_nQuadVelocitySmoothIterations = 0x5E6 # uint16_t + +class RnBlendVertex_t: + m_nWeight0 = 0x0 # uint16_t + m_nIndex0 = 0x2 # uint16_t + m_nWeight1 = 0x4 # uint16_t + m_nIndex1 = 0x6 # uint16_t + m_nWeight2 = 0x8 # uint16_t + m_nIndex2 = 0xA # uint16_t + m_nFlags = 0xC # uint16_t + m_nTargetIndex = 0xE # uint16_t + +class RnBodyDesc_t: + m_sDebugName = 0x0 # CUtlString + m_vPosition = 0x8 # Vector + m_qOrientation = 0x14 # QuaternionStorage + m_vLinearVelocity = 0x24 # Vector + m_vAngularVelocity = 0x30 # Vector + m_vLocalMassCenter = 0x3C # Vector + m_LocalInertiaInv = 0x48 # Vector[3] + m_flMassInv = 0x6C # float + m_flGameMass = 0x70 # float + m_flInertiaScaleInv = 0x74 # float + m_flLinearDamping = 0x78 # float + m_flAngularDamping = 0x7C # float + m_flLinearDrag = 0x80 # float + m_flAngularDrag = 0x84 # float + m_flLinearBuoyancyDrag = 0x88 # float + m_flAngularBuoyancyDrag = 0x8C # float + m_vLastAwakeForceAccum = 0x90 # Vector + m_vLastAwakeTorqueAccum = 0x9C # Vector + m_flBuoyancyFactor = 0xA8 # float + m_flGravityScale = 0xAC # float + m_flTimeScale = 0xB0 # float + m_nBodyType = 0xB4 # int32_t + m_nGameIndex = 0xB8 # uint32_t + m_nGameFlags = 0xBC # uint32_t + m_nMinVelocityIterations = 0xC0 # int8_t + m_nMinPositionIterations = 0xC1 # int8_t + m_nMassPriority = 0xC2 # int8_t + m_bEnabled = 0xC3 # bool + m_bSleeping = 0xC4 # bool + m_bIsContinuousEnabled = 0xC5 # bool + m_bDragEnabled = 0xC6 # bool + m_bBuoyancyDragEnabled = 0xC7 # bool + m_bGravityDisabled = 0xC8 # bool + m_bSpeculativeEnabled = 0xC9 # bool + m_bHasShadowController = 0xCA # bool + +class RnCapsuleDesc_t: + m_Capsule = 0x10 # RnCapsule_t + +class RnCapsule_t: + m_vCenter = 0x0 # Vector[2] + m_flRadius = 0x18 # float + +class RnFace_t: + m_nEdge = 0x0 # uint8_t + +class RnHalfEdge_t: + m_nNext = 0x0 # uint8_t + m_nTwin = 0x1 # uint8_t + m_nOrigin = 0x2 # uint8_t + m_nFace = 0x3 # uint8_t + +class RnHullDesc_t: + m_Hull = 0x10 # RnHull_t + +class RnHull_t: + m_vCentroid = 0x0 # Vector + m_flMaxAngularRadius = 0xC # float + m_Bounds = 0x10 # AABB_t + m_vOrthographicAreas = 0x28 # Vector + m_MassProperties = 0x34 # matrix3x4_t + m_flVolume = 0x64 # float + m_Vertices = 0x68 # CUtlVector + m_Edges = 0x80 # CUtlVector + m_Faces = 0x98 # CUtlVector + m_Planes = 0xB0 # CUtlVector + m_nFlags = 0xC8 # uint32_t + m_pRegionSVM = 0xD0 # CRegionSVM* + +class RnMeshDesc_t: + m_Mesh = 0x10 # RnMesh_t + +class RnMesh_t: + m_vMin = 0x0 # Vector + m_vMax = 0xC # Vector + m_Nodes = 0x18 # CUtlVector + m_Vertices = 0x30 # CUtlVectorSIMDPaddedVector + m_Triangles = 0x48 # CUtlVector + m_Wings = 0x60 # CUtlVector + m_Materials = 0x78 # CUtlVector + m_vOrthographicAreas = 0x90 # Vector + m_nFlags = 0x9C # uint32_t + m_nDebugFlags = 0xA0 # uint32_t + +class RnNode_t: + m_vMin = 0x0 # Vector + m_nChildren = 0xC # uint32_t + m_vMax = 0x10 # Vector + m_nTriangleOffset = 0x1C # uint32_t + +class RnPlane_t: + m_vNormal = 0x0 # Vector + m_flOffset = 0xC # float + +class RnShapeDesc_t: + m_nCollisionAttributeIndex = 0x0 # uint32_t + m_nSurfacePropertyIndex = 0x4 # uint32_t + m_UserFriendlyName = 0x8 # CUtlString + +class RnSoftbodyCapsule_t: + m_vCenter = 0x0 # Vector[2] + m_flRadius = 0x18 # float + m_nParticle = 0x1C # uint16_t[2] + +class RnSoftbodyParticle_t: + m_flMassInv = 0x0 # float + +class RnSoftbodySpring_t: + m_nParticle = 0x0 # uint16_t[2] + m_flLength = 0x4 # float + +class RnSphereDesc_t: + m_Sphere = 0x10 # RnSphere_t + +class RnSphere_t: + m_vCenter = 0x0 # Vector + m_flRadius = 0xC # float + +class RnTriangle_t: + m_nIndex = 0x0 # int32_t[3] + +class RnWing_t: + m_nIndex = 0x0 # int32_t[3] + +class VertexPositionColor_t: + m_vPosition = 0x0 # Vector + +class VertexPositionNormal_t: + m_vPosition = 0x0 # Vector + m_vNormal = 0xC # Vector + +class constraint_axislimit_t: + flMinRotation = 0x0 # float + flMaxRotation = 0x4 # float + flMotorTargetAngSpeed = 0x8 # float + flMotorMaxTorque = 0xC # float + +class constraint_breakableparams_t: + strength = 0x0 # float + forceLimit = 0x4 # float + torqueLimit = 0x8 # float + bodyMassScale = 0xC # float[2] + isActive = 0x14 # bool + +class constraint_hingeparams_t: + worldPosition = 0x0 # Vector + worldAxisDirection = 0xC # Vector + hingeAxis = 0x18 # constraint_axislimit_t + constraint = 0x28 # constraint_breakableparams_t + +class vphysics_save_cphysicsbody_t: + m_nOldPointer = 0xD0 # uint64_t diff --git a/generated/vphysics2.dll.rs b/generated/vphysics2.dll.rs index 5d21329..3673615 100644 --- a/generated/vphysics2.dll.rs +++ b/generated/vphysics2.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.638771500 UTC + * 2023-10-17 02:04:50.002943900 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod CFeIndexedJiggleBone { pub const m_nNode: usize = 0x0; // uint32_t pub const m_nJiggleParent: usize = 0x4; // uint32_t diff --git a/generated/worldrenderer.dll.cs b/generated/worldrenderer.dll.cs index febd513..4d50374 100644 --- a/generated/worldrenderer.dll.cs +++ b/generated/worldrenderer.dll.cs @@ -1,6 +1,6 @@ /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.691751700 UTC + * 2023-10-17 02:04:50.063331200 UTC */ public static class AggregateLODSetup_t { diff --git a/generated/worldrenderer.dll.hpp b/generated/worldrenderer.dll.hpp index 0cf960c..6a779b3 100644 --- a/generated/worldrenderer.dll.hpp +++ b/generated/worldrenderer.dll.hpp @@ -1,12 +1,12 @@ +/* + * https://github.com/a2x/cs2-dumper + * 2023-10-17 02:04:50.060524800 UTC + */ + #pragma once #include -/* - * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.689004 UTC - */ - namespace AggregateLODSetup_t { constexpr std::ptrdiff_t m_vLODOrigin = 0x0; // Vector constexpr std::ptrdiff_t m_fMaxObjectScale = 0xC; // float diff --git a/generated/worldrenderer.dll.py b/generated/worldrenderer.dll.py new file mode 100644 index 0000000..c41b5e2 --- /dev/null +++ b/generated/worldrenderer.dll.py @@ -0,0 +1,197 @@ +''' +https://github.com/a2x/cs2-dumper +2023-10-17 02:04:50.066321500 UTC +''' + +class AggregateLODSetup_t: + m_vLODOrigin = 0x0 # Vector + m_fMaxObjectScale = 0xC # float + m_fSwitchDistances = 0x10 # CUtlVectorFixedGrowable + +class AggregateMeshInfo_t: + m_nVisClusterMemberOffset = 0x0 # uint32_t + m_nVisClusterMemberCount = 0x4 # uint8_t + m_bHasTransform = 0x5 # bool + m_nDrawCallIndex = 0x6 # int16_t + m_nLODSetupIndex = 0x8 # int16_t + m_nLODGroupMask = 0xA # uint8_t + m_vTintColor = 0xB # Color + m_objectFlags = 0x10 # ObjectTypeFlags_t + m_nLightProbeVolumePrecomputedHandshake = 0x14 # int32_t + +class AggregateSceneObject_t: + m_allFlags = 0x0 # ObjectTypeFlags_t + m_anyFlags = 0x4 # ObjectTypeFlags_t + m_nLayer = 0x8 # int16_t + m_aggregateMeshes = 0x10 # CUtlVector + m_lodSetups = 0x28 # CUtlVector + m_visClusterMembership = 0x40 # CUtlVector + m_fragmentTransforms = 0x58 # CUtlVector + m_renderableModel = 0x70 # CStrongHandle + +class BakedLightingInfo_t: + m_nLightmapVersionNumber = 0x0 # uint32_t + m_nLightmapGameVersionNumber = 0x4 # uint32_t + m_vLightmapUvScale = 0x8 # Vector2D + m_bHasLightmaps = 0x10 # bool + m_lightMaps = 0x18 # CUtlVector> + +class BaseSceneObjectOverride_t: + m_nSceneObjectIndex = 0x0 # uint32_t + +class CEntityIdentity: + m_nameStringableIndex = 0x14 # int32_t + m_name = 0x18 # CUtlSymbolLarge + m_designerName = 0x20 # CUtlSymbolLarge + m_flags = 0x30 # uint32_t + m_worldGroupId = 0x38 # WorldGroupId_t + m_fDataObjectTypes = 0x3C # uint32_t + m_PathIndex = 0x40 # ChangeAccessorFieldPathIndex_t + m_pPrev = 0x58 # CEntityIdentity* + m_pNext = 0x60 # CEntityIdentity* + m_pPrevByClass = 0x68 # CEntityIdentity* + m_pNextByClass = 0x70 # CEntityIdentity* + +class CEntityInstance: + m_iszPrivateVScripts = 0x8 # CUtlSymbolLarge + m_pEntity = 0x10 # CEntityIdentity* + m_CScriptComponent = 0x28 # CScriptComponent* + +class CScriptComponent: + m_scriptClassName = 0x30 # CUtlSymbolLarge + +class CVoxelVisibility: + m_nBaseClusterCount = 0x40 # uint32_t + m_nPVSBytesPerCluster = 0x44 # uint32_t + m_vMinBounds = 0x48 # Vector + m_vMaxBounds = 0x54 # Vector + m_flGridSize = 0x60 # float + m_nSkyVisibilityCluster = 0x64 # uint32_t + m_nSunVisibilityCluster = 0x68 # uint32_t + m_NodeBlock = 0x6C # VoxelVisBlockOffset_t + m_RegionBlock = 0x74 # VoxelVisBlockOffset_t + m_EnclosedClusterListBlock = 0x7C # VoxelVisBlockOffset_t + m_EnclosedClustersBlock = 0x84 # VoxelVisBlockOffset_t + m_MasksBlock = 0x8C # VoxelVisBlockOffset_t + m_nVisBlocks = 0x94 # VoxelVisBlockOffset_t + +class ClutterSceneObject_t: + m_Bounds = 0x0 # AABB_t + m_flags = 0x18 # ObjectTypeFlags_t + m_nLayer = 0x1C # int16_t + m_instancePositions = 0x20 # CUtlVector + m_instanceScales = 0x50 # CUtlVector + m_instanceTintSrgb = 0x68 # CUtlVector + m_tiles = 0x80 # CUtlVector + m_renderableModel = 0x98 # CStrongHandle + +class ClutterTile_t: + m_nFirstInstance = 0x0 # uint32_t + m_nLastInstance = 0x4 # uint32_t + m_BoundsWs = 0x8 # AABB_t + +class EntityIOConnectionData_t: + m_outputName = 0x0 # CUtlString + m_targetType = 0x8 # uint32_t + m_targetName = 0x10 # CUtlString + m_inputName = 0x18 # CUtlString + m_overrideParam = 0x20 # CUtlString + m_flDelay = 0x28 # float + m_nTimesToFire = 0x2C # int32_t + +class EntityKeyValueData_t: + m_connections = 0x8 # CUtlVector + m_keyValuesData = 0x20 # CUtlBinaryBlock + +class ExtraVertexStreamOverride_t: + m_nSubSceneObject = 0x4 # uint32_t + m_nDrawCallIndex = 0x8 # uint32_t + m_nAdditionalMeshDrawPrimitiveFlags = 0xC # MeshDrawPrimitiveFlags_t + m_extraBufferBinding = 0x10 # CRenderBufferBinding + +class InfoOverlayData_t: + m_transform = 0x0 # matrix3x4_t + m_flWidth = 0x30 # float + m_flHeight = 0x34 # float + m_flDepth = 0x38 # float + m_vUVStart = 0x3C # Vector2D + m_vUVEnd = 0x44 # Vector2D + m_pMaterial = 0x50 # CStrongHandle + m_nRenderOrder = 0x58 # int32_t + m_vTintColor = 0x5C # Vector4D + m_nSequenceOverride = 0x6C # int32_t + +class MaterialOverride_t: + m_nSubSceneObject = 0x4 # uint32_t + m_nDrawCallIndex = 0x8 # uint32_t + m_pMaterial = 0x10 # CStrongHandle + +class NodeData_t: + m_nParent = 0x0 # int32_t + m_vOrigin = 0x4 # Vector + m_vMinBounds = 0x10 # Vector + m_vMaxBounds = 0x1C # Vector + m_flMinimumDistance = 0x28 # float + m_ChildNodeIndices = 0x30 # CUtlVector + m_worldNodePrefix = 0x48 # CUtlString + +class PermEntityLumpData_t: + m_name = 0x8 # CUtlString + m_hammerUniqueId = 0x10 # CUtlString + m_childLumps = 0x18 # CUtlVector> + m_entityKeyValues = 0x30 # CUtlLeanVector + +class SceneObject_t: + m_nObjectID = 0x0 # uint32_t + m_vTransform = 0x4 # Vector4D[3] + m_flFadeStartDistance = 0x34 # float + m_flFadeEndDistance = 0x38 # float + m_vTintColor = 0x3C # Vector4D + m_skin = 0x50 # CUtlString + m_nObjectTypeFlags = 0x58 # ObjectTypeFlags_t + m_vLightingOrigin = 0x5C # Vector + m_nLightGroup = 0x68 # uint32_t + m_nOverlayRenderOrder = 0x6C # int16_t + m_nLODOverride = 0x6E # int16_t + m_nCubeMapPrecomputedHandshake = 0x70 # int32_t + m_nLightProbeVolumePrecomputedHandshake = 0x74 # int32_t + m_renderableModel = 0x80 # CStrongHandle + m_renderable = 0x88 # CStrongHandle + +class VoxelVisBlockOffset_t: + m_nOffset = 0x0 # uint32_t + m_nElementCount = 0x4 # uint32_t + +class WorldBuilderParams_t: + m_flMinDrawVolumeSize = 0x0 # float + m_bBuildBakedLighting = 0x4 # bool + m_vLightmapUvScale = 0x8 # Vector2D + m_nCompileTimestamp = 0x10 # uint64_t + m_nCompileFingerprint = 0x18 # uint64_t + +class WorldNodeOnDiskBufferData_t: + m_nElementCount = 0x0 # int32_t + m_nElementSizeInBytes = 0x4 # int32_t + m_inputLayoutFields = 0x8 # CUtlVector + m_pData = 0x20 # CUtlVector + +class WorldNode_t: + m_sceneObjects = 0x0 # CUtlVector + m_infoOverlays = 0x18 # CUtlVector + m_visClusterMembership = 0x30 # CUtlVector + m_aggregateSceneObjects = 0x48 # CUtlVector + m_clutterSceneObjects = 0x60 # CUtlVector + m_extraVertexStreamOverrides = 0x78 # CUtlVector + m_materialOverrides = 0x90 # CUtlVector + m_extraVertexStreams = 0xA8 # CUtlVector + m_layerNames = 0xC0 # CUtlVector + m_sceneObjectLayerIndices = 0xD8 # CUtlVector + m_overlayLayerIndices = 0xF0 # CUtlVector + m_grassFileName = 0x108 # CUtlString + m_nodeLightingInfo = 0x110 # BakedLightingInfo_t + +class World_t: + m_builderParams = 0x0 # WorldBuilderParams_t + m_worldNodes = 0x20 # CUtlVector + m_worldLightingInfo = 0x38 # BakedLightingInfo_t + m_entityLumps = 0x68 # CUtlVector> diff --git a/generated/worldrenderer.dll.rs b/generated/worldrenderer.dll.rs index aec8b71..22584e4 100644 --- a/generated/worldrenderer.dll.rs +++ b/generated/worldrenderer.dll.rs @@ -1,10 +1,10 @@ -#![allow(non_snake_case, non_upper_case_globals)] - /* * https://github.com/a2x/cs2-dumper - * 2023-10-15 12:13:31.694871800 UTC + * 2023-10-17 02:04:50.069165400 UTC */ +#![allow(non_snake_case, non_upper_case_globals)] + pub mod AggregateLODSetup_t { pub const m_vLODOrigin: usize = 0x0; // Vector pub const m_fMaxObjectScale: usize = 0xC; // float diff --git a/src/builder/json_file_builder.rs b/src/builder/json_file_builder.rs index 57b9025..4694c99 100644 --- a/src/builder/json_file_builder.rs +++ b/src/builder/json_file_builder.rs @@ -7,14 +7,14 @@ use super::FileBuilder; #[derive(Debug, PartialEq)] pub struct JsonFileBuilder { json: Value, - namespace: String, + current_namespace: String, } impl Default for JsonFileBuilder { fn default() -> Self { Self { json: Value::Object(Map::new()), - namespace: String::new(), + current_namespace: String::new(), } } } @@ -29,7 +29,7 @@ impl FileBuilder for JsonFileBuilder { } fn write_namespace(&mut self, _output: &mut dyn Write, name: &str) -> Result<()> { - self.namespace = name.to_string(); + self.current_namespace = name.to_string(); Ok(()) } @@ -42,7 +42,9 @@ impl FileBuilder for JsonFileBuilder { _comment: Option<&str>, ) -> Result<()> { if let Some(map) = self.json.as_object_mut() { - let entry = map.entry(&self.namespace).or_insert_with(|| json!({})); + let entry = map + .entry(&self.current_namespace) + .or_insert_with(|| json!({})); if let Some(object) = entry.as_object_mut() { object.insert(name.to_string(), json!(value)); diff --git a/src/builder/mod.rs b/src/builder/mod.rs index a597d24..e06ada9 100644 --- a/src/builder/mod.rs +++ b/src/builder/mod.rs @@ -4,12 +4,14 @@ pub use cpp_file_builder::CppFileBuilder; pub use csharp_file_builder::CSharpFileBuilder; pub use file_builder::FileBuilder; pub use json_file_builder::JsonFileBuilder; +pub use python_file_builder::PythonFileBuilder; pub use rust_file_builder::RustFileBuilder; pub mod cpp_file_builder; pub mod csharp_file_builder; pub mod file_builder; pub mod json_file_builder; +pub mod python_file_builder; pub mod rust_file_builder; #[derive(Debug, PartialEq)] @@ -17,6 +19,7 @@ pub enum FileBuilderEnum { CppFileBuilder(CppFileBuilder), CSharpFileBuilder(CSharpFileBuilder), JsonFileBuilder(JsonFileBuilder), + PythonFileBuilder(PythonFileBuilder), RustFileBuilder(RustFileBuilder), } @@ -54,6 +57,7 @@ impl FileBuilderEnum { FileBuilderEnum::CppFileBuilder(builder) => builder, FileBuilderEnum::CSharpFileBuilder(builder) => builder, FileBuilderEnum::JsonFileBuilder(builder) => builder, + FileBuilderEnum::PythonFileBuilder(builder) => builder, FileBuilderEnum::RustFileBuilder(builder) => builder, } } diff --git a/src/builder/python_file_builder.rs b/src/builder/python_file_builder.rs new file mode 100644 index 0000000..de65ec9 --- /dev/null +++ b/src/builder/python_file_builder.rs @@ -0,0 +1,43 @@ +use std::io::{Result, Write}; + +use super::FileBuilder; + +#[derive(Debug, PartialEq)] +pub struct PythonFileBuilder; + +impl FileBuilder for PythonFileBuilder { + fn extension(&mut self) -> &str { + "py" + } + + fn write_top_level(&mut self, _output: &mut dyn Write) -> Result<()> { + Ok(()) + } + + fn write_namespace(&mut self, output: &mut dyn Write, name: &str) -> Result<()> { + write!(output, "class {}:\n", name)?; + + Ok(()) + } + + fn write_variable( + &mut self, + output: &mut dyn Write, + name: &str, + value: usize, + comment: Option<&str>, + ) -> Result<()> { + match comment { + Some(comment) => write!(output, " {} = {:#X} # {}\n", name, value, comment), + None => write!(output, " {} = {:#X}\n", name, value), + } + } + + fn write_closure(&mut self, output: &mut dyn Write, eof: bool) -> Result<()> { + if !eof { + write!(output, "\n")?; + } + + Ok(()) + } +} diff --git a/src/dumpers/interfaces.rs b/src/dumpers/interfaces.rs index 778580e..2f308b4 100644 --- a/src/dumpers/interfaces.rs +++ b/src/dumpers/interfaces.rs @@ -1,51 +1,21 @@ -use std::ffi::c_char; -use std::mem::offset_of; +use convert_case::{Case, Casing}; use crate::builder::FileBuilderEnum; use crate::dumpers::Entry; use crate::error::Result; use crate::remote::Process; +use crate::sdk::InterfaceReg; use super::{generate_files, Entries}; -#[derive(Debug)] -#[repr(C)] -struct InterfaceReg { - create_fn: *const (), // 0x0000 - name: *const c_char, // 0x0008 - next: *mut InterfaceReg, // 0x0010 -} - -impl InterfaceReg { - pub fn ptr(&self, process: &Process) -> Result { - process - .read_memory::(self as *const _ as usize + offset_of!(InterfaceReg, create_fn)) - } - - pub fn name(&self, process: &Process) -> Result { - let name_ptr = process - .read_memory::(self as *const _ as usize + offset_of!(InterfaceReg, name))?; - - process.read_string(name_ptr) - } - - pub fn next(&self, process: &Process) -> Result<*mut InterfaceReg> { - process.read_memory::<*mut InterfaceReg>( - self as *const _ as usize + offset_of!(InterfaceReg, next), - ) - } -} - pub fn dump_interfaces(builders: &mut Vec, process: &Process) -> Result<()> { - let module_names = process.get_loaded_modules()?; - let mut entries = Entries::new(); - for module_name in module_names { - if module_name == "crashhandler64.dll" { - continue; - } - + for module_name in process + .get_loaded_modules()? + .into_iter() + .filter(|module_name| *module_name != "crashhandler64.dll") + { let module = process.get_module_by_name(&module_name)?; if let Some(create_interface_export) = module.export("CreateInterface") { @@ -70,7 +40,12 @@ pub fn dump_interfaces(builders: &mut Vec, process: &Process) - ); entries - .entry(module_name.replace(".", "_")) + .entry( + module_name + .replace(".", "_") + .to_case(Case::Snake) + .to_case(Case::Pascal), + ) .or_default() .push(Entry { name: name.clone(), diff --git a/src/dumpers/mod.rs b/src/dumpers/mod.rs index 086a20c..d5b4318 100644 --- a/src/dumpers/mod.rs +++ b/src/dumpers/mod.rs @@ -2,6 +2,8 @@ use std::collections::BTreeMap; use std::fs::File; use std::io::Write; +use chrono::Utc; + use crate::builder::{FileBuilder, FileBuilderEnum}; use crate::error::Result; @@ -34,29 +36,23 @@ pub fn generate_file( let mut file = File::create(file_path)?; - builder.write_top_level(&mut file)?; + write_banner_to_file(&mut file, builder.extension())?; - if builder.extension() != "json" { - write!( - file, - "/*\n * https://github.com/a2x/cs2-dumper\n * {}\n */\n\n", - chrono::Utc::now() - )?; - } + builder.write_top_level(&mut file)?; let len = entries.len(); for (i, pair) in entries.iter().enumerate() { builder.write_namespace(&mut file, pair.0)?; - for entry in pair.1 { + pair.1.iter().try_for_each(|entry| { builder.write_variable( &mut file, &entry.name, entry.value, entry.comment.as_deref(), - )?; - } + ) + })?; builder.write_closure(&mut file, i == len - 1)?; } @@ -65,12 +61,28 @@ pub fn generate_file( } pub fn generate_files( - builders: &mut Vec, + builders: &mut [FileBuilderEnum], entries: &Entries, file_name: &str, ) -> Result<()> { - for builder in builders { - generate_file(builder, &entries, file_name)?; + builders + .iter_mut() + .try_for_each(|builder| generate_file(builder, entries, file_name)) +} + +fn write_banner_to_file(file: &mut File, extension: &str) -> Result<()> { + let chrono_now = Utc::now(); + + const URL: &str = "https://github.com/a2x/cs2-dumper"; + + let banner = match extension { + "json" => None, + "py" => Some(format!("'''\n{}\n{}\n'''\n\n", URL, chrono_now)), + _ => Some(format!("/*\n * {}\n * {}\n */\n\n", URL, chrono_now)), + }; + + if let Some(banner) = banner { + write!(file, "{}", banner)?; } Ok(()) diff --git a/src/dumpers/offsets.rs b/src/dumpers/offsets.rs index 91e8860..4228d8c 100644 --- a/src/dumpers/offsets.rs +++ b/src/dumpers/offsets.rs @@ -1,5 +1,7 @@ use std::fs::File; +use convert_case::{Case, Casing}; + use crate::builder::FileBuilderEnum; use crate::config::{Config, Operation::*}; use crate::dumpers::Entry; @@ -84,72 +86,81 @@ pub fn dump_offsets(builders: &mut Vec, process: &Process) -> R for signature in config.signatures { let module = process.get_module_by_name(&signature.module)?; - if let Ok(address) = process.find_pattern(&signature.module, &signature.pattern) { - let mut address = Address::from(address); + let mut address = match process.find_pattern(&signature.module, &signature.pattern) { + Ok(a) => Address::from(a), + Err(_) => { + log::error!("Failed to find pattern for {}.", signature.name); - for operation in signature.operations { - match operation { - Add { value } => address += value, - Dereference { times, size } => { - let times = times.unwrap_or(1); - let size = size.unwrap_or(8); - - for _ in 0..times { - process.read_memory_raw( - address.0, - &mut address.0 as *mut _ as *mut _, - size, - )?; - } - } - Jmp { offset, length } => { - address = process.resolve_jmp(address.0, offset, length)?.into() - } - RipRelative { offset, length } => { - address = process.resolve_rip(address.0, offset, length)?.into() - } - Slice { start, end } => { - let mut result: usize = 0; - - process.read_memory_raw( - address.add(start).0, - &mut result as *mut _ as *mut _, - end - start, - )?; - - address = result.into(); - } - Subtract { value } => address -= value, - } + continue; } + }; - let (name, value) = if address.0 < module.base() { - log::debug!(" └─ {} @ {:#X}", signature.name, address.0); + for operation in signature.operations { + match operation { + Add { value } => address += value, + Dereference { times, size } => { + let times = times.unwrap_or(1); + let size = size.unwrap_or(8); - (signature.name, address.0) - } else { - log::debug!( - " └─ {} @ {:#X} ({} + {:#X})", - signature.name, - address, - signature.module, - address.sub(module.base()) - ); + for _ in 0..times { + process.read_memory_raw( + address.0, + &mut address.0 as *mut _ as *mut _, + size, + )?; + } + } + Jmp { offset, length } => { + address = process.resolve_jmp(address.0, offset, length)?.into() + } + RipRelative { offset, length } => { + address = process.resolve_rip(address.0, offset, length)?.into() + } + Slice { start, end } => { + let mut result: usize = 0; - (signature.name, address.sub(module.base()).0) - }; + process.read_memory_raw( + address.add(start).0, + &mut result as *mut _ as *mut _, + end - start, + )?; - entries - .entry(signature.module.replace(".", "_")) - .or_default() - .push(Entry { - name, - value, - comment: None, - }); - } else { - log::error!("Failed to find pattern for {}.", signature.name); + address = result.into(); + } + Subtract { value } => address -= value, + } } + + let (name, value) = if address.0 < module.base() { + log::debug!(" └─ {} @ {:#X}", signature.name, address.0); + + (signature.name, address.0) + } else { + log::debug!( + " └─ {} @ {:#X} ({} + {:#X})", + signature.name, + address, + signature.module, + address.sub(module.base()) + ); + + (signature.name, address.sub(module.base()).0) + }; + + entries + .entry( + signature + .module + .replace(".", "_") + .to_case(Case::Snake) + .to_case(Case::Pascal), + ) + .or_default() + .push(Entry { + name, + value, + comment: None, + }); } generate_files(builders, &entries, "offsets")?; diff --git a/src/error.rs b/src/error.rs index a436f48..49172e6 100644 --- a/src/error.rs +++ b/src/error.rs @@ -9,7 +9,7 @@ use windows::core::Error as WindowsError; #[derive(Debug, Error)] pub enum Error { - #[error("Buffer size mismatch: expected {0}, got {1}")] + #[error("Buffer size mismatch. Expected {0}, got {1}")] BufferSizeMismatch(usize, usize), #[error("Invalid magic: {0:#X}")] @@ -18,14 +18,14 @@ pub enum Error { #[error("IO error: {0}")] IOError(#[from] io::Error), - #[error("Module not found")] - ModuleNotFound, + #[error("Module not found: {0}")] + ModuleNotFound(String), - #[error("Pattern not found")] - PatternNotFound, + #[error("Pattern not found: {0}")] + PatternNotFound(String), - #[error("Process not found")] - ProcessNotFound, + #[error("Process not found: {0}")] + ProcessNotFound(String), #[error("Serde error: {0}")] SerdeError(#[from] SerdeError), diff --git a/src/main.rs b/src/main.rs index 1655dc5..b606192 100644 --- a/src/main.rs +++ b/src/main.rs @@ -67,6 +67,7 @@ fn main() -> Result<()> { FileBuilderEnum::CppFileBuilder(CppFileBuilder), FileBuilderEnum::CSharpFileBuilder(CSharpFileBuilder), FileBuilderEnum::JsonFileBuilder(JsonFileBuilder::default()), + FileBuilderEnum::PythonFileBuilder(PythonFileBuilder), FileBuilderEnum::RustFileBuilder(RustFileBuilder), ]; diff --git a/src/remote/process.rs b/src/remote/process.rs index d7df783..92e0648 100644 --- a/src/remote/process.rs +++ b/src/remote/process.rs @@ -58,7 +58,7 @@ impl Process { } } - Err(Error::PatternNotFound) + Err(Error::PatternNotFound(pattern.to_owned())) } pub fn get_loaded_modules(&self) -> Result> { @@ -108,7 +108,7 @@ impl Process { } } - Err(Error::ModuleNotFound) + Err(Error::ModuleNotFound(module_name.to_owned())) } pub fn read_memory_raw(&self, address: usize, buffer: *mut c_void, size: usize) -> Result<()> { @@ -215,7 +215,7 @@ impl Process { } } - Err(Error::ProcessNotFound) + Err(Error::ProcessNotFound(process_name.to_owned())) } fn pattern_to_bytes(pattern: &str) -> Vec { diff --git a/src/sdk/interface.rs b/src/sdk/interface.rs new file mode 100644 index 0000000..4b5ac16 --- /dev/null +++ b/src/sdk/interface.rs @@ -0,0 +1,33 @@ +use std::ffi::c_char; +use std::mem::offset_of; + +use crate::error::Result; +use crate::remote::Process; + +#[derive(Debug)] +#[repr(C)] +pub struct InterfaceReg { + pub create_fn: *const (), // 0x0000 + pub name: *const c_char, // 0x0008 + pub next: *mut InterfaceReg, // 0x0010 +} + +impl InterfaceReg { + pub fn ptr(&self, process: &Process) -> Result { + process + .read_memory::(self as *const _ as usize + offset_of!(InterfaceReg, create_fn)) + } + + pub fn name(&self, process: &Process) -> Result { + let name_ptr = process + .read_memory::(self as *const _ as usize + offset_of!(InterfaceReg, name))?; + + process.read_string(name_ptr) + } + + pub fn next(&self, process: &Process) -> Result<*mut InterfaceReg> { + process.read_memory::<*mut InterfaceReg>( + self as *const _ as usize + offset_of!(InterfaceReg, next), + ) + } +} diff --git a/src/sdk/mod.rs b/src/sdk/mod.rs index 47039f5..71817ea 100644 --- a/src/sdk/mod.rs +++ b/src/sdk/mod.rs @@ -1,3 +1,4 @@ +pub use interface::InterfaceReg; pub use schema_class_field_data::SchemaClassFieldData; pub use schema_class_info::SchemaClassInfo; pub use schema_system::SchemaSystem; @@ -6,6 +7,7 @@ pub use schema_type::SchemaType; pub use schema_type_declared_class::SchemaTypeDeclaredClass; pub use utl_ts_hash::UtlTsHash; +pub mod interface; pub mod schema_class_field_data; pub mod schema_class_info; pub mod schema_system;