mirror of
https://github.com/neverlosecc/source2sdk.git
synced 2025-04-20 05:08:14 +00:00
19185 lines
506 KiB
C++
19185 lines
506 KiB
C++
#pragma once
|
|
#include <cstdint>
|
|
#include "!GlobalTypes.hpp"
|
|
|
|
///////////////////////////////////////////
|
|
// Binary: !GlobalTypes
|
|
// Class Count: 906
|
|
// Enum Count: 168
|
|
///////////////////////////////////////////
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class ThreeState_t : uint32_t
|
|
{
|
|
TRS_FALSE = 0x0,
|
|
TRS_TRUE = 0x1,
|
|
TRS_NONE = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 1
|
|
enum class LightSourceShape_t : uint32_t
|
|
{
|
|
LIGHT_SOURCE_SHAPE_SPHERE = 0x0,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 7
|
|
enum class LightType_t : uint32_t
|
|
{
|
|
MATERIAL_LIGHT_DISABLE = 0x0,
|
|
MATERIAL_LIGHT_POINT = 0x1,
|
|
MATERIAL_LIGHT_DIRECTIONAL = 0x2,
|
|
MATERIAL_LIGHT_SPOT = 0x3,
|
|
MATERIAL_LIGHT_ORTHO = 0x4,
|
|
MATERIAL_LIGHT_ENVIRONMENT_PROBE = 0x5,
|
|
MATERIAL_LIGHT_AREA = 0x6,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class RenderSlotType_t : uint32_t
|
|
{
|
|
RENDER_SLOT_INVALID = 0xffffffffffffffff,
|
|
RENDER_SLOT_PER_VERTEX = 0x0,
|
|
RENDER_SLOT_PER_INSTANCE = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 6
|
|
enum class CubeMapFace_t : uint32_t
|
|
{
|
|
CUBEMAP_FACE_POSITIVE_X = 0x0,
|
|
CUBEMAP_FACE_NEGATIVE_X = 0x1,
|
|
CUBEMAP_FACE_POSITIVE_Y = 0x2,
|
|
CUBEMAP_FACE_NEGATIVE_Y = 0x3,
|
|
CUBEMAP_FACE_POSITIVE_Z = 0x4,
|
|
CUBEMAP_FACE_NEGATIVE_Z = 0x5,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class InputLayoutVariation_t : uint32_t
|
|
{
|
|
INPUT_LAYOUT_VARIATION_DEFAULT = 0x0,
|
|
INPUT_LAYOUT_VARIATION_STREAM1_INSTANCEID = 0x1,
|
|
INPUT_LAYOUT_VARIATION_STREAM1_INSTANCEID_MORPH_VERT_ID = 0x2,
|
|
INPUT_LAYOUT_VARIATION_STREAM1_DRAWINDIRECT_ID = 0x3,
|
|
INPUT_LAYOUT_VARIATION_MAX = 0x4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 8
|
|
enum class RenderMultisampleType_t : uint32_t
|
|
{
|
|
RENDER_MULTISAMPLE_INVALID = 0xffffffffffffffff,
|
|
RENDER_MULTISAMPLE_NONE = 0x0,
|
|
RENDER_MULTISAMPLE_2X = 0x1,
|
|
RENDER_MULTISAMPLE_4X = 0x2,
|
|
RENDER_MULTISAMPLE_6X = 0x3,
|
|
RENDER_MULTISAMPLE_8X = 0x4,
|
|
RENDER_MULTISAMPLE_16X = 0x5,
|
|
RENDER_MULTISAMPLE_TYPE_COUNT = 0x6,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 9
|
|
enum class RenderBufferFlags_t : uint32_t
|
|
{
|
|
RENDER_BUFFER_USAGE_VERTEX_BUFFER = 0x1,
|
|
RENDER_BUFFER_USAGE_INDEX_BUFFER = 0x2,
|
|
RENDER_BUFFER_USAGE_SHADER_RESOURCE = 0x4,
|
|
RENDER_BUFFER_USAGE_UNORDERED_ACCESS = 0x8,
|
|
RENDER_BUFFER_BYTEADDRESS_BUFFER = 0x10,
|
|
RENDER_BUFFER_STRUCTURED_BUFFER = 0x20,
|
|
RENDER_BUFFER_APPEND_CONSUME_BUFFER = 0x40,
|
|
RENDER_BUFFER_UAV_COUNTER = 0x80,
|
|
RENDER_BUFFER_UAV_DRAW_INDIRECT_ARGS = 0x100,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 21
|
|
enum class TextureSpecificationFlags_t : uint32_t
|
|
{
|
|
TSPEC_FLAGS = 0x0,
|
|
TSPEC_RENDER_TARGET = 0x1,
|
|
TSPEC_VERTEX_TEXTURE = 0x2,
|
|
TSPEC_UNFILTERABLE_OK = 0x4,
|
|
TSPEC_RENDER_TARGET_SAMPLEABLE = 0x8,
|
|
TSPEC_SUGGEST_CLAMPS = 0x10,
|
|
TSPEC_SUGGEST_CLAMPT = 0x20,
|
|
TSPEC_SUGGEST_CLAMPU = 0x40,
|
|
TSPEC_NO_LOD = 0x80,
|
|
TSPEC_CUBE_TEXTURE = 0x100,
|
|
TSPEC_VOLUME_TEXTURE = 0x200,
|
|
TSPEC_TEXTURE_ARRAY = 0x400,
|
|
TSPEC_TEXTURE_GEN_MIP_MAPS = 0x800,
|
|
TSPEC_LINE_TEXTURE_360 = 0x1000,
|
|
TSPEC_LINEAR_ADDRESSING_360 = 0x2000,
|
|
TSPEC_USE_TYPED_IMAGEFORMAT = 0x4000,
|
|
TSPEC_SHARED_RESOURCE = 0x8000,
|
|
TSPEC_UAV = 0x10000,
|
|
TSPEC_INPUT_ATTACHMENT = 0x20000,
|
|
TSPEC_CUBE_CAN_SAMPLE_AS_ARRAY = 0x40000,
|
|
TSPEC_LINEAR_COLOR_SPACE = 0x80000,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 45
|
|
enum class RenderPrimitiveType_t : uint32_t
|
|
{
|
|
RENDER_PRIM_POINTS = 0x0,
|
|
RENDER_PRIM_LINES = 0x1,
|
|
RENDER_PRIM_LINES_WITH_ADJACENCY = 0x2,
|
|
RENDER_PRIM_LINE_STRIP = 0x3,
|
|
RENDER_PRIM_LINE_STRIP_WITH_ADJACENCY = 0x4,
|
|
RENDER_PRIM_TRIANGLES = 0x5,
|
|
RENDER_PRIM_TRIANGLES_WITH_ADJACENCY = 0x6,
|
|
RENDER_PRIM_TRIANGLE_STRIP = 0x7,
|
|
RENDER_PRIM_TRIANGLE_STRIP_WITH_ADJACENCY = 0x8,
|
|
RENDER_PRIM_INSTANCED_QUADS = 0x9,
|
|
RENDER_PRIM_HETEROGENOUS = 0xa,
|
|
RENDER_PRIM_1_CONTROL_POINT_PATCHLIST = 0xb,
|
|
RENDER_PRIM_2_CONTROL_POINT_PATCHLIST = 0xc,
|
|
RENDER_PRIM_3_CONTROL_POINT_PATCHLIST = 0xd,
|
|
RENDER_PRIM_4_CONTROL_POINT_PATCHLIST = 0xe,
|
|
RENDER_PRIM_5_CONTROL_POINT_PATCHLIST = 0xf,
|
|
RENDER_PRIM_6_CONTROL_POINT_PATCHLIST = 0x10,
|
|
RENDER_PRIM_7_CONTROL_POINT_PATCHLIST = 0x11,
|
|
RENDER_PRIM_8_CONTROL_POINT_PATCHLIST = 0x12,
|
|
RENDER_PRIM_9_CONTROL_POINT_PATCHLIST = 0x13,
|
|
RENDER_PRIM_10_CONTROL_POINT_PATCHLIST = 0x14,
|
|
RENDER_PRIM_11_CONTROL_POINT_PATCHLIST = 0x15,
|
|
RENDER_PRIM_12_CONTROL_POINT_PATCHLIST = 0x16,
|
|
RENDER_PRIM_13_CONTROL_POINT_PATCHLIST = 0x17,
|
|
RENDER_PRIM_14_CONTROL_POINT_PATCHLIST = 0x18,
|
|
RENDER_PRIM_15_CONTROL_POINT_PATCHLIST = 0x19,
|
|
RENDER_PRIM_16_CONTROL_POINT_PATCHLIST = 0x1a,
|
|
RENDER_PRIM_17_CONTROL_POINT_PATCHLIST = 0x1b,
|
|
RENDER_PRIM_18_CONTROL_POINT_PATCHLIST = 0x1c,
|
|
RENDER_PRIM_19_CONTROL_POINT_PATCHLIST = 0x1d,
|
|
RENDER_PRIM_20_CONTROL_POINT_PATCHLIST = 0x1e,
|
|
RENDER_PRIM_21_CONTROL_POINT_PATCHLIST = 0x1f,
|
|
RENDER_PRIM_22_CONTROL_POINT_PATCHLIST = 0x20,
|
|
RENDER_PRIM_23_CONTROL_POINT_PATCHLIST = 0x21,
|
|
RENDER_PRIM_24_CONTROL_POINT_PATCHLIST = 0x22,
|
|
RENDER_PRIM_25_CONTROL_POINT_PATCHLIST = 0x23,
|
|
RENDER_PRIM_26_CONTROL_POINT_PATCHLIST = 0x24,
|
|
RENDER_PRIM_27_CONTROL_POINT_PATCHLIST = 0x25,
|
|
RENDER_PRIM_28_CONTROL_POINT_PATCHLIST = 0x26,
|
|
RENDER_PRIM_29_CONTROL_POINT_PATCHLIST = 0x27,
|
|
RENDER_PRIM_30_CONTROL_POINT_PATCHLIST = 0x28,
|
|
RENDER_PRIM_31_CONTROL_POINT_PATCHLIST = 0x29,
|
|
RENDER_PRIM_32_CONTROL_POINT_PATCHLIST = 0x2a,
|
|
RENDER_PRIM_COMPUTE_SHADER = 0x2b,
|
|
RENDER_PRIM_TYPE_COUNT = 0x2c,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 9
|
|
enum class EntityIOTargetType_t : uint32_t
|
|
{
|
|
ENTITY_IO_TARGET_INVALID = 0xffffffffffffffff,
|
|
ENTITY_IO_TARGET_CLASSNAME = 0x0,
|
|
ENTITY_IO_TARGET_CLASSNAME_DERIVES_FROM = 0x1,
|
|
ENTITY_IO_TARGET_ENTITYNAME = 0x2,
|
|
ENTITY_IO_TARGET_CONTAINS_COMPONENT = 0x3,
|
|
ENTITY_IO_TARGET_SPECIAL_ACTIVATOR = 0x4,
|
|
ENTITY_IO_TARGET_SPECIAL_CALLER = 0x5,
|
|
ENTITY_IO_TARGET_EHANDLE = 0x6,
|
|
ENTITY_IO_TARGET_ENTITYNAME_OR_CLASSNAME = 0x7,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class EntityDormancyType_t : uint32_t
|
|
{
|
|
ENTITY_NOT_DORMANT = 0x0,
|
|
ENTITY_DORMANT = 0x1,
|
|
ENTITY_SUSPENDED = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class HorizJustification_e : uint32_t
|
|
{
|
|
HORIZ_JUSTIFICATION_LEFT = 0x0,
|
|
HORIZ_JUSTIFICATION_CENTER = 0x1,
|
|
HORIZ_JUSTIFICATION_RIGHT = 0x2,
|
|
HORIZ_JUSTIFICATION_NONE = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class BloomBlendMode_t : uint32_t
|
|
{
|
|
BLOOM_BLEND_ADD = 0x0,
|
|
BLOOM_BLEND_SCREEN = 0x1,
|
|
BLOOM_BLEND_BLUR = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class ViewFadeMode_t : uint32_t
|
|
{
|
|
VIEW_FADE_CONSTANT_COLOR = 0x0,
|
|
VIEW_FADE_MODULATE = 0x1,
|
|
VIEW_FADE_MOD2X = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class LayoutPositionType_e : uint32_t
|
|
{
|
|
LAYOUTPOSITIONTYPE_VIEWPORT_RELATIVE = 0x0,
|
|
LAYOUTPOSITIONTYPE_FRACTIONAL = 0x1,
|
|
LAYOUTPOSITIONTYPE_NONE = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class VertJustification_e : uint32_t
|
|
{
|
|
VERT_JUSTIFICATION_TOP = 0x0,
|
|
VERT_JUSTIFICATION_CENTER = 0x1,
|
|
VERT_JUSTIFICATION_BOTTOM = 0x2,
|
|
VERT_JUSTIFICATION_NONE = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class BinaryNodeChildOption : uint32_t
|
|
{
|
|
Child1 = 0x0,
|
|
Child2 = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class BoneMaskBlendSpace : uint32_t
|
|
{
|
|
BlendSpace_Parent = 0x0,
|
|
BlendSpace_Model = 0x1,
|
|
BlendSpace_Model_RotationOnly = 0x2,
|
|
BlendSpace_Model_TranslationOnly = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class SelectionSource_t : uint32_t
|
|
{
|
|
SelectionSource_Bool = 0x0,
|
|
SelectionSource_Enum = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class IkTargetType : uint32_t
|
|
{
|
|
IkTarget_Attachment = 0x0,
|
|
IkTarget_Bone = 0x1,
|
|
IkTarget_Parameter_ModelSpace = 0x2,
|
|
IkTarget_Parameter_WorldSpace = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 13
|
|
enum class AnimVectorSource : uint32_t
|
|
{
|
|
MoveDirection = 0x0,
|
|
FacingDirection = 0x1,
|
|
LookDirection = 0x2,
|
|
VectorParameter = 0x3,
|
|
WayPointDirection = 0x4,
|
|
Acceleration = 0x5,
|
|
SlopeNormal = 0x6,
|
|
SlopeNormal_WorldSpace = 0x7,
|
|
LookTarget = 0x8,
|
|
LookTarget_WorldSpace = 0x9,
|
|
WayPointPosition = 0xa,
|
|
GoalPosition = 0xb,
|
|
RootMotionVelocity = 0xc,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class ChoiceMethod : uint32_t
|
|
{
|
|
WeightedRandom = 0x0,
|
|
WeightedRandomNoRepeat = 0x1,
|
|
Iterate = 0x2,
|
|
IterateRandom = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 8
|
|
enum class FootFallTagFoot_t : uint32_t
|
|
{
|
|
FOOT1 = 0x0,
|
|
FOOT2 = 0x1,
|
|
FOOT3 = 0x2,
|
|
FOOT4 = 0x3,
|
|
FOOT5 = 0x4,
|
|
FOOT6 = 0x5,
|
|
FOOT7 = 0x6,
|
|
FOOT8 = 0x7,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 7
|
|
enum class AnimationSnapshotType_t : uint32_t
|
|
{
|
|
ANIMATION_SNAPSHOT_SERVER_SIMULATION = 0x0,
|
|
ANIMATION_SNAPSHOT_CLIENT_SIMULATION = 0x1,
|
|
ANIMATION_SNAPSHOT_CLIENT_PREDICTION = 0x2,
|
|
ANIMATION_SNAPSHOT_CLIENT_INTERPOLATION = 0x3,
|
|
ANIMATION_SNAPSHOT_CLIENT_RENDER = 0x4,
|
|
ANIMATION_SNAPSHOT_FINAL_COMPOSITE = 0x5,
|
|
ANIMATION_SNAPSHOT_MAX = 0x6,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class AimMatrixBlendMode : uint32_t
|
|
{
|
|
AimMatrixBlendMode_Additive = 0x0,
|
|
AimMatrixBlendMode_BoneMask = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class FacingMode : uint32_t
|
|
{
|
|
FacingMode_Manual = 0x0,
|
|
FacingMode_Path = 0x1,
|
|
FacingMode_LookTarget = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class AnimVRHandMotionRange_t : uint32_t
|
|
{
|
|
MotionRange_WithController = 0x0,
|
|
MotionRange_WithoutController = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class SolveIKChainAnimNodeSettingSource : uint32_t
|
|
{
|
|
SOLVEIKCHAINANIMNODESETTINGSOURCE_Default = 0x0,
|
|
SOLVEIKCHAINANIMNODESETTINGSOURCE_Override = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class SelectorTagBehavior_t : uint32_t
|
|
{
|
|
SelectorTagBehavior_OnWhileCurrent = 0x0,
|
|
SelectorTagBehavior_OffWhenFinished = 0x1,
|
|
SelectorTagBehavior_OffBeforeFinished = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 13
|
|
enum class AnimParamButton_t : uint32_t
|
|
{
|
|
ANIMPARAM_BUTTON_NONE = 0x0,
|
|
ANIMPARAM_BUTTON_DPAD_UP = 0x1,
|
|
ANIMPARAM_BUTTON_DPAD_RIGHT = 0x2,
|
|
ANIMPARAM_BUTTON_DPAD_DOWN = 0x3,
|
|
ANIMPARAM_BUTTON_DPAD_LEFT = 0x4,
|
|
ANIMPARAM_BUTTON_A = 0x5,
|
|
ANIMPARAM_BUTTON_B = 0x6,
|
|
ANIMPARAM_BUTTON_X = 0x7,
|
|
ANIMPARAM_BUTTON_Y = 0x8,
|
|
ANIMPARAM_BUTTON_LEFT_SHOULDER = 0x9,
|
|
ANIMPARAM_BUTTON_RIGHT_SHOULDER = 0xa,
|
|
ANIMPARAM_BUTTON_LTRIGGER = 0xb,
|
|
ANIMPARAM_BUTTON_RTRIGGER = 0xc,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class SeqPoseSetting_t : uint32_t
|
|
{
|
|
SEQ_POSE_SETTING_CONSTANT = 0x0,
|
|
SEQ_POSE_SETTING_ROTATION = 0x1,
|
|
SEQ_POSE_SETTING_POSITION = 0x2,
|
|
SEQ_POSE_SETTING_VELOCITY = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class IkEndEffectorType : uint32_t
|
|
{
|
|
IkEndEffector_Attachment = 0x0,
|
|
IkEndEffector_Bone = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class JiggleBoneSimSpace : uint32_t
|
|
{
|
|
SimSpace_Local = 0x0,
|
|
SimSpace_Model = 0x1,
|
|
SimSpace_World = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 6
|
|
enum class AnimationProcessingType_t : uint32_t
|
|
{
|
|
ANIMATION_PROCESSING_SERVER_SIMULATION = 0x0,
|
|
ANIMATION_PROCESSING_CLIENT_SIMULATION = 0x1,
|
|
ANIMATION_PROCESSING_CLIENT_PREDICTION = 0x2,
|
|
ANIMATION_PROCESSING_CLIENT_INTERPOLATION = 0x3,
|
|
ANIMATION_PROCESSING_CLIENT_RENDER = 0x4,
|
|
ANIMATION_PROCESSING_MAX = 0x5,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class DampingSpeedFunction : uint32_t
|
|
{
|
|
NoDamping = 0x0,
|
|
Constant = 0x1,
|
|
Spring = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class FootLockSubVisualization : uint32_t
|
|
{
|
|
FOOTLOCKSUBVISUALIZATION_ReachabilityAnalysis = 0x0,
|
|
FOOTLOCKSUBVISUALIZATION_IKSolve = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class FootstepLandedFootSoundType_t : uint32_t
|
|
{
|
|
FOOTSOUND_Left = 0x0,
|
|
FOOTSOUND_Right = 0x1,
|
|
FOOTSOUND_UseOverrideSound = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class AnimVrFingerSplay_t : uint32_t
|
|
{
|
|
AnimVrFingerSplay_Thumb_Index = 0x0,
|
|
AnimVrFingerSplay_Index_Middle = 0x1,
|
|
AnimVrFingerSplay_Middle_Ring = 0x2,
|
|
AnimVrFingerSplay_Ring_Pinky = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class AnimVrBoneTransformSource_t : uint32_t
|
|
{
|
|
AnimVrBoneTransformSource_LiveStream = 0x0,
|
|
AnimVrBoneTransformSource_GripLimit = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class ResetCycleOption : uint32_t
|
|
{
|
|
Beginning = 0x0,
|
|
SameCycleAsSource = 0x1,
|
|
InverseSourceCycle = 0x2,
|
|
FixedValue = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class BlendKeyType : uint32_t
|
|
{
|
|
BlendKey_UserValue = 0x0,
|
|
BlendKey_Velocity = 0x1,
|
|
BlendKey_Distance = 0x2,
|
|
BlendKey_RemainingDistance = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class MotionSamplingMethod : uint32_t
|
|
{
|
|
Uniform = 0x0,
|
|
AtFootCycleStart = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class ChoiceBlendMethod : uint32_t
|
|
{
|
|
SingleBlendTime = 0x0,
|
|
PerChoiceBlendTimes = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class ChoiceChangeMethod : uint32_t
|
|
{
|
|
OnReset = 0x0,
|
|
OnCycleEnd = 0x1,
|
|
OnResetOrCycleEnd = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class Blend2DMode : uint32_t
|
|
{
|
|
Blend2DMode_General = 0x0,
|
|
Blend2DMode_Directional = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 6
|
|
enum class IKSolverType : uint32_t
|
|
{
|
|
IKSOLVER_Perlin = 0x0,
|
|
IKSOLVER_TwoBone = 0x1,
|
|
IKSOLVER_Fabrik = 0x2,
|
|
IKSOLVER_DogLeg3Bone = 0x3,
|
|
IKSOLVER_CCD = 0x4,
|
|
IKSOLVER_COUNT = 0x5,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 36
|
|
enum class AnimValueSource : uint32_t
|
|
{
|
|
MoveHeading = 0x0,
|
|
MoveSpeed = 0x1,
|
|
ForwardSpeed = 0x2,
|
|
StrafeSpeed = 0x3,
|
|
FacingHeading = 0x4,
|
|
ManualFacingHeading = 0x5,
|
|
LookHeading = 0x6,
|
|
LookPitch = 0x7,
|
|
Parameter = 0x8,
|
|
WayPointHeading = 0x9,
|
|
WayPointDistance = 0xa,
|
|
BoundaryRadius = 0xb,
|
|
TargetMoveHeading = 0xc,
|
|
TargetMoveSpeed = 0xd,
|
|
AccelerationHeading = 0xe,
|
|
AccelerationSpeed = 0xf,
|
|
SlopeHeading = 0x10,
|
|
SlopeAngle = 0x11,
|
|
SlopePitch = 0x12,
|
|
SlopeYaw = 0x13,
|
|
GoalDistance = 0x14,
|
|
AccelerationLeftRight = 0x15,
|
|
AccelerationFrontBack = 0x16,
|
|
RootMotionSpeed = 0x17,
|
|
RootMotionTurnSpeed = 0x18,
|
|
MoveHeadingRelativeToLookHeading = 0x19,
|
|
MaxMoveSpeed = 0x1a,
|
|
FingerCurl_Thumb = 0x1b,
|
|
FingerCurl_Index = 0x1c,
|
|
FingerCurl_Middle = 0x1d,
|
|
FingerCurl_Ring = 0x1e,
|
|
FingerCurl_Pinky = 0x1f,
|
|
FingerSplay_Thumb_Index = 0x20,
|
|
FingerSplay_Index_Middle = 0x21,
|
|
FingerSplay_Middle_Ring = 0x22,
|
|
FingerSplay_Ring_Pinky = 0x23,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class FinishedConditionOption : uint32_t
|
|
{
|
|
FinishedConditionOption_OnFinished = 0x0,
|
|
FinishedConditionOption_OnAlmostFinished = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 40
|
|
enum class ControlValue : uint32_t
|
|
{
|
|
ControlValue_MoveHeading = 0x0,
|
|
ControlValue_MoveSpeed = 0x1,
|
|
ControlValue_FacingHeading = 0x2,
|
|
ControlValue_LookHeading = 0x3,
|
|
ControlValue_LookPitch = 0x4,
|
|
ControlValue_WayPointHeading = 0x5,
|
|
ControlValue_WayPointDistance = 0x6,
|
|
ControlValue_BoundaryRadius = 0x7,
|
|
ControlValue_TotalTranslation_SourceState = 0x8,
|
|
ControlValue_TotalTranslation_TargetState = 0x9,
|
|
ControlValue_RemainingTranslation_SourceState = 0xa,
|
|
ControlValue_RemainingTranslation_TargetState = 0xb,
|
|
ControlValue_MoveVsFacingDelta = 0xc,
|
|
ControlValue_SourceStateBlendWeight = 0xd,
|
|
ControlValue_TargetStateBlendWeight = 0xe,
|
|
ControlValue_TargetMoveHeading = 0xf,
|
|
ControlValue_TargetMoveSpeed = 0x10,
|
|
ControlValue_AccelerationHeading = 0x11,
|
|
ControlValue_AccelerationSpeed = 0x12,
|
|
ControlValue_SlopeHeading = 0x13,
|
|
ControlValue_SlopeAngle = 0x14,
|
|
ControlValue_SlopeYaw = 0x15,
|
|
ControlValue_SlopePitch = 0x16,
|
|
ControlValue_GoalDistance = 0x17,
|
|
ControlValue_AccelerationLeftRight = 0x18,
|
|
ControlValue_AccelerationFrontBack = 0x19,
|
|
ControlValue_RootMotionSpeed = 0x1a,
|
|
ControlValue_RootMotionTurnSpeed = 0x1b,
|
|
ControlValue_MoveHeadingRelativeToLookHeading = 0x1c,
|
|
ControlValue_FingerCurl_Thumb = 0x1d,
|
|
ControlValue_FingerCurl_Index = 0x1e,
|
|
ControlValue_FingerCurl_Middle = 0x1f,
|
|
ControlValue_FingerCurl_Ring = 0x20,
|
|
ControlValue_FingerCurl_Pinky = 0x21,
|
|
ControlValue_FingerSplay_Thumb_Index = 0x22,
|
|
ControlValue_FingerSplay_Index_Middle = 0x23,
|
|
ControlValue_FingerSplay_Middle_Ring = 0x24,
|
|
ControlValue_FingerSplay_Ring_Pinky = 0x25,
|
|
ControlValue_Count = 0x26,
|
|
ControlValue_Invalid = 0xff,
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 69
|
|
enum class fieldtype_t : uint8_t
|
|
{
|
|
FIELD_VOID = 0,
|
|
FIELD_FLOAT32 = 1,
|
|
FIELD_STRING = 2,
|
|
FIELD_VECTOR = 3,
|
|
FIELD_QUATERNION = 4,
|
|
FIELD_INT32 = 5,
|
|
FIELD_BOOLEAN = 6,
|
|
FIELD_INT16 = 7,
|
|
FIELD_CHARACTER = 8,
|
|
FIELD_COLOR32 = 9,
|
|
FIELD_EMBEDDED = 10,
|
|
FIELD_CUSTOM = 11,
|
|
FIELD_CLASSPTR = 12,
|
|
FIELD_EHANDLE = 13,
|
|
FIELD_POSITION_VECTOR = 14,
|
|
FIELD_TIME = 15,
|
|
FIELD_TICK = 16,
|
|
FIELD_SOUNDNAME = 17,
|
|
FIELD_INPUT = 18,
|
|
FIELD_FUNCTION = 19,
|
|
FIELD_VMATRIX = 20,
|
|
FIELD_VMATRIX_WORLDSPACE = 21,
|
|
FIELD_MATRIX3X4_WORLDSPACE = 22,
|
|
FIELD_INTERVAL = 23,
|
|
FIELD_UNUSED = 24,
|
|
FIELD_VECTOR2D = 25,
|
|
FIELD_INT64 = 26,
|
|
FIELD_VECTOR4D = 27,
|
|
FIELD_RESOURCE = 28,
|
|
FIELD_TYPEUNKNOWN = 29,
|
|
FIELD_CSTRING = 30,
|
|
FIELD_HSCRIPT = 31,
|
|
FIELD_VARIANT = 32,
|
|
FIELD_UINT64 = 33,
|
|
FIELD_FLOAT64 = 34,
|
|
FIELD_POSITIVEINTEGER_OR_NULL = 35,
|
|
FIELD_HSCRIPT_NEW_INSTANCE = 36,
|
|
FIELD_UINT32 = 37,
|
|
FIELD_UTLSTRINGTOKEN = 38,
|
|
FIELD_QANGLE = 39,
|
|
FIELD_NETWORK_ORIGIN_CELL_QUANTIZED_VECTOR = 40,
|
|
FIELD_HMATERIAL = 41,
|
|
FIELD_HMODEL = 42,
|
|
FIELD_HANIMATIONGRAPH = 43,
|
|
FIELD_NETWORK_QUANTIZED_VECTOR = 44,
|
|
FIELD_NETWORK_QUANTIZED_FLOAT = 45,
|
|
FIELD_DIRECTION_VECTOR_WORLDSPACE = 46,
|
|
FIELD_QANGLE_WORLDSPACE = 47,
|
|
FIELD_QUATERNION_WORLDSPACE = 48,
|
|
FIELD_HSCRIPT_LIGHTBINDING = 49,
|
|
FIELD_V8_VALUE = 50,
|
|
FIELD_V8_OBJECT = 51,
|
|
FIELD_V8_ARRAY = 52,
|
|
FIELD_V8_CALLBACK_INFO = 53,
|
|
FIELD_UTLSTRING = 54,
|
|
FIELD_NETWORK_ORIGIN_CELL_QUANTIZED_POSITION_VECTOR = 55,
|
|
FIELD_HRENDERTEXTURE = 56,
|
|
FIELD_HPARTICLESYSTEMDEFINITION = 57,
|
|
FIELD_UINT8 = 58,
|
|
FIELD_UINT16 = 59,
|
|
FIELD_CTRANSFORM = 60,
|
|
FIELD_CTRANSFORM_WORLDSPACE = 61,
|
|
FIELD_HPOSTPROCESSING = 62,
|
|
FIELD_MATRIX3X4 = 63,
|
|
FIELD_SHIM = 64,
|
|
FIELD_CMOTIONTRANSFORM = 65,
|
|
FIELD_CMOTIONTRANSFORM_WORLDSPACE = 66,
|
|
FIELD_ATTACHMENT_HANDLE = 67,
|
|
FIELD_TYPECOUNT = 68,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class IKTargetSource : uint32_t
|
|
{
|
|
IKTARGETSOURCE_Bone = 0x0,
|
|
IKTARGETSOURCE_AnimgraphParameter = 0x1,
|
|
IKTARGETSOURCE_COUNT = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 24
|
|
enum class CGroundIKSolveAnimNode::DebugSkeletonBoneType_t : uint32_t
|
|
{
|
|
CGroundIKSolveAnimNode::FLAG_NO_BONE_FLAGS = 0x0,
|
|
CGroundIKSolveAnimNode::FLAG_BONEFLEXDRIVER = 0x4,
|
|
CGroundIKSolveAnimNode::FLAG_CLOTH = 0x8,
|
|
CGroundIKSolveAnimNode::FLAG_PHYSICS = 0x10,
|
|
CGroundIKSolveAnimNode::FLAG_ATTACHMENT = 0x20,
|
|
CGroundIKSolveAnimNode::FLAG_ANIMATION = 0x40,
|
|
CGroundIKSolveAnimNode::FLAG_MESH = 0x80,
|
|
CGroundIKSolveAnimNode::FLAG_HITBOX = 0x100,
|
|
CGroundIKSolveAnimNode::FLAG_RETARGET_SRC = 0x200,
|
|
CGroundIKSolveAnimNode::FLAG_BONE_USED_BY_VERTEX_LOD0 = 0x400,
|
|
CGroundIKSolveAnimNode::FLAG_BONE_USED_BY_VERTEX_LOD1 = 0x800,
|
|
CGroundIKSolveAnimNode::FLAG_BONE_USED_BY_VERTEX_LOD2 = 0x1000,
|
|
CGroundIKSolveAnimNode::FLAG_BONE_USED_BY_VERTEX_LOD3 = 0x2000,
|
|
CGroundIKSolveAnimNode::FLAG_BONE_USED_BY_VERTEX_LOD4 = 0x4000,
|
|
CGroundIKSolveAnimNode::FLAG_BONE_USED_BY_VERTEX_LOD5 = 0x8000,
|
|
CGroundIKSolveAnimNode::FLAG_BONE_USED_BY_VERTEX_LOD6 = 0x10000,
|
|
CGroundIKSolveAnimNode::FLAG_BONE_USED_BY_VERTEX_LOD7 = 0x20000,
|
|
CGroundIKSolveAnimNode::FLAG_BONE_MERGE_READ = 0x40000,
|
|
CGroundIKSolveAnimNode::FLAG_BONE_MERGE_WRITE = 0x80000,
|
|
CGroundIKSolveAnimNode::BLEND_PREALIGNED = 0x100000,
|
|
CGroundIKSolveAnimNode::FLAG_RIGIDLENGTH = 0x200000,
|
|
CGroundIKSolveAnimNode::FLAG_PROCEDURAL = 0x400000,
|
|
CGroundIKSolveAnimNode::FLAG_IK = 0x800000,
|
|
CGroundIKSolveAnimNode::FLAG_ALL_BONE_FLAGS = 0xffffff,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class AnimNodeNetworkMode : uint32_t
|
|
{
|
|
ServerAuthoritative = 0x0,
|
|
ClientSimulate = 0x1,
|
|
ClientPredicted = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class StepPhase : uint32_t
|
|
{
|
|
StepPhase_OnGround = 0x0,
|
|
StepPhase_InAir = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class AnimPoseControl : uint32_t
|
|
{
|
|
NoPoseControl = 0x0,
|
|
AbsolutePoseControl = 0x1,
|
|
RelativePoseControl = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class GroundIKTiltSource_t : uint32_t
|
|
{
|
|
TILT_None = 0x0,
|
|
TILT_IK = 0x1,
|
|
TILT_MovementManagerSlope = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class IKTargetCoordinateSystem : uint32_t
|
|
{
|
|
IKTARGETCOORDINATESYSTEM_WorldSpace = 0x0,
|
|
IKTARGETCOORDINATESYSTEM_ModelSpace = 0x1,
|
|
IKTARGETCOORDINATESYSTEM_COUNT = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 7
|
|
enum class SolveIKChainAnimNodeDebugSetting : uint32_t
|
|
{
|
|
SOLVEIKCHAINANIMNODEDEBUGSETTING_None = 0x0,
|
|
SOLVEIKCHAINANIMNODEDEBUGSETTING_X_Axis_Circle = 0x1,
|
|
SOLVEIKCHAINANIMNODEDEBUGSETTING_Y_Axis_Circle = 0x2,
|
|
SOLVEIKCHAINANIMNODEDEBUGSETTING_Z_Axis_Circle = 0x3,
|
|
SOLVEIKCHAINANIMNODEDEBUGSETTING_Forward = 0x4,
|
|
SOLVEIKCHAINANIMNODEDEBUGSETTING_Up = 0x5,
|
|
SOLVEIKCHAINANIMNODEDEBUGSETTING_Left = 0x6,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class PathStatusOptions : uint32_t
|
|
{
|
|
PathStatus_HasPath = 0x0,
|
|
PathStatus_WaypointIsGoal = 0x1,
|
|
PathStatus_GoalHasChanged = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class BinaryNodeTiming : uint32_t
|
|
{
|
|
UseChild1 = 0x0,
|
|
UseChild2 = 0x1,
|
|
SyncChildren = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class CAnimationGraphVisualizerPrimitiveType : uint32_t
|
|
{
|
|
ANIMATIONGRAPHVISUALIZERPRIMITIVETYPE_Text = 0x0,
|
|
ANIMATIONGRAPHVISUALIZERPRIMITIVETYPE_Sphere = 0x1,
|
|
ANIMATIONGRAPHVISUALIZERPRIMITIVETYPE_Line = 0x2,
|
|
ANIMATIONGRAPHVISUALIZERPRIMITIVETYPE_Pie = 0x3,
|
|
ANIMATIONGRAPHVISUALIZERPRIMITIVETYPE_Axis = 0x4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class BoneTransformSpace_t : uint32_t
|
|
{
|
|
BoneTransformSpace_Invalid = 0xffffffffffffffff,
|
|
BoneTransformSpace_Parent = 0x0,
|
|
BoneTransformSpace_Model = 0x1,
|
|
BoneTransformSpace_World = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 17
|
|
enum class SeqCmd_t : uint32_t
|
|
{
|
|
SeqCmd_Nop = 0x0,
|
|
SeqCmd_LinearDelta = 0x1,
|
|
SeqCmd_FetchFrameRange = 0x2,
|
|
SeqCmd_Slerp = 0x3,
|
|
SeqCmd_Add = 0x4,
|
|
SeqCmd_Subtract = 0x5,
|
|
SeqCmd_Scale = 0x6,
|
|
SeqCmd_Copy = 0x7,
|
|
SeqCmd_Blend = 0x8,
|
|
SeqCmd_Worldspace = 0x9,
|
|
SeqCmd_Sequence = 0xa,
|
|
SeqCmd_FetchCycle = 0xb,
|
|
SeqCmd_FetchFrame = 0xc,
|
|
SeqCmd_IKLockInPlace = 0xd,
|
|
SeqCmd_IKRestoreAll = 0xe,
|
|
SeqCmd_ReverseSequence = 0xf,
|
|
SeqCmd_Transform = 0x10,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class VPhysXJoint_t::Flags_t : uint32_t
|
|
{
|
|
VPhysXJoint_t::JOINT_FLAGS_NONE = 0x0,
|
|
VPhysXJoint_t::JOINT_FLAGS_BODY1_FIXED = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class MeshTranslucencyType_t : uint32_t
|
|
{
|
|
MESH_TRANSLUCENCY_FULLY_OPAQUE = 0x0,
|
|
MESH_TRANSLUCENCY_PARTIALLY_ALPHA_BLENDED = 0x1,
|
|
MESH_TRANSLUCENCY_FULLY_ALPHA_BLENDED = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class MorphLookupType_t : uint32_t
|
|
{
|
|
LOOKUP_TYPE_TEXCOORD = 0x0,
|
|
LOOKUP_TYPE_VERTEX_ID = 0x1,
|
|
LOOKUP_TYPE_COUNT = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class MorphBundleType_t : uint32_t
|
|
{
|
|
MORPH_BUNDLE_TYPE_NONE = 0x0,
|
|
MORPH_BUNDLE_TYPE_POSITION_SPEED = 0x1,
|
|
MORPH_BUNDLE_TYPE_NORMAL_WRINKLE = 0x2,
|
|
MORPH_BUNDLE_TYPE_COUNT = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 23
|
|
enum class ModelSkeletonData_t::BoneFlags_t : uint32_t
|
|
{
|
|
ModelSkeletonData_t::FLAG_NO_BONE_FLAGS = 0x0,
|
|
ModelSkeletonData_t::FLAG_BONEFLEXDRIVER = 0x4,
|
|
ModelSkeletonData_t::FLAG_CLOTH = 0x8,
|
|
ModelSkeletonData_t::FLAG_PHYSICS = 0x10,
|
|
ModelSkeletonData_t::FLAG_ATTACHMENT = 0x20,
|
|
ModelSkeletonData_t::FLAG_ANIMATION = 0x40,
|
|
ModelSkeletonData_t::FLAG_MESH = 0x80,
|
|
ModelSkeletonData_t::FLAG_HITBOX = 0x100,
|
|
ModelSkeletonData_t::FLAG_RETARGET_SRC = 0x200,
|
|
ModelSkeletonData_t::FLAG_BONE_USED_BY_VERTEX_LOD0 = 0x400,
|
|
ModelSkeletonData_t::FLAG_BONE_USED_BY_VERTEX_LOD1 = 0x800,
|
|
ModelSkeletonData_t::FLAG_BONE_USED_BY_VERTEX_LOD2 = 0x1000,
|
|
ModelSkeletonData_t::FLAG_BONE_USED_BY_VERTEX_LOD3 = 0x2000,
|
|
ModelSkeletonData_t::FLAG_BONE_USED_BY_VERTEX_LOD4 = 0x4000,
|
|
ModelSkeletonData_t::FLAG_BONE_USED_BY_VERTEX_LOD5 = 0x8000,
|
|
ModelSkeletonData_t::FLAG_BONE_USED_BY_VERTEX_LOD6 = 0x10000,
|
|
ModelSkeletonData_t::FLAG_BONE_USED_BY_VERTEX_LOD7 = 0x20000,
|
|
ModelSkeletonData_t::FLAG_BONE_MERGE_READ = 0x40000,
|
|
ModelSkeletonData_t::FLAG_BONE_MERGE_WRITE = 0x80000,
|
|
ModelSkeletonData_t::FLAG_ALL_BONE_FLAGS = 0xfffff,
|
|
ModelSkeletonData_t::BLEND_PREALIGNED = 0x100000,
|
|
ModelSkeletonData_t::FLAG_RIGIDLENGTH = 0x200000,
|
|
ModelSkeletonData_t::FLAG_PROCEDURAL = 0x400000,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class VPhysXConstraintParams_t::EnumFlags0_t : uint32_t
|
|
{
|
|
VPhysXConstraintParams_t::FLAG0_SHIFT_INTERPENETRATE = 0x0,
|
|
VPhysXConstraintParams_t::FLAG0_SHIFT_CONSTRAIN = 0x1,
|
|
VPhysXConstraintParams_t::FLAG0_SHIFT_BREAKABLE_FORCE = 0x2,
|
|
VPhysXConstraintParams_t::FLAG0_SHIFT_BREAKABLE_TORQUE = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class AnimVRHand_t : uint32_t
|
|
{
|
|
AnimVRHand_Left = 0x0,
|
|
AnimVRHand_Right = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class JointAxis_t : uint32_t
|
|
{
|
|
JOINT_AXIS_X = 0x0,
|
|
JOINT_AXIS_Y = 0x1,
|
|
JOINT_AXIS_Z = 0x2,
|
|
JOINT_AXIS_COUNT = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class ModelBoneFlexComponent_t : uint32_t
|
|
{
|
|
MODEL_BONE_FLEX_INVALID = 0xffffffffffffffff,
|
|
MODEL_BONE_FLEX_TX = 0x0,
|
|
MODEL_BONE_FLEX_TY = 0x1,
|
|
MODEL_BONE_FLEX_TZ = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 8
|
|
enum class MeshDrawPrimitiveFlags_t : uint32_t
|
|
{
|
|
MESH_DRAW_FLAGS_NONE = 0x0,
|
|
MESH_DRAW_FLAGS_USE_SHADOW_FAST_PATH = 0x1,
|
|
MESH_DRAW_FLAGS_USE_COMPRESSED_NORMAL_TANGENT = 0x2,
|
|
MESH_DRAW_INPUT_LAYOUT_IS_NOT_MATCHED_TO_MATERIAL = 0x8,
|
|
MESH_DRAW_FLAGS_USE_COMPRESSED_PER_VERTEX_LIGHTING = 0x10,
|
|
MESH_DRAW_FLAGS_USE_UNCOMPRESSED_PER_VERTEX_LIGHTING = 0x20,
|
|
MESH_DRAW_FLAGS_CAN_BATCH_WITH_DYNAMIC_SHADER_CONSTANTS = 0x40,
|
|
MESH_DRAW_FLAGS_DRAW_LAST = 0x80,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class MorphFlexControllerRemapType_t : uint32_t
|
|
{
|
|
MORPH_FLEXCONTROLLER_REMAP_PASSTHRU = 0x0,
|
|
MORPH_FLEXCONTROLLER_REMAP_2WAY = 0x1,
|
|
MORPH_FLEXCONTROLLER_REMAP_NWAY = 0x2,
|
|
MORPH_FLEXCONTROLLER_REMAP_EYELID = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class MorphEncodingType_t : uint32_t
|
|
{
|
|
ENCODING_TYPE_OBJECT_SPACE = 0x0,
|
|
ENCODING_TYPE_TANGENT_SPACE = 0x1,
|
|
ENCODING_TYPE_COUNT = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 15
|
|
enum class PermModelInfo_t::FlagEnum : uint32_t
|
|
{
|
|
PermModelInfo_t::FLAG_TRANSLUCENT = 0x1,
|
|
PermModelInfo_t::FLAG_TRANSLUCENT_TWO_PASS = 0x2,
|
|
PermModelInfo_t::FLAG_MODEL_IS_RUNTIME_COMBINED = 0x4,
|
|
PermModelInfo_t::FLAG_SOURCE1_IMPORT = 0x8,
|
|
PermModelInfo_t::FLAG_MODEL_PART_CHILD = 0x10,
|
|
PermModelInfo_t::FLAG_NAV_GEN_NONE = 0x20,
|
|
PermModelInfo_t::FLAG_NAV_GEN_HULL = 0x40,
|
|
PermModelInfo_t::FLAG_NO_FORCED_FADE = 0x800,
|
|
PermModelInfo_t::FLAG_HAS_SKINNED_MESHES = 0x400,
|
|
PermModelInfo_t::FLAG_DO_NOT_CAST_SHADOWS = 0x20000,
|
|
PermModelInfo_t::FLAG_FORCE_PHONEME_CROSSFADE = 0x1000,
|
|
PermModelInfo_t::FLAG_NO_ANIM_EVENTS = 0x100000,
|
|
PermModelInfo_t::FLAG_ANIMATION_DRIVEN_FLEXES = 0x200000,
|
|
PermModelInfo_t::FLAG_IMPLICIT_BIND_POSE_SEQUENCE = 0x400000,
|
|
PermModelInfo_t::FLAG_MODEL_DOC = 0x800000,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class VPhysXBodyPart_t::VPhysXFlagEnum_t : uint32_t
|
|
{
|
|
VPhysXBodyPart_t::FLAG_STATIC = 0x1,
|
|
VPhysXBodyPart_t::FLAG_KINEMATIC = 0x2,
|
|
VPhysXBodyPart_t::FLAG_JOINT = 0x4,
|
|
VPhysXBodyPart_t::FLAG_MASS = 0x8,
|
|
VPhysXBodyPart_t::FLAG_ALWAYS_DYNAMIC_ON_CLIENT = 0x10,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class JointMotion_t : uint32_t
|
|
{
|
|
JOINT_MOTION_FREE = 0x0,
|
|
JOINT_MOTION_LOCKED = 0x1,
|
|
JOINT_MOTION_COUNT = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 26
|
|
enum class FlexOpCode_t : uint32_t
|
|
{
|
|
FLEX_OP_CONST = 0x1,
|
|
FLEX_OP_FETCH1 = 0x2,
|
|
FLEX_OP_FETCH2 = 0x3,
|
|
FLEX_OP_ADD = 0x4,
|
|
FLEX_OP_SUB = 0x5,
|
|
FLEX_OP_MUL = 0x6,
|
|
FLEX_OP_DIV = 0x7,
|
|
FLEX_OP_NEG = 0x8,
|
|
FLEX_OP_EXP = 0x9,
|
|
FLEX_OP_OPEN = 0xa,
|
|
FLEX_OP_CLOSE = 0xb,
|
|
FLEX_OP_COMMA = 0xc,
|
|
FLEX_OP_MAX = 0xd,
|
|
FLEX_OP_MIN = 0xe,
|
|
FLEX_OP_2WAY_0 = 0xf,
|
|
FLEX_OP_2WAY_1 = 0x10,
|
|
FLEX_OP_NWAY = 0x11,
|
|
FLEX_OP_COMBO = 0x12,
|
|
FLEX_OP_DOMINATE = 0x13,
|
|
FLEX_OP_DME_LOWER_EYELID = 0x14,
|
|
FLEX_OP_DME_UPPER_EYELID = 0x15,
|
|
FLEX_OP_SQRT = 0x16,
|
|
FLEX_OP_REMAPVALCLAMPED = 0x17,
|
|
FLEX_OP_SIN = 0x18,
|
|
FLEX_OP_COS = 0x19,
|
|
FLEX_OP_ABS = 0x1a,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class VPhysXAggregateData_t::VPhysXFlagEnum_t : uint32_t
|
|
{
|
|
VPhysXAggregateData_t::FLAG_IS_POLYSOUP_GEOMETRY = 0x1,
|
|
VPhysXAggregateData_t::FLAG_LEVEL_COLLISION = 0x10,
|
|
VPhysXAggregateData_t::FLAG_IGNORE_SCALE_OBSOLETE_DO_NOT_USE = 0x20,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class AnimVRFinger_t : uint32_t
|
|
{
|
|
AnimVrFinger_Thumb = 0x0,
|
|
AnimVrFinger_Index = 0x1,
|
|
AnimVrFinger_Middle = 0x2,
|
|
AnimVrFinger_Ring = 0x3,
|
|
AnimVrFinger_Pinky = 0x4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class SosGroupType_t : uint32_t
|
|
{
|
|
SOS_GROUPTYPE_DYNAMIC = 0x0,
|
|
SOS_GROUPTYPE_STATIC = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class ActionType_t : uint32_t
|
|
{
|
|
SOS_ACTION_NONE = 0x0,
|
|
SOS_ACTION_LIMITER = 0x1,
|
|
SOS_ACTION_TIME_LIMIT = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class SosActionSortType_t : uint32_t
|
|
{
|
|
SOS_SORTTYPE_HIGHEST = 0x0,
|
|
SOS_SORTTYPE_LOWEST = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 6
|
|
enum class SosEditItemType_t : uint32_t
|
|
{
|
|
SOS_EDIT_ITEM_TYPE_SOUNDEVENTS = 0x0,
|
|
SOS_EDIT_ITEM_TYPE_SOUNDEVENT = 0x1,
|
|
SOS_EDIT_ITEM_TYPE_LIBRARYSTACKS = 0x2,
|
|
SOS_EDIT_ITEM_TYPE_STACK = 0x3,
|
|
SOS_EDIT_ITEM_TYPE_OPERATOR = 0x4,
|
|
SOS_EDIT_ITEM_TYPE_FIELD = 0x5,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class SosActionStopType_t : uint32_t
|
|
{
|
|
SOS_STOPTYPE_NONE = 0x0,
|
|
SOS_STOPTYPE_TIME = 0x1,
|
|
SOS_STOPTYPE_OPVAR = 0x2,
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
enum class vmix_filter_type_t : uint16_t
|
|
{
|
|
FILTER_UNKNOWN = 18446744073709551615,
|
|
FILTER_LOWPASS = 0,
|
|
FILTER_HIGHPASS = 1,
|
|
FILTER_BANDPASS = 2,
|
|
FILTER_NOTCH = 3,
|
|
FILTER_PEAKING_EQ = 4,
|
|
FILTER_LOW_SHELF = 5,
|
|
FILTER_HIGH_SHELF = 6,
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 13
|
|
enum class vmix_processor_type_t : uint16_t
|
|
{
|
|
VPROCESSOR_UNKNOWN = 0,
|
|
VPROCESSOR_STEAMAUDIO_REVERB = 1,
|
|
VPROCESSOR_RT_PITCH = 2,
|
|
VPROCESSOR_STEAMAUDIO_HRTF = 3,
|
|
VPROCESSOR_DYNAMICS = 4,
|
|
VPROCESSOR_PRESETDSP = 5,
|
|
VPROCESSOR_DELAY = 6,
|
|
VPROCESSOR_FULLWAVE_INTEGRATOR = 7,
|
|
VPROCESSOR_FILTER = 8,
|
|
VPROCESSOR_STEAMAUDIO_PATHING = 9,
|
|
VPROCESSOR_EQ8 = 10,
|
|
VPROCESSOR_ENVELOPE = 11,
|
|
VPROCESSOR_VOCODER = 12,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 13
|
|
enum class ObjectTypeFlags_t : uint32_t
|
|
{
|
|
OBJECT_TYPE_NONE = 0x0,
|
|
OBJECT_TYPE_IMAGE_LOD = 0x1,
|
|
OBJECT_TYPE_GEOMETRY_LOD = 0x2,
|
|
OBJECT_TYPE_DECAL = 0x4,
|
|
OBJECT_TYPE_MODEL = 0x8,
|
|
OBJECT_TYPE_BLOCK_LIGHT = 0x10,
|
|
OBJECT_TYPE_NO_SHADOWS = 0x20,
|
|
OBJECT_TYPE_WORLDSPACE_TEXURE_BLEND = 0x40,
|
|
OBJECT_TYPE_DISABLED_IN_LOW_QUALITY = 0x80,
|
|
OBJECT_TYPE_NO_SUN_SHADOWS = 0x100,
|
|
OBJECT_TYPE_RENDER_WITH_DYNAMIC = 0x200,
|
|
OBJECT_TYPE_RENDER_TO_CUBEMAPS = 0x400,
|
|
OBJECT_TYPE_PRECOMPUTED_VISMEMBERS = 0x4000,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class voxel_vis_compression_t : uint32_t
|
|
{
|
|
VOXVIS_COMPRESS_RAW = 0x0,
|
|
VOXVIS_COMPRESS_RLE = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 1
|
|
enum class EntityLumpFlags_t : uint32_t
|
|
{
|
|
ENTITY_LUMP_NONE = 0x0,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class TextureRepetitionMode_t : uint32_t
|
|
{
|
|
TEXTURE_REPETITION_PARTICLE = 0x0,
|
|
TEXTURE_REPETITION_PATH = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class ParticleLightTypeChoiceList_t : uint32_t
|
|
{
|
|
PARTICLE_LIGHT_TYPE_POINT = 0x0,
|
|
PARTICLE_LIGHT_TYPE_SPOT = 0x1,
|
|
PARTICLE_LIGHT_TYPE_FX = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 6
|
|
enum class ParticleImpulseType_t : uint32_t
|
|
{
|
|
IMPULSE_TYPE_NONE = 0x0,
|
|
IMPULSE_TYPE_GENERIC = 0x1,
|
|
IMPULSE_TYPE_ROPE = 0x2,
|
|
IMPULSE_TYPE_EXPLOSION = 0x4,
|
|
IMPULSE_TYPE_EXPLOSION_UNDERWATER = 0x8,
|
|
IMPULSE_TYPE_PARTICLE_SYSTEM = 0x10,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class ParticleSortingChoiceList_t : uint32_t
|
|
{
|
|
PARTICLE_SORTING_NEAREST = 0x0,
|
|
PARTICLE_SORTING_CREATION_TIME = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class ParticleCollisionMode_t : uint32_t
|
|
{
|
|
COLLISION_MODE_PER_PARTICLE_TRACE = 0x3,
|
|
COLLISION_MODE_USE_NEAREST_TRACE = 0x2,
|
|
COLLISION_MODE_PER_FRAME_PLANESET = 0x1,
|
|
COLLISION_MODE_INITIAL_TRACE_DOWN = 0x0,
|
|
COLLISION_MODE_DISABLED = 0xffffffffffffffff,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 6
|
|
enum class ParticleOrientationChoiceList_t : uint32_t
|
|
{
|
|
PARTICLE_ORIENTATION_SCREEN_ALIGNED = 0x0,
|
|
PARTICLE_ORIENTATION_SCREEN_Z_ALIGNED = 0x1,
|
|
PARTICLE_ORIENTATION_WORLD_Z_ALIGNED = 0x2,
|
|
PARTICLE_ORIENTATION_ALIGN_TO_PARTICLE_NORMAL = 0x3,
|
|
PARTICLE_ORIENTATION_SCREENALIGN_TO_PARTICLE_NORMAL = 0x4,
|
|
PARTICLE_ORIENTATION_FULL_3AXIS_ROTATION = 0x5,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 18
|
|
enum class ParticleAttachment_t : uint32_t
|
|
{
|
|
PATTACH_INVALID = 0xffffffffffffffff,
|
|
PATTACH_ABSORIGIN = 0x0,
|
|
PATTACH_ABSORIGIN_FOLLOW = 0x1,
|
|
PATTACH_CUSTOMORIGIN = 0x2,
|
|
PATTACH_CUSTOMORIGIN_FOLLOW = 0x3,
|
|
PATTACH_POINT = 0x4,
|
|
PATTACH_POINT_FOLLOW = 0x5,
|
|
PATTACH_EYES_FOLLOW = 0x6,
|
|
PATTACH_OVERHEAD_FOLLOW = 0x7,
|
|
PATTACH_WORLDORIGIN = 0x8,
|
|
PATTACH_ROOTBONE_FOLLOW = 0x9,
|
|
PATTACH_RENDERORIGIN_FOLLOW = 0xa,
|
|
PATTACH_MAIN_VIEW = 0xb,
|
|
PATTACH_WATERWAKE = 0xc,
|
|
PATTACH_CENTER_FOLLOW = 0xd,
|
|
PATTACH_BONE = 0xe,
|
|
PATTACH_BONEFOLLOW = 0xf,
|
|
MAX_PATTACH_TYPES = 0x10,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class ParticleDetailLevel_t : uint32_t
|
|
{
|
|
PARTICLEDETAIL_LOW = 0x0,
|
|
PARTICLEDETAIL_MEDIUM = 0x1,
|
|
PARTICLEDETAIL_HIGH = 0x2,
|
|
PARTICLEDETAIL_ULTRA = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class ParticleFalloffFunction_t : uint32_t
|
|
{
|
|
PARTICLE_FALLOFF_CONSTANT = 0x0,
|
|
PARTICLE_FALLOFF_LINEAR = 0x1,
|
|
PARTICLE_FALLOFF_EXPONENTIAL = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 12
|
|
enum class ParticleVecType_t : uint32_t
|
|
{
|
|
PVEC_TYPE_INVALID = 0xffffffffffffffff,
|
|
PVEC_TYPE_LITERAL = 0x0,
|
|
PVEC_TYPE_LITERAL_COLOR = 0x1,
|
|
PVEC_TYPE_PARTICLE_VECTOR = 0x2,
|
|
PVEC_TYPE_CP_VALUE = 0x3,
|
|
PVEC_TYPE_CP_RELATIVE_POSITION = 0x4,
|
|
PVEC_TYPE_CP_RELATIVE_DIR = 0x5,
|
|
PVEC_TYPE_FLOAT_COMPONENTS = 0x6,
|
|
PVEC_TYPE_FLOAT_INTERP_CLAMPED = 0x7,
|
|
PVEC_TYPE_FLOAT_INTERP_OPEN = 0x8,
|
|
PVEC_TYPE_FLOAT_INTERP_GRADIENT = 0x9,
|
|
PVEC_TYPE_COUNT = 0xa,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class PFNoiseModifier_t : uint32_t
|
|
{
|
|
PF_NOISE_MODIFIER_NONE = 0x0,
|
|
PF_NOISE_MODIFIER_LINES = 0x1,
|
|
PF_NOISE_MODIFIER_CLUMPS = 0x2,
|
|
PF_NOISE_MODIFIER_RINGS = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class ParticleFloatRandomMode_t : uint32_t
|
|
{
|
|
PF_RANDOM_MODE_INVALID = 0xffffffffffffffff,
|
|
PF_RANDOM_MODE_CONSTANT = 0x0,
|
|
PF_RANDOM_MODE_VARYING = 0x1,
|
|
PF_RANDOM_MODE_COUNT = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class ParticleDepthFeatheringMode_t : uint32_t
|
|
{
|
|
PARTICLE_DEPTH_FEATHERING_OFF = 0x0,
|
|
PARTICLE_DEPTH_FEATHERING_ON_OPTIONAL = 0x1,
|
|
PARTICLE_DEPTH_FEATHERING_ON_REQUIRED = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class ParticleFloatInputMode_t : uint32_t
|
|
{
|
|
PF_INPUT_MODE_INVALID = 0xffffffffffffffff,
|
|
PF_INPUT_MODE_CLAMPED = 0x0,
|
|
PF_INPUT_MODE_LOOPED = 0x1,
|
|
PF_INPUT_MODE_COUNT = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class ParticleSelection_t : uint32_t
|
|
{
|
|
PARTICLE_SELECTION_FIRST = 0x0,
|
|
PARTICLE_SELECTION_LAST = 0x1,
|
|
PARTICLE_SELECTION_NUMBER = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 7
|
|
enum class ParticleFloatMapType_t : uint32_t
|
|
{
|
|
PF_MAP_TYPE_INVALID = 0xffffffffffffffff,
|
|
PF_MAP_TYPE_DIRECT = 0x0,
|
|
PF_MAP_TYPE_MULT = 0x1,
|
|
PF_MAP_TYPE_REMAP = 0x2,
|
|
PF_MAP_TYPE_REMAP_BIASED = 0x3,
|
|
PF_MAP_TYPE_CURVE = 0x4,
|
|
PF_MAP_TYPE_COUNT = 0x5,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class ParticleTopology_t : uint32_t
|
|
{
|
|
PARTICLE_TOPOLOGY_POINTS = 0x0,
|
|
PARTICLE_TOPOLOGY_LINES = 0x1,
|
|
PARTICLE_TOPOLOGY_TRIS = 0x2,
|
|
PARTICLE_TOPOLOGY_QUADS = 0x3,
|
|
PARTICLE_TOPOLOGY_CUBES = 0x4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class AnimationType_t : uint32_t
|
|
{
|
|
ANIMATION_TYPE_FIXED_RATE = 0x0,
|
|
ANIMATION_TYPE_FIT_LIFETIME = 0x1,
|
|
ANIMATION_TYPE_MANUAL_FRAMES = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class HitboxLerpType_t : uint32_t
|
|
{
|
|
HITBOX_LERP_LIFETIME = 0x0,
|
|
HITBOX_LERP_CONSTANT = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 9
|
|
enum class VectorExpressionType_t : uint32_t
|
|
{
|
|
VECTOR_EXPRESSION_UNINITIALIZED = 0xffffffffffffffff,
|
|
VECTOR_EXPRESSION_ADD = 0x0,
|
|
VECTOR_EXPRESSION_SUBTRACT = 0x1,
|
|
VECTOR_EXPRESSION_MUL = 0x2,
|
|
VECTOR_EXPRESSION_DIVIDE = 0x3,
|
|
VECTOR_EXPRESSION_INPUT_1 = 0x4,
|
|
VECTOR_EXPRESSION_MIN = 0x5,
|
|
VECTOR_EXPRESSION_MAX = 0x6,
|
|
VECTOR_EXPRESSION_NORMALIZE_INPUT_1 = 0x7,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 13
|
|
enum class SequenceCombineMode_t : uint32_t
|
|
{
|
|
SEQUENCE_COMBINE_MODE_USE_SEQUENCE_0 = 0x0,
|
|
SEQUENCE_COMBINE_MODE_USE_SEQUENCE_1 = 0x1,
|
|
SEQUENCE_COMBINE_MODE_AVERAGE = 0x2,
|
|
SEQUENCE_COMBINE_MODE_ADDITIVE = 0x3,
|
|
SEQUENCE_COMBINE_MODE_ALPHA_FROM0_RGB_FROM_1 = 0x4,
|
|
SEQUENCE_COMBINE_MODE_ALPHA_FROM1_RGB_FROM_0 = 0x5,
|
|
SEQUENCE_COMBINE_MODE_WEIGHTED_BLEND = 0x6,
|
|
SEQUENCE_COMBINE_MODE_ALPHA_BLEND_1_OVER_0 = 0x7,
|
|
SEQUENCE_COMBINE_MODE_REPLICATEALPHA0 = 0x8,
|
|
SEQUENCE_COMBINE_MODE_REPLICATEALPHA1 = 0x9,
|
|
SEQUENCE_COMBINE_MODE_ALPHA_BLEND_0_OVER_1 = 0xa,
|
|
SEQUENCE_COMBINE_MODE_REPLICATE_COLOR_0 = 0xb,
|
|
SEQUENCE_COMBINE_MODE_REPLICATE_COLOR_1 = 0xc,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 11
|
|
enum class ParticlePinDistance_t : uint32_t
|
|
{
|
|
PARTICLE_PIN_DISTANCE_NONE = 0xffffffffffffffff,
|
|
PARTICLE_PIN_DISTANCE_NEIGHBOR = 0x0,
|
|
PARTICLE_PIN_DISTANCE_FARTHEST = 0x1,
|
|
PARTICLE_PIN_DISTANCE_FIRST = 0x2,
|
|
PARTICLE_PIN_DISTANCE_LAST = 0x3,
|
|
PARTICLE_PIN_DISTANCE_CENTER = 0x5,
|
|
PARTICLE_PIN_DISTANCE_CP = 0x6,
|
|
PARTICLE_PIN_DISTANCE_CP_PAIR_EITHER = 0x7,
|
|
PARTICLE_PIN_DISTANCE_CP_PAIR_BOTH = 0x8,
|
|
PARTICLE_PIN_SPEED = 0x9,
|
|
PARTICLE_PIN_COLLECTION_AGE = 0xa,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class ParticleDirectionNoiseType_t : uint32_t
|
|
{
|
|
PARTICLE_DIR_NOISE_PERLIN = 0x0,
|
|
PARTICLE_DIR_NOISE_CURL = 0x1,
|
|
PARTICLE_DIR_NOISE_WORLEY_BASIC = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class PFNoiseType_t : uint32_t
|
|
{
|
|
PF_NOISE_TYPE_PERLIN = 0x0,
|
|
PF_NOISE_TYPE_SIMPLEX = 0x1,
|
|
PF_NOISE_TYPE_WORLEY = 0x2,
|
|
PF_NOISE_TYPE_CURL = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class BlurFilterType_t : uint32_t
|
|
{
|
|
BLURFILTER_GAUSSIAN = 0x0,
|
|
BLURFILTER_BOX = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 8
|
|
enum class ScalarExpressionType_t : uint32_t
|
|
{
|
|
SCALAR_EXPRESSION_UNINITIALIZED = 0xffffffffffffffff,
|
|
SCALAR_EXPRESSION_ADD = 0x0,
|
|
SCALAR_EXPRESSION_SUBTRACT = 0x1,
|
|
SCALAR_EXPRESSION_MUL = 0x2,
|
|
SCALAR_EXPRESSION_DIVIDE = 0x3,
|
|
SCALAR_EXPRESSION_INPUT_1 = 0x4,
|
|
SCALAR_EXPRESSION_MIN = 0x5,
|
|
SCALAR_EXPRESSION_MAX = 0x6,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class DetailCombo_t : uint32_t
|
|
{
|
|
DETAIL_COMBO_OFF = 0x0,
|
|
DETAIL_COMBO_ADD = 0x1,
|
|
DETAIL_COMBO_ADD_SELF_ILLUM = 0x2,
|
|
DETAIL_COMBO_MOD2X = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 8
|
|
enum class ParticleColorBlendType_t : uint32_t
|
|
{
|
|
PARTICLE_COLOR_BLEND_MULTIPLY = 0x0,
|
|
PARTICLE_COLOR_BLEND_ADD = 0x1,
|
|
PARTICLE_COLOR_BLEND_SUBTRACT = 0x2,
|
|
PARTICLE_COLOR_BLEND_MOD2X = 0x3,
|
|
PARTICLE_COLOR_BLEND_SCREEN = 0x4,
|
|
PARTICLE_COLOR_BLEND_MAX = 0x5,
|
|
PARTICLE_COLOR_BLEND_MIN = 0x6,
|
|
PARTICLE_COLOR_BLEND_REPLACE = 0x7,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class ParticleColorBlendMode_t : uint32_t
|
|
{
|
|
PARTICLEBLEND_DEFAULT = 0x0,
|
|
PARTICLEBLEND_OVERLAY = 0x1,
|
|
PARTICLEBLEND_DARKEN = 0x2,
|
|
PARTICLEBLEND_LIGHTEN = 0x3,
|
|
PARTICLEBLEND_MULTIPLY = 0x4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 6
|
|
enum class PFNoiseTurbulence_t : uint32_t
|
|
{
|
|
PF_NOISE_TURB_NONE = 0x0,
|
|
PF_NOISE_TURB_HIGHLIGHT = 0x1,
|
|
PF_NOISE_TURB_FEEDBACK = 0x2,
|
|
PF_NOISE_TURB_LOOPY = 0x3,
|
|
PF_NOISE_TURB_CONTRAST = 0x4,
|
|
PF_NOISE_TURB_ALTERNATE = 0x5,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 18
|
|
enum class ParticleFloatType_t : uint32_t
|
|
{
|
|
PF_TYPE_INVALID = 0xffffffffffffffff,
|
|
PF_TYPE_LITERAL = 0x0,
|
|
PF_TYPE_RANDOM_UNIFORM = 0x1,
|
|
PF_TYPE_RANDOM_BIASED = 0x2,
|
|
PF_TYPE_COLLECTION_AGE = 0x3,
|
|
PF_TYPE_ENDCAP_AGE = 0x4,
|
|
PF_TYPE_CONTROL_POINT_COMPONENT = 0x5,
|
|
PF_TYPE_CONTROL_POINT_CHANGE_AGE = 0x6,
|
|
PF_TYPE_PARTICLE_DETAIL_LEVEL = 0x7,
|
|
PF_TYPE_PARTICLE_NOISE = 0x8,
|
|
PF_TYPE_PARTICLE_AGE = 0x9,
|
|
PF_TYPE_PARTICLE_AGE_NORMALIZED = 0xa,
|
|
PF_TYPE_PARTICLE_FLOAT = 0xb,
|
|
PF_TYPE_PARTICLE_VECTOR_COMPONENT = 0xc,
|
|
PF_TYPE_PARTICLE_SPEED = 0xd,
|
|
PF_TYPE_PARTICLE_NUMBER = 0xe,
|
|
PF_TYPE_PARTICLE_NUMBER_NORMALIZED = 0xf,
|
|
PF_TYPE_COUNT = 0x10,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class PetGroundType_t : uint32_t
|
|
{
|
|
PET_GROUND_NONE = 0x0,
|
|
PET_GROUND_GRID = 0x1,
|
|
PET_GROUND_PLANE = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class ParticleVRHandChoiceList_t : uint32_t
|
|
{
|
|
PARTICLE_VRHAND_LEFT = 0x0,
|
|
PARTICLE_VRHAND_RIGHT = 0x1,
|
|
PARTICLE_VRHAND_CP = 0x2,
|
|
PARTICLE_VRHAND_CP_OBJECT = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 7
|
|
enum class PFuncVisualizationType_t : uint32_t
|
|
{
|
|
PFUNC_VISUALIZATION_SPHERE_WIREFRAME = 0x0,
|
|
PFUNC_VISUALIZATION_SPHERE_SOLID = 0x1,
|
|
PFUNC_VISUALIZATION_BOX = 0x2,
|
|
PFUNC_VISUALIZATION_RING = 0x3,
|
|
PFUNC_VISUALIZATION_PLANE = 0x4,
|
|
PFUNC_VISUALIZATION_LINE = 0x5,
|
|
PFUNC_VISUALIZATION_CYLINDER = 0x6,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class ParticleFloatBiasType_t : uint32_t
|
|
{
|
|
PF_BIAS_TYPE_INVALID = 0xffffffffffffffff,
|
|
PF_BIAS_TYPE_STANDARD = 0x0,
|
|
PF_BIAS_TYPE_GAIN = 0x1,
|
|
PF_BIAS_TYPE_EXPONENTIAL = 0x2,
|
|
PF_BIAS_TYPE_COUNT = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class MissingParentInheritBehavior_t : uint32_t
|
|
{
|
|
MISSING_PARENT_DO_NOTHING = 0xffffffffffffffff,
|
|
MISSING_PARENT_KILL = 0x0,
|
|
MISSING_PARENT_FIND_NEW = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 7
|
|
enum class Detail2Combo_t : uint32_t
|
|
{
|
|
DETAIL_2_COMBO_UNINITIALIZED = 0xffffffffffffffff,
|
|
DETAIL_2_COMBO_OFF = 0x0,
|
|
DETAIL_2_COMBO_ADD = 0x1,
|
|
DETAIL_2_COMBO_ADD_SELF_ILLUM = 0x2,
|
|
DETAIL_2_COMBO_MOD2X = 0x3,
|
|
DETAIL_2_COMBO_MUL = 0x4,
|
|
DETAIL_2_COMBO_CROSSFADE = 0x5,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class ParticleSetMethod_t : uint32_t
|
|
{
|
|
PARTICLE_SET_REPLACE_VALUE = 0x0,
|
|
PARTICLE_SET_SCALE_INITIAL_VALUE = 0x1,
|
|
PARTICLE_SET_ADD_TO_INITIAL_VALUE = 0x2,
|
|
PARTICLE_SET_SCALE_CURRENT_VALUE = 0x3,
|
|
PARTICLE_SET_ADD_TO_CURRENT_VALUE = 0x4,
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 14
|
|
enum class MoveType_t : uint8_t
|
|
{
|
|
MOVETYPE_NONE = 0,
|
|
MOVETYPE_UNUSED1 = 1,
|
|
MOVETYPE_WALK = 2,
|
|
MOVETYPE_UNUSED9 = 3,
|
|
MOVETYPE_UNUSED2 = 4,
|
|
MOVETYPE_UNUSED3 = 5,
|
|
MOVETYPE_VPHYSICS = 6,
|
|
MOVETYPE_UNUSED8 = 7,
|
|
MOVETYPE_UNUSED4 = 8,
|
|
MOVETYPE_UNUSED5 = 9,
|
|
MOVETYPE_UNUSED6 = 10,
|
|
MOVETYPE_UNUSED7 = 11,
|
|
MOVETYPE_LAST = 11,
|
|
MOVETYPE_MAX_BITS = 4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class ValueRemapperHapticsType_t : uint32_t
|
|
{
|
|
HaticsType_Default = 0x0,
|
|
HaticsType_None = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class ValueRemapperInputType_t : uint32_t
|
|
{
|
|
InputType_PlayerShootPosition = 0x0,
|
|
InputType_PlayerShootPositionAroundAxis = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class ShadowType_t : uint32_t
|
|
{
|
|
SHADOWS_NONE = 0x0,
|
|
SHADOWS_SIMPLE = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class BrushSolidities_e : uint32_t
|
|
{
|
|
BRUSHSOLID_TOGGLE = 0x0,
|
|
BRUSHSOLID_NEVER = 0x1,
|
|
BRUSHSOLID_ALWAYS = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class PointWorldTextJustifyHorizontal_t : uint32_t
|
|
{
|
|
POINT_WORLD_TEXT_JUSTIFY_HORIZONTAL_LEFT = 0x0,
|
|
POINT_WORLD_TEXT_JUSTIFY_HORIZONTAL_CENTER = 0x1,
|
|
POINT_WORLD_TEXT_JUSTIFY_HORIZONTAL_RIGHT = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class PointTemplateOwnerSpawnGroupType_t : uint32_t
|
|
{
|
|
INSERT_INTO_POINT_TEMPLATE_SPAWN_GROUP = 0x0,
|
|
INSERT_INTO_CURRENTLY_ACTIVE_SPAWN_GROUP = 0x1,
|
|
INSERT_INTO_NEWLY_CREATED_SPAWN_GROUP = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class ValueRemapperOutputType_t : uint32_t
|
|
{
|
|
OutputType_AnimationCycle = 0x0,
|
|
OutputType_RotationX = 0x1,
|
|
OutputType_RotationY = 0x2,
|
|
OutputType_RotationZ = 0x3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class PointWorldTextJustifyVertical_t : uint32_t
|
|
{
|
|
POINT_WORLD_TEXT_JUSTIFY_VERTICAL_BOTTOM = 0x0,
|
|
POINT_WORLD_TEXT_JUSTIFY_VERTICAL_CENTER = 0x1,
|
|
POINT_WORLD_TEXT_JUSTIFY_VERTICAL_TOP = 0x2,
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 11
|
|
enum class SolidType_t : uint8_t
|
|
{
|
|
SOLID_NONE = 0,
|
|
SOLID_BSP = 1,
|
|
SOLID_BBOX = 2,
|
|
SOLID_OBB = 3,
|
|
SOLID_POINT = 5,
|
|
SOLID_VPHYSICS = 6,
|
|
SOLID_CAPSULE = 7,
|
|
SOLID_SPHERE = 8,
|
|
SOLID_ORIENTED_CAPSULE = 9,
|
|
SOLID_CYLINDER = 10,
|
|
SOLID_LAST = 11,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 1
|
|
enum class navproperties_t : uint32_t
|
|
{
|
|
NAV_IGNORE = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class PlayerConnectedState : uint32_t
|
|
{
|
|
PlayerConnected = 0x0,
|
|
PlayerDisconnecting = 0x1,
|
|
PlayerDisconnected = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class DoorState_t : uint32_t
|
|
{
|
|
DOOR_STATE_CLOSED = 0x0,
|
|
DOOR_STATE_OPENING = 0x1,
|
|
DOOR_STATE_OPEN = 0x2,
|
|
DOOR_STATE_CLOSING = 0x3,
|
|
DOOR_STATE_AJAR = 0x4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 6
|
|
enum class LatchDirtyPermission_t : uint32_t
|
|
{
|
|
LATCH_DIRTY_DISALLOW = 0x0,
|
|
LATCH_DIRTY_SERVER_CONTROLLED = 0x1,
|
|
LATCH_DIRTY_CLIENT_SIMULATED = 0x2,
|
|
LATCH_DIRTY_PREDICTION = 0x3,
|
|
LATCH_DIRTY_FRAMESIMULATE = 0x4,
|
|
LATCH_DIRTY_PARTICLE_SIMULATE = 0x5,
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 20
|
|
enum class RenderFx_t : uint8_t
|
|
{
|
|
kRenderFxNone = 0,
|
|
kRenderFxPulseSlow = 1,
|
|
kRenderFxPulseFast = 2,
|
|
kRenderFxPulseSlowWide = 3,
|
|
kRenderFxPulseFastWide = 4,
|
|
kRenderFxFadeSlow = 5,
|
|
kRenderFxFadeFast = 6,
|
|
kRenderFxSolidSlow = 7,
|
|
kRenderFxSolidFast = 8,
|
|
kRenderFxStrobeSlow = 9,
|
|
kRenderFxStrobeFast = 10,
|
|
kRenderFxStrobeFaster = 11,
|
|
kRenderFxFlickerSlow = 12,
|
|
kRenderFxFlickerFast = 13,
|
|
kRenderFxNoDissipation = 14,
|
|
kRenderFxFadeOut = 15,
|
|
kRenderFxFadeIn = 16,
|
|
kRenderFxPulseFastWider = 17,
|
|
kRenderFxGlowShell = 18,
|
|
kRenderFxMax = 19,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class NavDirType : uint32_t
|
|
{
|
|
NORTH = 0x0,
|
|
EAST = 0x1,
|
|
SOUTH = 0x2,
|
|
WEST = 0x3,
|
|
NUM_DIRECTIONS = 0x4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class ValueRemapperRatchetType_t : uint32_t
|
|
{
|
|
RatchetType_Absolute = 0x0,
|
|
RatchetType_EachEngage = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class PointTemplateClientOnlyEntityBehavior_t : uint32_t
|
|
{
|
|
CREATE_FOR_CURRENTLY_CONNECTED_CLIENTS_ONLY = 0x0,
|
|
CREATE_FOR_CLIENTS_WHO_CONNECT_LATER = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 30
|
|
enum class soundlevel_t : uint32_t
|
|
{
|
|
SNDLVL_NONE = 0x0,
|
|
SNDLVL_20dB = 0x14,
|
|
SNDLVL_25dB = 0x19,
|
|
SNDLVL_30dB = 0x1e,
|
|
SNDLVL_35dB = 0x23,
|
|
SNDLVL_40dB = 0x28,
|
|
SNDLVL_45dB = 0x2d,
|
|
SNDLVL_50dB = 0x32,
|
|
SNDLVL_55dB = 0x37,
|
|
SNDLVL_IDLE = 0x3c,
|
|
SNDLVL_60dB = 0x3c,
|
|
SNDLVL_65dB = 0x41,
|
|
SNDLVL_STATIC = 0x42,
|
|
SNDLVL_70dB = 0x46,
|
|
SNDLVL_NORM = 0x4b,
|
|
SNDLVL_75dB = 0x4b,
|
|
SNDLVL_80dB = 0x50,
|
|
SNDLVL_TALKING = 0x50,
|
|
SNDLVL_85dB = 0x55,
|
|
SNDLVL_90dB = 0x5a,
|
|
SNDLVL_95dB = 0x5f,
|
|
SNDLVL_100dB = 0x64,
|
|
SNDLVL_105dB = 0x69,
|
|
SNDLVL_110dB = 0x6e,
|
|
SNDLVL_120dB = 0x78,
|
|
SNDLVL_130dB = 0x82,
|
|
SNDLVL_GUNFIRE = 0x8c,
|
|
SNDLVL_140dB = 0x8c,
|
|
SNDLVL_150dB = 0x96,
|
|
SNDLVL_180dB = 0xb4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 6
|
|
enum class HierarchyType_t : uint32_t
|
|
{
|
|
HIERARCHY_NONE = 0x0,
|
|
HIERARCHY_BONE_MERGE = 0x1,
|
|
HIERARCHY_ATTACHMENT = 0x2,
|
|
HIERARCHY_ABSORIGIN = 0x3,
|
|
HIERARCHY_BONE = 0x4,
|
|
HIERARCHY_TYPE_COUNT = 0x5,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class PointWorldTextReorientMode_t : uint32_t
|
|
{
|
|
POINT_WORLD_TEXT_REORIENT_NONE = 0x0,
|
|
POINT_WORLD_TEXT_REORIENT_AROUND_UP = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class SpawnDebugRestrictionOverrideState_t : uint32_t
|
|
{
|
|
SPAWN_DEBUG_RESTRICT_NONE = 0x0,
|
|
SPAWN_DEBUG_RESTRICT_IGNORE_MANAGER_DISTANCE_REQS = 0x1,
|
|
SPAWN_DEBUG_RESTRICT_IGNORE_TEMPLATE_DISTANCE_LOS_REQS = 0x2,
|
|
SPAWN_DEBUG_RESTRICT_IGNORE_TEMPLATE_COOLDOWN_LIMITS = 0x4,
|
|
SPAWN_DEBUG_RESTRICT_IGNORE_TARGET_COOLDOWN_LIMITS = 0x8,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
enum class ValueRemapperMomentumType_t : uint32_t
|
|
{
|
|
MomentumType_None = 0x0,
|
|
MomentumType_Friction = 0x1,
|
|
MomentumType_SpringTowardSnapValue = 0x2,
|
|
MomentumType_SpringAwayFromSnapValue = 0x3,
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 16
|
|
enum class NavAttributeEnum : uint64_t
|
|
{
|
|
NAV_MESH_CROUCH = 0x1,
|
|
NAV_MESH_JUMP = 0x2,
|
|
NAV_MESH_PRECISE = 0x4,
|
|
NAV_MESH_NO_JUMP = 0x8,
|
|
NAV_MESH_AVOID = 0x80,
|
|
NAV_MESH_STAIRS = 0x1000,
|
|
NAV_MESH_NO_MERGE = 0x2000,
|
|
NAV_MESH_OBSTACLE_TOP = 0x4000,
|
|
NAV_MESH_CLIFF = 0x8000,
|
|
NAV_MESH_STOP = 0x10,
|
|
NAV_MESH_RUN = 0x20,
|
|
NAV_MESH_WALK = 0x40,
|
|
NAV_MESH_TRANSIENT = 0x100,
|
|
NAV_MESH_DONT_HIDE = 0x200,
|
|
NAV_MESH_STAND = 0x400,
|
|
NAV_MESH_NO_HOSTAGES = 0x800,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 8
|
|
enum class TOGGLE_STATE : uint32_t
|
|
{
|
|
TS_AT_TOP = 0x0,
|
|
TS_AT_BOTTOM = 0x1,
|
|
TS_GOING_UP = 0x2,
|
|
TS_GOING_DOWN = 0x3,
|
|
DOOR_OPEN = 0x0,
|
|
DOOR_CLOSED = 0x1,
|
|
DOOR_OPENING = 0x2,
|
|
DOOR_CLOSING = 0x3,
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 13
|
|
enum class RenderMode_t : uint8_t
|
|
{
|
|
kRenderNormal = 0,
|
|
kRenderTransColor = 1,
|
|
kRenderTransTexture = 2,
|
|
kRenderGlow = 3,
|
|
kRenderTransAlpha = 4,
|
|
kRenderTransAdd = 5,
|
|
kRenderEnvironmental = 6,
|
|
kRenderTransAddFrameBlend = 7,
|
|
kRenderTransAlphaAdd = 8,
|
|
kRenderWorldGlow = 9,
|
|
kRenderNone = 10,
|
|
kRenderDevVisualizer = 11,
|
|
kRenderModeCount = 12,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class EntFinderMethod_t : uint32_t
|
|
{
|
|
ENT_FIND_METHOD_NEAREST = 0x0,
|
|
ENT_FIND_METHOD_FARTHEST = 0x1,
|
|
ENT_FIND_METHOD_RANDOM = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class SpawnDebugOverrideState_t : uint32_t
|
|
{
|
|
SPAWN_DEBUG_OVERRIDE_NONE = 0x0,
|
|
SPAWN_DEBUG_OVERRIDE_FORCE_ENABLED = 0x1,
|
|
SPAWN_DEBUG_OVERRIDE_FORCE_DISABLED = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 11
|
|
enum class PrecipitationType_t : uint32_t
|
|
{
|
|
PRECIPITATION_TYPE_PARTICLERAIN = 0x4,
|
|
PRECIPITATION_TYPE_PARTICLEASH = 0x5,
|
|
PRECIPITATION_TYPE_PARTICLERAINSTORM = 0x6,
|
|
PRECIPITATION_TYPE_PARTICLEBUGS = 0x7,
|
|
PRECIPITATION_TYPE_PARTICLESMOKE = 0x8,
|
|
PRECIPITATION_TYPE_PARTICLESNOW = 0x9,
|
|
PRECIPITATION_TYPE_PARTICLEXENSPORES = 0xa,
|
|
PRECIPITATION_TYPE_DUSTMOTES = 0xb,
|
|
PRECIPITATION_TYPE_PARTICLEFLYINGEMBER = 0xc,
|
|
PRECIPITATION_TYPE_PARTICLEGROUNDFOG = 0xd,
|
|
NUM_PRECIPITATION_TYPES = 0xe,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class filter_t : uint32_t
|
|
{
|
|
FILTER_AND = 0x0,
|
|
FILTER_OR = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class Class_T : uint32_t
|
|
{
|
|
CLASS_NONE = 0x0,
|
|
CLASS_PLAYER = 0x1,
|
|
CLASS_PLAYER_ALLY = 0x2,
|
|
CLASS_BULLSEYE = 0x3,
|
|
LAST_SHARED_ENTITY_CLASS = 0x4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class ScreenEffectType_t : uint32_t
|
|
{
|
|
SCREENEFFECT_EP2_ADVISOR_STUN = 0x0,
|
|
SCREENEFFECT_EP1_INTRO = 0x1,
|
|
SCREENEFFECT_EP2_GROGGY = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class LifeState_t : uint32_t
|
|
{
|
|
LIFE_ALIVE = 0x0,
|
|
LIFE_DYING = 0x1,
|
|
LIFE_DEAD = 0x2,
|
|
LIFE_RESPAWNABLE = 0x3,
|
|
LIFE_RESPAWNING = 0x4,
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 9
|
|
enum class SurroundingBoundsType_t : uint8_t
|
|
{
|
|
USE_OBB_COLLISION_BOUNDS = 0,
|
|
USE_BEST_COLLISION_BOUNDS = 1,
|
|
USE_HITBOXES = 2,
|
|
USE_SPECIFIED_BOUNDS = 3,
|
|
USE_GAME_CODE = 4,
|
|
USE_ROTATION_EXPANDED_BOUNDS = 5,
|
|
USE_COLLISION_BOUNDS_NEVER_VPHYSICS = 6,
|
|
USE_ROTATION_EXPANDED_SEQUENCE_BOUNDS = 7,
|
|
SURROUNDING_TYPE_BIT_COUNT = 3,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 5
|
|
enum class TimelineCompression_t : uint32_t
|
|
{
|
|
TIMELINE_COMPRESSION_SUM = 0x0,
|
|
TIMELINE_COMPRESSION_COUNT_PER_INTERVAL = 0x1,
|
|
TIMELINE_COMPRESSION_AVERAGE = 0x2,
|
|
TIMELINE_COMPRESSION_AVERAGE_BLEND = 0x3,
|
|
TIMELINE_COMPRESSION_TOTAL = 0x4,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2
|
|
enum class SceneOnPlayerDeath_t : uint32_t
|
|
{
|
|
SCENE_ONPLAYERDEATH_DO_NOTHING = 0x0,
|
|
SCENE_ONPLAYERDEATH_CANCEL = 0x1,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 3
|
|
enum class LOSSpeculativeMuzzle_t : uint32_t
|
|
{
|
|
MUZZLE_CURRENT_NPC_STATE = 0x0,
|
|
MUZZLE_STANDING = 0x1,
|
|
MUZZLE_CROUCHING = 0x2,
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 13
|
|
enum class PostProcessParameterNames_t : uint32_t
|
|
{
|
|
PPPN_FADE_TIME = 0x0,
|
|
PPPN_LOCAL_CONTRAST_STRENGTH = 0x1,
|
|
PPPN_LOCAL_CONTRAST_EDGE_STRENGTH = 0x2,
|
|
PPPN_VIGNETTE_START = 0x3,
|
|
PPPN_VIGNETTE_END = 0x4,
|
|
PPPN_VIGNETTE_BLUR_STRENGTH = 0x5,
|
|
PPPN_FADE_TO_BLACK_STRENGTH = 0x6,
|
|
PPPN_DEPTH_BLUR_FOCAL_DISTANCE = 0x7,
|
|
PPPN_DEPTH_BLUR_STRENGTH = 0x8,
|
|
PPPN_SCREEN_BLUR_STRENGTH = 0x9,
|
|
PPPN_FILM_GRAIN_STRENGTH = 0xa,
|
|
PPPN_TOP_VIGNETTE_STRENGTH = 0xb,
|
|
POST_PROCESS_PARAMETER_COUNT = 0xc,
|
|
};
|
|
|
|
// Aligment: 18
|
|
// Size: 336
|
|
class CSchemaSystemInternalRegistration
|
|
{
|
|
public:
|
|
Vector2D m_Vector2D; // 0x0
|
|
Vector m_Vector; // 0x8
|
|
VectorAligned m_VectorAligned; // 0x20
|
|
QAngle m_QAngle; // 0x30
|
|
RadianEuler m_RadianEuler; // 0x3c
|
|
DegreeEuler m_DegreeEuler; // 0x48
|
|
Quaternion m_Quaternion; // 0x54
|
|
matrix3x4_t m_matrix3x4_t; // 0x64
|
|
matrix3x4a_t m_matrix3x4a_t; // 0xa0
|
|
Color m_Color; // 0xd0
|
|
Vector4D m_Vector4D; // 0xd4
|
|
CTransform m_CTransform; // 0xf0
|
|
KeyValues* m_pKeyValues; // 0x110
|
|
CUtlBinaryBlock m_CUtlBinaryBlock; // 0x118
|
|
CUtlString m_CUtlString; // 0x130
|
|
CUtlSymbol m_CUtlSymbol; // 0x138
|
|
CUtlStringToken m_stringToken; // 0x13c
|
|
CResourceArray< CResourcePointer< CResourceString > > m_ResourceTypes; // 0x140
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCResourceManifestInternal
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCEntityLump
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCSequenceGroupData
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeIParticleSystemDefinition
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCTextureBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCModel
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeIMaterial2
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCAnimData
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCGenericDataResource
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCVMixListResource
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeIAnimationGraph
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCWorldNode
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCVSoundEventScriptList
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCAnimationGroup
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeIAnimationSubGraph
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
struct InfoForResourceTypeVSound_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 64
|
|
class FourQuaternions
|
|
{
|
|
public:
|
|
fltx4 x; // 0x0
|
|
fltx4 y; // 0x10
|
|
fltx4 z; // 0x20
|
|
fltx4 w; // 0x30
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeIParticleSnapshot
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCPostProcessingResource
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 24
|
|
struct AABB_t
|
|
{
|
|
public:
|
|
Vector m_vMinBounds; // 0x0
|
|
Vector m_vMaxBounds; // 0xc
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
struct InfoForResourceTypeWorld_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCPhysAggregateData
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCVoxelVisibility
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCRenderMesh
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCVPhysXSurfacePropertiesList
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 35
|
|
// Size: 264
|
|
struct LightDesc_t
|
|
{
|
|
public:
|
|
LightType_t m_Type; // 0x0
|
|
Vector m_Color; // 0x4
|
|
Vector m_BounceColor; // 0x10
|
|
float m_Range; // 0x1c
|
|
float m_Falloff; // 0x20
|
|
float m_Attenuation0; // 0x24
|
|
float m_Attenuation1; // 0x28
|
|
float m_Attenuation2; // 0x2c
|
|
float m_Theta; // 0x30
|
|
float m_Phi; // 0x34
|
|
int32_t m_nLightGroupCount; // 0x40
|
|
CUtlStringToken[1] m_lightGroups; // 0x44
|
|
bool m_bCastShadows; // 0x48
|
|
int32_t m_nShadowWidth; // 0x4c
|
|
int32_t m_nShadowHeight; // 0x50
|
|
int32_t m_nShadowCascadeCount; // 0x54
|
|
float32[4] m_flShadowCascadeDistance; // 0x58
|
|
int32[4] m_nShadowCascadeResolution; // 0x68
|
|
bool m_bUsesIndexedBakedLighting; // 0x78
|
|
int32_t m_nBakeLightIndex; // 0x7c
|
|
float m_flBakeLightIndexScale; // 0x80
|
|
int32_t m_nFogLightingMode; // 0x84
|
|
bool m_bRenderDiffuse; // 0x88
|
|
bool m_bRenderSpecular; // 0x89
|
|
bool m_bRenderTransmissive; // 0x8a
|
|
int32_t m_nPriority; // 0x8c
|
|
LightSourceShape_t m_Shape; // 0x90
|
|
float m_flLightSourceDim0; // 0x94
|
|
float m_flLightSourceDim1; // 0x98
|
|
float m_flLightSourceSize0; // 0x9c
|
|
float m_flLightSourceSize1; // 0xa0
|
|
float m_flPrecomputedMaxRange; // 0xa4
|
|
float m_flFogContributionStength; // 0xa8
|
|
float m_flNearClipPlane; // 0xac
|
|
Vector m_vecUp; // 0xc8
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCVSoundStackScriptList
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCChoreoSceneFileData
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class InfoForResourceTypeCMorphSetData
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 32
|
|
struct SheetFrameImage_t
|
|
{
|
|
public:
|
|
Vector2D[2] uvCropped; // 0x0
|
|
Vector2D[2] uvUncropped; // 0x10
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 56
|
|
struct RenderInputLayoutField_t
|
|
{
|
|
public:
|
|
uint8[32] m_pSemanticName; // 0x0
|
|
int32_t m_nSemanticIndex; // 0x20
|
|
uint32_t m_Format; // 0x24
|
|
int32_t m_nOffset; // 0x28
|
|
int32_t m_nSlot; // 0x2c
|
|
RenderSlotType_t m_nSlotType; // 0x30
|
|
int32_t m_nInstanceStepRate; // 0x34
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 12
|
|
struct SheetSequenceFrame_t
|
|
{
|
|
public:
|
|
float m_flDisplayTime; // 0x0
|
|
CResourceArray< SheetFrameImage_t > m_Images; // 0x4
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 8
|
|
struct Sheet_t
|
|
{
|
|
public:
|
|
CResourceArray< SheetSequence_t > m_Sequences; // 0x0
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 32
|
|
struct SheetSequence_t
|
|
{
|
|
public:
|
|
uint32_t m_nId; // 0x0
|
|
bool m_bClamp; // 0x4
|
|
bool m_bAlphaCrop; // 0x5
|
|
bool m_bNoColor; // 0x6
|
|
bool m_bNoAlpha; // 0x7
|
|
CResourceArray< SheetSequenceFrame_t > m_Frames; // 0x8
|
|
float m_flTotalTime; // 0x10
|
|
CResourceString m_name; // 0x14
|
|
CResourceArray< SequenceFloatParam_t > m_floatParams; // 0x18
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
struct VsInputSignature_t
|
|
{
|
|
public:
|
|
CUtlVector< VsInputSignatureElement_t > m_elems; // 0x0
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct SequenceFloatParam_t
|
|
{
|
|
public:
|
|
CResourceString m_name; // 0x0
|
|
float m_value; // 0x4
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 196
|
|
struct VsInputSignatureElement_t
|
|
{
|
|
public:
|
|
char[64] m_pName; // 0x0
|
|
char[64] m_pSemantic; // 0x40
|
|
char[64] m_pD3DSemanticName; // 0x80
|
|
int32_t m_nD3DSemanticIndex; // 0xc0
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 48
|
|
struct EventServerPollNetworking_t : public EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
struct EventClientProcessInput_t
|
|
{
|
|
public:
|
|
EngineLoopState_t m_LoopState; // 0x0
|
|
float m_flRealTime; // 0x28
|
|
float m_flFrameTime; // 0x2c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
struct EventClientPollNetworking_t
|
|
{
|
|
public:
|
|
int32_t m_nTickCount; // 0x0
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 40
|
|
struct EngineLoopState_t
|
|
{
|
|
public:
|
|
int32_t m_nPlatWindowWidth; // 0x18
|
|
int32_t m_nPlatWindowHeight; // 0x1c
|
|
int32_t m_nRenderWidth; // 0x20
|
|
int32_t m_nRenderHeight; // 0x24
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 112
|
|
struct EntComponentInfo_t
|
|
{
|
|
public:
|
|
V_uuid_t m_id; // 0x0
|
|
char* m_pName; // 0x10
|
|
char* m_pCPPClassname; // 0x18
|
|
char* m_pNetworkDataReferencedDescription; // 0x20
|
|
char* m_pNetworkDataReferencedPtrPropDescription; // 0x28
|
|
int32_t m_nRuntimeIndex; // 0x30
|
|
uint32_t m_nFlags; // 0x34
|
|
CEntityComponentHelper* m_pBaseClassComponentHelper; // 0x68
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 8
|
|
class CEmptyEntityInstance
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 48
|
|
struct EventServerProcessNetworking_t : public EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
struct EventSimulate_t
|
|
{
|
|
public:
|
|
EngineLoopState_t m_LoopState; // 0x0
|
|
bool m_bFirstTick; // 0x28
|
|
bool m_bLastTick; // 0x29
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 16
|
|
struct EntOutput_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 96
|
|
struct EventSetTime_t
|
|
{
|
|
public:
|
|
EngineLoopState_t m_LoopState; // 0x0
|
|
int32_t m_nClientOutputFrames; // 0x28
|
|
double m_flRealTime; // 0x30
|
|
double m_flRenderTime; // 0x38
|
|
double m_flRenderFrameTime; // 0x40
|
|
double m_flRenderFrameTimeUnbounded; // 0x48
|
|
double m_flRenderFrameTimeUnscaled; // 0x50
|
|
double m_flTickRemainder; // 0x58
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 64
|
|
struct EventServerAdvanceTick_t : public EventAdvanceTick_t, EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
struct EventClientSendInput_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
struct EventClientFrameSimulate_t
|
|
{
|
|
public:
|
|
EngineLoopState_t m_LoopState; // 0x0
|
|
float m_flRealTime; // 0x28
|
|
float m_flFrameTime; // 0x2c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 72
|
|
struct EventClientPreOutput_t
|
|
{
|
|
public:
|
|
EngineLoopState_t m_LoopState; // 0x0
|
|
double m_flRenderTime; // 0x28
|
|
double m_flRenderFrameTime; // 0x30
|
|
double m_flRenderFrameTimeUnbounded; // 0x38
|
|
bool m_bRenderOnly; // 0x40
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
struct EventModInitialized_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class CVariantDefaultAllocator
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 64
|
|
struct EventClientPostAdvanceTick_t : public EventPostAdvanceTick_t, EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
struct EventSplitScreenStateChanged_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 64
|
|
struct EventAdvanceTick_t : public EventSimulate_t
|
|
{
|
|
public:
|
|
int32_t m_nCurrentTick; // 0x30
|
|
int32_t m_nCurrentTickThisFrame; // 0x34
|
|
int32_t m_nTotalTicksThisFrame; // 0x38
|
|
int32_t m_nTotalTicks; // 0x3c
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
struct EventClientProcessNetworking_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 8
|
|
class IHandleEntity
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 112
|
|
class CEntityIdentity
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "entityIdentityNameChanged"
|
|
int32_t m_nameStringableIndex; // 0x14
|
|
CUtlSymbolLarge m_name; // 0x18
|
|
CUtlSymbolLarge m_designerName; // 0x20
|
|
uint32_t m_flags; // 0x28
|
|
uint32_t m_fDataObjectTypes; // 0x30
|
|
// MNetworkDisable
|
|
// MNetworkChangeAccessorFieldPathIndex
|
|
ChangeAccessorFieldPathIndex_t m_PathIndex; // 0x34
|
|
CEntityIdentity* m_pPrev; // 0x48
|
|
CEntityIdentity* m_pNext; // 0x50
|
|
CEntityIdentity* m_pPrevByClass; // 0x58
|
|
CEntityIdentity* m_pNextByClass; // 0x60
|
|
V_uuid_t* m_pId; // 0x68
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 48
|
|
struct EventClientPauseSimulate_t : public EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 48
|
|
struct EventClientPreSimulate_t : public EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
struct EventPostDataUpdate_t
|
|
{
|
|
public:
|
|
int32_t m_nCount; // 0x0
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
struct EventProfileStorageAvailable_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 64
|
|
struct EventServerPostAdvanceTick_t : public EventPostAdvanceTick_t, EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 48
|
|
struct EventServerSimulate_t : public EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
struct EventAppShutdown_t
|
|
{
|
|
public:
|
|
int32_t m_nDummy0; // 0x0
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
struct EventFrameBoundary_t
|
|
{
|
|
public:
|
|
float m_flFrameTime; // 0x0
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
struct EventClientProcessGameInput_t
|
|
{
|
|
public:
|
|
EngineLoopState_t m_LoopState; // 0x0
|
|
float m_flRealTime; // 0x28
|
|
float m_flFrameTime; // 0x2c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 8
|
|
struct EventPreDataUpdate_t
|
|
{
|
|
public:
|
|
int32_t m_nEntityIndex; // 0x0
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
struct EventClientPollInput_t
|
|
{
|
|
public:
|
|
EngineLoopState_t m_LoopState; // 0x0
|
|
float m_flRealTime; // 0x28
|
|
uint32_t m_nVRDisplayID; // 0x2c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 64
|
|
struct EventClientPostOutput_t
|
|
{
|
|
public:
|
|
EngineLoopState_t m_LoopState; // 0x0
|
|
double m_flRenderTime; // 0x28
|
|
float m_flRenderFrameTime; // 0x30
|
|
float m_flRenderFrameTimeUnbounded; // 0x34
|
|
bool m_bRenderOnly; // 0x38
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 48
|
|
struct EventClientSimulate_t : public EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
class CNetworkVarChainer
|
|
{
|
|
public:
|
|
// MNetworkDisable
|
|
// MNetworkChangeAccessorFieldPathIndex
|
|
ChangeAccessorFieldPathIndex_t m_PathIndex; // 0x8
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 48
|
|
struct EntInput_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 64
|
|
struct EventClientAdvanceTick_t : public EventAdvanceTick_t, EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 8
|
|
class CEntityComponent
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 40
|
|
class CEntityComponentHelper
|
|
{
|
|
public:
|
|
uint32_t m_flags; // 0x8
|
|
EntComponentInfo_t* m_pInfo; // 0x10
|
|
int32_t m_nPriority; // 0x18
|
|
CEntityComponentHelper* m_pNext; // 0x20
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 48
|
|
struct EventServerPostSimulate_t : public EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 56
|
|
struct EventClientOutput_t
|
|
{
|
|
public:
|
|
EngineLoopState_t m_LoopState; // 0x0
|
|
float m_flRenderTime; // 0x28
|
|
float m_flRealTime; // 0x2c
|
|
float m_flRenderFrameTimeUnbounded; // 0x30
|
|
bool m_bRenderOnly; // 0x34
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 1
|
|
struct EventClientSceneSystemThreadStateChange_t
|
|
{
|
|
public:
|
|
bool m_bThreadsActive; // 0x0
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 40
|
|
class CEntityIOOutput
|
|
{
|
|
public:
|
|
CVariantBase< CVariantDefaultAllocator > m_Value; // 0x18
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 64
|
|
struct EventPostAdvanceTick_t : public EventSimulate_t
|
|
{
|
|
public:
|
|
int32_t m_nCurrentTick; // 0x30
|
|
int32_t m_nCurrentTickThisFrame; // 0x34
|
|
int32_t m_nTotalTicksThisFrame; // 0x38
|
|
int32_t m_nTotalTicks; // 0x3c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
struct EventSimpleLoopFrameUpdate_t
|
|
{
|
|
public:
|
|
EngineLoopState_t m_LoopState; // 0x0
|
|
float m_flRealTime; // 0x28
|
|
float m_flFrameTime; // 0x2c
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 48
|
|
struct EventClientPostSimulate_t : public EventSimulate_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
struct MaterialParamTexture_t : public MaterialParam_t
|
|
{
|
|
public:
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_pValue; // 0x8
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
struct MaterialParamFloat_t : public MaterialParam_t
|
|
{
|
|
public:
|
|
float m_flValue; // 0x8
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 112
|
|
struct PostProcessingBloomParameters_t
|
|
{
|
|
public:
|
|
BloomBlendMode_t m_blendMode; // 0x0
|
|
float 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
|
|
float32[5] m_flBlurWeight; // 0x20
|
|
Vector[5] m_vBlurTint; // 0x34
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 304
|
|
struct MaterialResourceData_t
|
|
{
|
|
public:
|
|
CUtlString m_materialName; // 0x0
|
|
CUtlString m_shaderName; // 0x8
|
|
CUtlVector< MaterialParamInt_t > m_intParams; // 0x10
|
|
CUtlVector< MaterialParamFloat_t > m_floatParams; // 0x28
|
|
CUtlVector< MaterialParamVector_t > m_vectorParams; // 0x40
|
|
CUtlVector< MaterialParamTexture_t > m_textureParams; // 0x58
|
|
CUtlVector< MaterialParamBuffer_t > m_dynamicParams; // 0x70
|
|
CUtlVector< MaterialParamBuffer_t > m_dynamicTextureParams; // 0x88
|
|
CUtlVector< MaterialParamInt_t > m_intAttributes; // 0xa0
|
|
CUtlVector< MaterialParamFloat_t > m_floatAttributes; // 0xb8
|
|
CUtlVector< MaterialParamVector_t > m_vectorAttributes; // 0xd0
|
|
CUtlVector< MaterialParamTexture_t > m_textureAttributes; // 0xe8
|
|
CUtlVector< MaterialParamString_t > m_stringAttributes; // 0x100
|
|
CUtlVector< CUtlString > m_renderAttributesUsed; // 0x118
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 32
|
|
struct MaterialParamBuffer_t : public MaterialParam_t
|
|
{
|
|
public:
|
|
CUtlBinaryBlock m_value; // 0x8
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 32
|
|
struct PostProcessingTonemapParameters_t
|
|
{
|
|
public:
|
|
float 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
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 20
|
|
struct PostProcessingLocalContrastParameters_t
|
|
{
|
|
public:
|
|
float m_flLocalContrastStrength; // 0x0
|
|
float m_flLocalContrastEdgeStrength; // 0x4
|
|
float m_flLocalContrastVignetteStart; // 0x8
|
|
float m_flLocalContrastVignetteEnd; // 0xc
|
|
float m_flLocalContrastVignetteBlur; // 0x10
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 36
|
|
struct PostProcessingVignetteParameters_t
|
|
{
|
|
public:
|
|
float m_flVignetteStrength; // 0x0
|
|
Vector2D m_vCenter; // 0x4
|
|
float m_flRadius; // 0xc
|
|
float m_flRoundness; // 0x10
|
|
float m_flFeather; // 0x14
|
|
Vector m_vColorTint; // 0x18
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
struct MaterialParamInt_t : public MaterialParam_t
|
|
{
|
|
public:
|
|
int32_t m_nValue; // 0x8
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 248
|
|
struct PostProcessingResource_t
|
|
{
|
|
public:
|
|
bool m_bHasTonemapParams; // 0x0
|
|
PostProcessingTonemapParameters_t m_toneMapParams; // 0x4
|
|
bool m_bHasBloomParams; // 0x24
|
|
PostProcessingBloomParameters_t m_bloomParams; // 0x28
|
|
bool m_bHasVignetteParams; // 0x98
|
|
PostProcessingVignetteParameters_t m_vignetteParams; // 0x9c
|
|
bool m_bHasLocalContrastParams; // 0xc0
|
|
PostProcessingLocalContrastParameters_t m_localConstrastParams; // 0xc4
|
|
int32_t m_nColorCorrectionVolumeDim; // 0xd8
|
|
CUtlBinaryBlock m_colorCorrectionVolumeData; // 0xe0
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
struct MaterialParamString_t : public MaterialParam_t
|
|
{
|
|
public:
|
|
CUtlString m_value; // 0x8
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
struct MaterialParamVector_t : public MaterialParam_t
|
|
{
|
|
public:
|
|
Vector4D m_value; // 0x8
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 8
|
|
struct MaterialParam_t
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
class CAnimMorphDifference
|
|
{
|
|
public:
|
|
CBufferString m_name; // 0x0
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 120
|
|
class CAnimKeyData
|
|
{
|
|
public:
|
|
CBufferString m_name; // 0x0
|
|
CUtlVector< CAnimBone > m_boneArray; // 0x10
|
|
CUtlVector< CAnimUser > m_userArray; // 0x28
|
|
CUtlVector< CBufferString > m_morphArray; // 0x40
|
|
int32_t m_nChannelElements; // 0x58
|
|
CUtlVector< CAnimDataChannelDesc > m_dataChannelArray; // 0x60
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct IKSolverSettings_t
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Solver Type"
|
|
// MPropertyAttributeChoiceEnumName
|
|
// MPropertyAttrChangeCallback
|
|
IKSolverType m_SolverType; // 0x0
|
|
// MPropertyFriendlyName "Num Iterations "
|
|
// MPropertyAttrStateCallback
|
|
int32_t m_nNumIterations; // 0x4
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 112
|
|
class CAnimData
|
|
{
|
|
public:
|
|
CBufferString m_name; // 0x10
|
|
CUtlVector< CAnimDesc > m_animArray; // 0x20
|
|
CUtlVector< CAnimDecoder > m_decoderArray; // 0x38
|
|
int32_t m_nMaxUniqueFrameIndex; // 0x50
|
|
CUtlVector< CAnimFrameSegment > m_segmentArray; // 0x58
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 88
|
|
class CSolveIKChainAnimNodeChainData
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "IK Chain"
|
|
// MPropertyAttributeChoiceName "IKChain"
|
|
CUtlString m_IkChain; // 0x8
|
|
// MPropertyFriendlyName "Solver Setting Source"
|
|
// MPropertyAttributeChoiceEnumName
|
|
// MPropertyAttrChangeCallback
|
|
SolveIKChainAnimNodeSettingSource m_SolverSettingSource; // 0x10
|
|
// MPropertyFriendlyName "Override Solver Settings"
|
|
// MPropertyAutoExpandGroup
|
|
// MPropertyAttrStateCallback
|
|
IKSolverSettings_t m_OverrideSolverSettings; // 0x14
|
|
// MPropertyFriendlyName "Target Setting Source"
|
|
// MPropertyAttributeChoiceEnumName
|
|
// MPropertyAttrChangeCallback
|
|
SolveIKChainAnimNodeSettingSource m_TargetSettingSource; // 0x1c
|
|
// MPropertyFriendlyName "Override Target Settings"
|
|
// MPropertyAutoExpandGroup
|
|
// MPropertyAttrStateCallback
|
|
IKTargetSettings_t m_OverrideTargetSettings; // 0x20
|
|
// MPropertyFriendlyName "Debug Setting"
|
|
// MPropertyGroupName "Debug"
|
|
SolveIKChainAnimNodeDebugSetting m_DebugSetting; // 0x40
|
|
// MPropertyFriendlyName "Debug Normalized Length"
|
|
// MPropertyGroupName "Debug"
|
|
float m_flDebugNormalizedLength; // 0x44
|
|
// MPropertyFriendlyName "Debug Offset"
|
|
// MPropertyGroupName "Debug"
|
|
Vector m_vDebugOffset; // 0x48
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
class CAnimSequenceParams
|
|
{
|
|
public:
|
|
float m_flFadeInTime; // 0x0
|
|
float m_flFadeOutTime; // 0x4
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 80
|
|
class CPathHelperAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Stopping Radius"
|
|
float m_flStoppingRadius; // 0x48
|
|
// MPropertyFriendlyName "Stopping Min Speed Scale"
|
|
float m_flStoppingSpeedScale; // 0x4c
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 56
|
|
class CTimeRemainingMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Match Time Remaining"
|
|
// MPropertyGroupName
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bMatchByTimeRemaining; // 0x28
|
|
// MPropertyFriendlyName "Max Time Remaining"
|
|
// MPropertyAttrStateCallback
|
|
float m_flMaxTimeRemaining; // 0x2c
|
|
// MPropertyFriendlyName "Filter By Time Remaining"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bFilterByTimeRemaining; // 0x30
|
|
// MPropertyFriendlyName "Min Time Remaining"
|
|
// MPropertyAttrStateCallback
|
|
float m_flMinTimeRemaining; // 0x34
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 28
|
|
class CSeqAutoLayer
|
|
{
|
|
public:
|
|
int16_t m_nLocalReference; // 0x0
|
|
int16_t m_nLocalPose; // 0x2
|
|
CSeqAutoLayerFlag m_flags; // 0x4
|
|
float m_start; // 0xc
|
|
float m_peak; // 0x10
|
|
float m_tail; // 0x14
|
|
float m_end; // 0x18
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 48
|
|
class CClipProperties
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Name"
|
|
// MPropertyAttrStateCallback
|
|
CUtlString m_name; // 0x18
|
|
// MPropertyFriendlyName "Frame Count"
|
|
// MPropertyAttrStateCallback
|
|
int32_t m_frames; // 0x20
|
|
// MPropertyFriendlyName "Frame Rate"
|
|
// MPropertyAttrStateCallback
|
|
float m_flFrameRate; // 0x24
|
|
// MPropertyFriendlyName "Duration"
|
|
// MPropertyAttrStateCallback
|
|
float m_flDuration; // 0x28
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 152
|
|
class CBlend2DAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
CUtlVector< CBlend2DItem > m_items; // 0x50
|
|
// MPropertyFriendlyName "Horizontal Axis"
|
|
// MPropertyAttrChangeCallback
|
|
AnimValueSource m_blendSourceX; // 0x68
|
|
// MPropertyFriendlyName "Horizontal Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_paramX; // 0x6c
|
|
// MPropertyFriendlyName "Vertical Axis"
|
|
// MPropertyAttrChangeCallback
|
|
AnimValueSource m_blendSourceY; // 0x70
|
|
// MPropertyFriendlyName "Vertical Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_paramY; // 0x74
|
|
// MPropertyFriendlyName "Loop"
|
|
bool m_bLoop; // 0x78
|
|
// MPropertyFriendlyName "Lock Blend on Reset"
|
|
bool m_bLockBlendOnReset; // 0x79
|
|
// MPropertyFriendlyName "Lock Blend When Waning"
|
|
bool m_bLockWhenWaning; // 0x7a
|
|
// MPropertyFriendlyName "Playback Speed"
|
|
float m_playbackSpeed; // 0x7c
|
|
// MPropertyFriendlyName "Damping"
|
|
CAnimInputDamping m_damping; // 0x80
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 80
|
|
class CSpeedScaleAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
AnimParamID m_param; // 0x48
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 72
|
|
class CChoreoAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 168
|
|
class CAnimRetargetElementData
|
|
{
|
|
public:
|
|
int32_t m_nElementType; // 0x0
|
|
int32_t m_nGroupType; // 0x4
|
|
int32_t m_nChainType; // 0x8
|
|
int32_t m_nChainIndex; // 0xc
|
|
int32_t m_nChainInvIndex; // 0x10
|
|
int32_t m_nBoneIndex; // 0x14
|
|
CBufferString m_boneName; // 0x18
|
|
matrix3x4_t m_transform; // 0x28
|
|
matrix3x4_t m_invTransform; // 0x58
|
|
float m_flDistance; // 0x88
|
|
Vector m_vecMin; // 0x8c
|
|
Vector m_vecMax; // 0x98
|
|
float m_flMass; // 0xa4
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 64
|
|
class CControlValueCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
ControlValue m_sourceControlValue; // 0x28
|
|
int32_t m_comparisonValueType; // 0x2c
|
|
float m_comparisonFixedValue; // 0x30
|
|
ControlValue m_comparisonControlValue; // 0x34
|
|
AnimParamID m_comparisonParamID; // 0x38
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 32
|
|
struct IKTargetSettings_t
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Target Source"
|
|
// MPropertyAttributeChoiceEnumName
|
|
// MPropertyAttrChangeCallback
|
|
IKTargetSource m_TargetSource; // 0x0
|
|
// MPropertyFriendlyName "Bone"
|
|
// MPropertyAttrStateCallback
|
|
IKBoneNameAndIndex_t m_Bone; // 0x8
|
|
// MPropertyFriendlyName "Animgraph Position Parameter"
|
|
// MPropertyAttributeChoiceName "VectorParameter"
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_AnimgraphParameterNamePosition; // 0x18
|
|
// MPropertyFriendlyName "Target Coords"
|
|
// MPropertyAttrStateCallback
|
|
IKTargetCoordinateSystem m_TargetCoordSystem; // 0x1c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 40
|
|
class CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
float m_flWeight; // 0x20
|
|
};
|
|
|
|
// Aligment: 12
|
|
// Size: 160
|
|
class CAimMatrixAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x48
|
|
// MPropertyFriendlyName "Sequence"
|
|
// MPropertyAttributeChoiceName "Sequence"
|
|
CUtlString m_sequenceName; // 0x50
|
|
// MPropertyFriendlyName "Angle Increment"
|
|
float m_fAngleIncrement; // 0x58
|
|
// MPropertyFriendlyName "Can Look Straight Down"
|
|
bool m_bCanLookStraightDown; // 0x5c
|
|
// MPropertyFriendlyName "Target"
|
|
AnimVectorSource m_target; // 0x60
|
|
// MPropertyFriendlyName "Parameter"
|
|
// MPropertyAttributeChoiceName "VectorParameter"
|
|
AnimParamID m_param; // 0x64
|
|
// MPropertyFriendlyName "Aim Attachment"
|
|
// MPropertyAttributeChoiceName "Attachment"
|
|
CUtlString m_attachmentName; // 0x68
|
|
// MPropertyFriendlyName "Blend Mode"
|
|
AimMatrixBlendMode m_blendMode; // 0x70
|
|
// MPropertyFriendlyName "Bone Mask"
|
|
// MPropertyAttributeChoiceName "BoneMask"
|
|
CUtlString m_boneMaskName; // 0x78
|
|
// MPropertyFriendlyName "Reset Child"
|
|
bool m_bResetBase; // 0x80
|
|
// MPropertyFriendlyName "Lock Blend When Waning"
|
|
bool m_bLockWhenWaning; // 0x81
|
|
// MPropertyFriendlyName "Damping"
|
|
CAnimInputDamping m_damping; // 0x88
|
|
};
|
|
|
|
// Aligment: 24
|
|
// Size: 176
|
|
class CHitReactAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Minimum Delay Between Hits"
|
|
float m_flMinDelayBetweenHits; // 0x48
|
|
// MPropertyFriendlyName "Trigger Parameter"
|
|
// MPropertyAttributeChoiceName "BoolParameter"
|
|
AnimParamID m_triggerParam; // 0x4c
|
|
// MPropertyFriendlyName "Hit Bone Parameter"
|
|
// MPropertyAttributeChoiceName "IntParameter"
|
|
AnimParamID m_hitBoneParam; // 0x50
|
|
// MPropertyFriendlyName "Hit Offset Parameter"
|
|
// MPropertyAttributeChoiceName "VectorParameter"
|
|
AnimParamID m_hitOffsetParam; // 0x54
|
|
// MPropertyFriendlyName "Hit Direction Parameter"
|
|
// MPropertyAttributeChoiceName "VectorParameter"
|
|
AnimParamID m_hitDirectionParam; // 0x58
|
|
// MPropertyFriendlyName "Hit Strength Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
AnimParamID m_hitStrengthParam; // 0x5c
|
|
// MPropertyFriendlyName "Bone Weights"
|
|
// MPropertyAttributeChoiceName "BoneMask"
|
|
CUtlString m_weightListName; // 0x60
|
|
// MPropertyFriendlyName "Hip Bone"
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
CUtlString m_hipBoneName; // 0x68
|
|
// MPropertyFriendlyName "Hip Translation Scale"
|
|
float m_flHipBoneTranslationScale; // 0x70
|
|
// MPropertyFriendlyName "Number of bone effected"
|
|
int32_t m_nEffectedBoneCount; // 0x74
|
|
// MPropertyFriendlyName "Max Impact Force"
|
|
float m_flMaxImpactForce; // 0x78
|
|
// MPropertyFriendlyName "Min Impact Force"
|
|
float m_flMinImpactForce; // 0x7c
|
|
// MPropertyFriendlyName "Whip Impact Scale"
|
|
float m_flWhipImpactScale; // 0x80
|
|
// MPropertyFriendlyName "Counter Rotation Scale"
|
|
float m_flCounterRotationScale; // 0x84
|
|
// MPropertyFriendlyName "Distance Fade Scale"
|
|
float m_flDistanceFadeScale; // 0x88
|
|
// MPropertyFriendlyName "Propagation Scale"
|
|
float m_flPropagationScale; // 0x8c
|
|
// MPropertyFriendlyName "Whip Delay Time"
|
|
float m_flWhipDelay; // 0x90
|
|
// MPropertyFriendlyName "Spring Strength"
|
|
float m_flSpringStrength; // 0x94
|
|
// MPropertyFriendlyName "Whip Spring Strength"
|
|
float m_flWhipSpringStrength; // 0x98
|
|
// MPropertyFriendlyName "Hip Dip Spring Strength"
|
|
float m_flHipDipSpringStrength; // 0x9c
|
|
// MPropertyFriendlyName "Hip Dip Scale"
|
|
float m_flHipDipImpactScale; // 0xa0
|
|
// MPropertyFriendlyName "Hip Dip Delay Time"
|
|
float m_flHipDipDelay; // 0xa4
|
|
// MPropertyFriendlyName "Reset Child"
|
|
bool m_bResetBase; // 0xa8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 32
|
|
struct AnimationDecodeDebugDump_t
|
|
{
|
|
public:
|
|
AnimationProcessingType_t m_processingType; // 0x0
|
|
CUtlVector< AnimationDecodeDebugDumpElement_t > m_elems; // 0x8
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 72
|
|
class CDistanceRemainingMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Maximum Tracked Distance"
|
|
float m_flMaxDistance; // 0x28
|
|
// MPropertyFriendlyName "Filter By Fixed Distance"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bFilterFixedMinDistance; // 0x2c
|
|
// MPropertyFriendlyName "Min Distance"
|
|
// MPropertyAttrStateCallback
|
|
float m_flMinDistance; // 0x30
|
|
// MPropertyFriendlyName "Filter By Goal Distance"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bFilterGoalDistance; // 0x34
|
|
// MPropertyFriendlyName "Goal Filter Start Distance"
|
|
// MPropertyAttrStateCallback
|
|
float m_flStartGoalFilterDistance; // 0x38
|
|
// MPropertyFriendlyName "Filter By Goal Overshoot"
|
|
// MPropertyAttrChangeCallback
|
|
// MPropertyAttrStateCallback
|
|
bool m_bFilterGoalOvershoot; // 0x3c
|
|
// MPropertyFriendlyName "Max Goal Overshoot Scale"
|
|
// MPropertyAttrStateCallback
|
|
float m_flMaxGoalOvershootScale; // 0x40
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
class AnimParamID
|
|
{
|
|
public:
|
|
uint32_t m_id; // 0x0
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CBoneVelocityMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Bone"
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
CUtlString m_boneName; // 0x28
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 136
|
|
class CFollowPathAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Blend Out Time"
|
|
float m_flBlendOutTime; // 0x48
|
|
// MPropertyFriendlyName "Block Non-Path Movement"
|
|
bool m_bBlockNonPathMovement; // 0x4c
|
|
// MPropertyFriendlyName "Stop Feet at Goal"
|
|
bool m_bStopFeetAtGoal; // 0x4d
|
|
// MPropertyFriendlyName "Enable Speed Scaling"
|
|
// MPropertyGroupName "Speed Scaling"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bScaleSpeed; // 0x4e
|
|
// MPropertyFriendlyName "Scale"
|
|
// MPropertyGroupName "Speed Scaling"
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyAttrStateCallback
|
|
float m_flScale; // 0x50
|
|
// MPropertyFriendlyName "Min Angle"
|
|
// MPropertyGroupName "Speed Scaling"
|
|
// MPropertyAttributeRange "0 180"
|
|
// MPropertyAttrStateCallback
|
|
float m_flMinAngle; // 0x54
|
|
// MPropertyFriendlyName "Max Angle"
|
|
// MPropertyGroupName "Speed Scaling"
|
|
// MPropertyAttributeRange "0 180"
|
|
// MPropertyAttrStateCallback
|
|
float m_flMaxAngle; // 0x58
|
|
// MPropertyFriendlyName "Blend Time"
|
|
// MPropertyGroupName "Speed Scaling"
|
|
// MPropertyAttrStateCallback
|
|
float m_flSpeedScaleBlending; // 0x5c
|
|
// MPropertyFriendlyName "Enable Turn to Face"
|
|
// MPropertyGroupName "Turn to Face"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bTurnToFace; // 0x60
|
|
// MPropertyFriendlyName "Target"
|
|
// MPropertyGroupName "Turn to Face"
|
|
// MPropertyAttrChangeCallback
|
|
// MPropertyAttrStateCallback
|
|
AnimValueSource m_facingTarget; // 0x64
|
|
// MPropertyFriendlyName "Parameter"
|
|
// MPropertyGroupName "Turn to Face"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_param; // 0x68
|
|
// MPropertyFriendlyName "Offset"
|
|
// MPropertyGroupName "Turn to Face"
|
|
// MPropertyAttributeRange "-180 180"
|
|
// MPropertyAttrStateCallback
|
|
float m_flTurnToFaceOffset; // 0x6c
|
|
// MPropertyFriendlyName "Damping"
|
|
// MPropertyGroupName "Turn to Face"
|
|
// MPropertyAttrStateCallback
|
|
CAnimInputDamping m_damping; // 0x70
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 56
|
|
class CActivityValueList
|
|
{
|
|
public:
|
|
CUtlVector< CSmartPtr< CActivityValues > > m_activities; // 0x18
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 72
|
|
class CRagdollAnimTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Pose Control"
|
|
AnimPoseControl m_nPoseControl; // 0x30
|
|
// MPropertyFriendlyName "Frequency"
|
|
// MPropertyAttributeRange "0 30"
|
|
float m_flFrequency; // 0x34
|
|
// MPropertyFriendlyName "Damping Ratio"
|
|
// MPropertyAttributeRange "0 2"
|
|
float m_flDampingRatio; // 0x38
|
|
// MPropertyFriendlyName "Decay Duration"
|
|
// MPropertyAttributeRange "-1 1000"
|
|
float m_flDecayDuration; // 0x3c
|
|
// MPropertyFriendlyName "Decay Bias"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flDecayBias; // 0x40
|
|
// MPropertyFriendlyName "Destroy"
|
|
bool m_bDestroy; // 0x44
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 120
|
|
class CNeuralNetAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Weights File"
|
|
CUtlString m_weightsFile; // 0x40
|
|
// MPropertyFriendlyName "Test Input File"
|
|
CUtlString m_testInputFile; // 0x48
|
|
// MPropertyFriendlyName "Bone Map File"
|
|
CUtlString m_boneMapFile; // 0x50
|
|
// MPropertyFriendlyName "Sensor Range File"
|
|
CUtlString m_sensorRangeFile; // 0x58
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 56
|
|
class CBoolAnimParameter : public CAnimParameterBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Default Value"
|
|
bool m_bDefaultValue; // 0x30
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 24
|
|
class CBlendNodeChild
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x0
|
|
// MPropertyFriendlyName "Name"
|
|
CUtlString m_name; // 0x8
|
|
// MPropertyFriendlyName "Blend Value"
|
|
float m_blendValue; // 0x10
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 48
|
|
class CStringAnimTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CAnimParameterList
|
|
{
|
|
public:
|
|
CUtlVector< CSmartPtr< CAnimParameterBase > > m_Parameters; // 0x18
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 136
|
|
class CBlendAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Blend Items"
|
|
// MPropertyAutoExpandGroup
|
|
CUtlVector< CBlendNodeChild > m_children; // 0x48
|
|
// MPropertyFriendlyName "Blend Source"
|
|
// MPropertyAttrChangeCallback
|
|
AnimValueSource m_blendValueSource; // 0x60
|
|
// MPropertyFriendlyName "Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_param; // 0x64
|
|
// MPropertyFriendlyName "Blend Key Values"
|
|
BlendKeyType m_blendKeyType; // 0x68
|
|
// MPropertyFriendlyName "Lock Blend on Reset"
|
|
bool m_bLockBlendOnReset; // 0x6c
|
|
// MPropertyFriendlyName "Sync Cycles"
|
|
bool m_bSyncCycles; // 0x6d
|
|
// MPropertyFriendlyName "Loop"
|
|
bool m_bLoop; // 0x6e
|
|
// MPropertyFriendlyName "Lock Blend When Waning"
|
|
bool m_bLockWhenWaning; // 0x6f
|
|
// MPropertyFriendlyName "Damping"
|
|
CAnimInputDamping m_damping; // 0x70
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CFutureFacingMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Distance"
|
|
float m_flDistance; // 0x28
|
|
};
|
|
|
|
// Aligment: 12
|
|
// Size: 144
|
|
class CSeqCmdSeqDesc
|
|
{
|
|
public:
|
|
CBufferString m_sName; // 0x0
|
|
CSeqSeqDescFlag m_flags; // 0x10
|
|
CSeqTransition m_transition; // 0x1c
|
|
int16_t m_nFrameRangeSequence; // 0x24
|
|
int16_t m_nFrameCount; // 0x26
|
|
float m_flFPS; // 0x28
|
|
int16_t m_nSubCycles; // 0x2c
|
|
int16_t m_numLocalResults; // 0x2e
|
|
CUtlVector< CSeqCmdLayer > m_cmdLayerArray; // 0x30
|
|
CUtlVector< CAnimAnimEvent > m_eventArray; // 0x48
|
|
CUtlVector< CAnimActivity > m_activityArray; // 0x60
|
|
CUtlVector< CSeqPoseSetting > m_poseSettingArray; // 0x78
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 88
|
|
class CGroupInputAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "External Connections"
|
|
// MPropertyAutoExpandGroup
|
|
// MPropertyAttrStateCallback
|
|
CUtlVector< CConnectionProxyItem > m_proxyItems; // 0x40
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 40
|
|
class CAnimStateConditionBase
|
|
{
|
|
public:
|
|
uint8_t m_comparisonOp; // 0x20
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 80
|
|
class CAnimationGraphVisualizerPie : public CAnimationGraphVisualizerPrimitiveBase
|
|
{
|
|
public:
|
|
VectorAligned m_vWsCenter; // 0x10
|
|
VectorAligned m_vWsStart; // 0x20
|
|
VectorAligned m_vWsEnd; // 0x30
|
|
Color m_Color; // 0x40
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 88
|
|
class CGroupOutputAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "External Connections"
|
|
// MPropertyAutoExpandGroup
|
|
// MPropertyAttrStateCallback
|
|
CUtlVector< CConnectionProxyItem > m_proxyItems; // 0x40
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 432
|
|
class CAnimDesc
|
|
{
|
|
public:
|
|
CBufferString m_name; // 0x0
|
|
CAnimDesc_Flag m_flags; // 0x10
|
|
float fps; // 0x18
|
|
CAnimEncodedFrames m_Data; // 0x20
|
|
CUtlVector< CAnimMovement > m_movementArray; // 0xf8
|
|
CUtlVector< CAnimAnimEvent > m_eventArray; // 0x110
|
|
CUtlVector< CAnimActivity > m_activityArray; // 0x128
|
|
CUtlVector< CAnimLocalHierarchy > m_hierarchyArray; // 0x140
|
|
float framestalltime; // 0x158
|
|
Vector m_vecRootMin; // 0x15c
|
|
Vector m_vecRootMax; // 0x168
|
|
CUtlVector< Vector > m_vecBoneWorldMin; // 0x178
|
|
CUtlVector< Vector > m_vecBoneWorldMax; // 0x190
|
|
CAnimSequenceParams m_sequenceParams; // 0x1a8
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CAnimClipPropertiesManager
|
|
{
|
|
public:
|
|
CUtlVector< CSmartPtr< CClipProperties > > m_Clips; // 0x18
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 12
|
|
class CSeqIKLock
|
|
{
|
|
public:
|
|
float m_flPosWeight; // 0x0
|
|
float m_flAngleWeight; // 0x4
|
|
int16_t m_nLocalBone; // 0x8
|
|
bool m_bBonesOrientedAlongPositiveX; // 0xa
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 128
|
|
class CGroupAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
AnimNodeID m_inputNodeID; // 0x48
|
|
// MPropertyHideField
|
|
AnimNodeID m_outputNodeID; // 0x4c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 40
|
|
class CAnimGraphGeneralSettings : public CAnimGraphSettingsGroup
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Grid Snapping"
|
|
int32_t m_iGridSnap; // 0x20
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 64
|
|
class CFloatAnimParameter : public CAnimParameterBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Default Value"
|
|
float m_fDefaultValue; // 0x30
|
|
// MPropertyFriendlyName "Min Value"
|
|
float m_fMinValue; // 0x34
|
|
// MPropertyFriendlyName "Max Value"
|
|
float m_fMaxValue; // 0x38
|
|
// MPropertyFriendlyName "Interpolate"
|
|
bool m_bInterpolate; // 0x3c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CAnimGraphSettingsManager
|
|
{
|
|
public:
|
|
CUtlVector< CSmartPtr< CAnimGraphSettingsGroup > > m_settingsGroups; // 0x18
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CLookPitchCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Comparison Value"
|
|
float m_comparisonValue; // 0x2c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 56
|
|
class CPostGraphIKTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Blend Amount"
|
|
float m_flBlendAmount; // 0x30
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 24
|
|
class CSeqCmdLayer
|
|
{
|
|
public:
|
|
int16_t m_cmd; // 0x0
|
|
int16_t m_nLocalReference; // 0x2
|
|
int16_t m_nLocalBonemask; // 0x4
|
|
int16_t m_nDstResult; // 0x6
|
|
int16_t m_nSrcResult; // 0x8
|
|
bool m_bSpline; // 0xa
|
|
float m_flVar1; // 0xc
|
|
float m_flVar2; // 0x10
|
|
int16_t m_nLineNumber; // 0x14
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 64
|
|
class CAnimationGraphVisualizerAxis : public CAnimationGraphVisualizerPrimitiveBase
|
|
{
|
|
public:
|
|
CTransform m_xWsTransform; // 0x10
|
|
float m_flAxisSize; // 0x30
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 96
|
|
class CSubtractAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_baseInputConnection; // 0x40
|
|
// MPropertyHideField
|
|
CNodeConnection m_subtractInputConnection; // 0x48
|
|
// MPropertyFriendlyName "Timing Control"
|
|
// MPropertyAttrChangeCallback
|
|
BinaryNodeTiming m_timingBehavior; // 0x50
|
|
// MPropertyFriendlyName "Timing Blend"
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyAttrStateCallback
|
|
float m_flTimingBlend; // 0x54
|
|
// MPropertyFriendlyName "Foot Motion Timing"
|
|
BinaryNodeChildOption m_footMotionTiming; // 0x58
|
|
// MPropertyFriendlyName "Reset Base Child"
|
|
bool m_bResetBase; // 0x5c
|
|
// MPropertyFriendlyName "Reset Subtracted Child"
|
|
bool m_bResetSubtract; // 0x5d
|
|
// MPropertyFriendlyName "Treat Translation Separately"
|
|
bool m_bApplyChannelsSeparately; // 0x5e
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 88
|
|
class CPlayerInputAnimMotor : public CAnimMotorBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Sample Times"
|
|
CUtlVector< float32 > m_sampleTimes; // 0x28
|
|
// MPropertyFriendlyName "Use Acceleration"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bUseAcceleraion; // 0x40
|
|
// MPropertyFriendlyName "Spring Constant"
|
|
// MPropertyAttrStateCallback
|
|
float m_flSpringConstant; // 0x44
|
|
// MPropertyFriendlyName "Anticipation Distance"
|
|
float m_flAnticipationDistance; // 0x48
|
|
// MPropertyFriendlyName "Anticipation Position Parameter"
|
|
// MPropertyAttributeChoiceName "VectorParameter"
|
|
AnimParamID m_anticipationPosParam; // 0x4c
|
|
// MPropertyFriendlyName "Anticipation Heading Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
AnimParamID m_anticipationHeadingParam; // 0x50
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 88
|
|
class CWayPointHelperAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Start Cycle"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flStartCycle; // 0x48
|
|
// MPropertyFriendlyName "End Cycle"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flEndCycle; // 0x4c
|
|
// MPropertyFriendlyName "Only align to Goals"
|
|
bool m_bOnlyGoals; // 0x50
|
|
// MPropertyFriendlyName "Prevent Overshoot"
|
|
bool m_bPreventOvershoot; // 0x51
|
|
// MPropertyFriendlyName "Prevent Undershoot"
|
|
bool m_bPreventUndershoot; // 0x52
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 280
|
|
class CSeqS1SeqDesc
|
|
{
|
|
public:
|
|
CBufferString m_sName; // 0x0
|
|
CSeqSeqDescFlag m_flags; // 0x10
|
|
CSeqMultiFetch m_fetch; // 0x20
|
|
int32_t m_nLocalWeightlist; // 0x88
|
|
CUtlVector< CSeqAutoLayer > m_autoLayerArray; // 0x90
|
|
CUtlVector< CSeqIKLock > m_IKLockArray; // 0xa8
|
|
CSeqTransition m_transition; // 0xc0
|
|
KeyValues3 m_SequenceKeys; // 0xc8
|
|
CBufferString m_LegacyKeyValueText; // 0xd8
|
|
CUtlVector< CAnimActivity > m_activityArray; // 0xe8
|
|
CUtlVector< CFootMotion > m_footMotion; // 0x100
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
class CAnimationGraphVisualizerText : public CAnimationGraphVisualizerPrimitiveBase
|
|
{
|
|
public:
|
|
VectorAligned m_vWsPosition; // 0x10
|
|
Color m_Color; // 0x20
|
|
CUtlString m_Text; // 0x28
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 24
|
|
class CConnectionProxyItem
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Name"
|
|
CUtlString m_name; // 0x0
|
|
// MPropertyHideField
|
|
AnimOutputID m_outputID; // 0x8
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0xc
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
class CAnimationGraphVisualizerPrimitiveBase
|
|
{
|
|
public:
|
|
CAnimationGraphVisualizerPrimitiveType m_Type; // 0x8
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 128
|
|
class CBoneMaskAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Bone Mask"
|
|
// MPropertyAttributeChoiceName "BoneMask"
|
|
CUtlString m_weightListName; // 0x40
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection1; // 0x48
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection2; // 0x50
|
|
// MPropertyFriendlyName "Blend Space"
|
|
BoneMaskBlendSpace m_blendSpace; // 0x58
|
|
// MPropertyFriendlyName "Use Blend Source"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bUseBlendScale; // 0x5c
|
|
// MPropertyFriendlyName "Blend Source"
|
|
// MPropertyAttrChangeCallback
|
|
// MPropertyAttrStateCallback
|
|
AnimValueSource m_blendValueSource; // 0x60
|
|
// MPropertyFriendlyName "Blend Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_blendParameter; // 0x64
|
|
// MPropertyFriendlyName "Timing Control"
|
|
// MPropertyAttrChangeCallback
|
|
BinaryNodeTiming m_timingBehavior; // 0x68
|
|
// MPropertyFriendlyName "Timing Blend"
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyAttrStateCallback
|
|
float m_flTimingBlend; // 0x6c
|
|
// MPropertyFriendlyName "Root Motion Blend"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flRootMotionBlend; // 0x70
|
|
// MPropertyFriendlyName "Foot Motion Timing"
|
|
BinaryNodeChildOption m_footMotionTiming; // 0x74
|
|
// MPropertyFriendlyName "Reset Child1"
|
|
bool m_bResetChild1; // 0x78
|
|
// MPropertyFriendlyName "Reset Child2"
|
|
bool m_bResetChild2; // 0x79
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CMoveSpeedCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Comparison Value"
|
|
float m_comparisonValue; // 0x2c
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 104
|
|
class CAnimNodeManager
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 112
|
|
class CStateMachineAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
CUtlVector< CSmartPtr< CAnimState > > m_states; // 0x50
|
|
// MPropertyFriendlyName "Block Tags from Waning States"
|
|
bool m_bBlockWaningTags; // 0x68
|
|
// MPropertyFriendlyName "Lock State when Waning"
|
|
bool m_bLockStateWhenWaning; // 0x69
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 384
|
|
class CAnimationGroup
|
|
{
|
|
public:
|
|
uint32_t m_nFlags; // 0x10
|
|
CBufferString m_name; // 0x18
|
|
CUtlVector< CStrongHandle< InfoForResourceTypeCAnimData > > m_localHAnimArray_Handle; // 0x60
|
|
CUtlVector< CStrongHandle< InfoForResourceTypeCAnimationGroup > > m_includedGroupArray_Handle; // 0x78
|
|
CStrongHandle< InfoForResourceTypeCSequenceGroupData > m_directHSeqGroup_Handle; // 0x90
|
|
CAnimKeyData m_decodeKey; // 0x98
|
|
CAnimRetargetData m_retarget; // 0x110
|
|
CUtlVector< CBufferString > m_szScripts; // 0x160
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 56
|
|
class CAudioAnimTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Audio Clip"
|
|
// MPropertyAttributeEditor "SoundPicker"
|
|
CUtlString m_clipName; // 0x30
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 104
|
|
class CSeqMultiFetch
|
|
{
|
|
public:
|
|
CSeqMultiFetchFlag m_flags; // 0x0
|
|
CUtlVector< int16 > m_localReferenceArray; // 0x8
|
|
int32[2] m_nGroupSize; // 0x20
|
|
int32[2] m_nLocalPose; // 0x28
|
|
CUtlVector< float32 > m_poseKeyArray0; // 0x30
|
|
CUtlVector< float32 > m_poseKeyArray1; // 0x48
|
|
int32_t m_nLocalCyclePoseParameter; // 0x60
|
|
bool m_bCalculatePoseParameters; // 0x64
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 96
|
|
class CDampedPathAnimMotor : public CPathAnimMotorBase, CAnimMotorBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Anticipation Time"
|
|
float m_flAnticipationTime; // 0x48
|
|
// MPropertyFriendlyName "Anticipation Position Parameter"
|
|
// MPropertyAttributeChoiceName "VectorParameter"
|
|
AnimParamID m_anticipationPosParam; // 0x4c
|
|
// MPropertyFriendlyName "Anticipation Heading Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
AnimParamID m_anticipationHeadingParam; // 0x50
|
|
// MPropertyFriendlyName "Spring Constant"
|
|
// MPropertyGroupName "+Stopping:Arrival Damping"
|
|
float m_flSpringConstant; // 0x54
|
|
// MPropertyFriendlyName "Min Tension"
|
|
// MPropertyGroupName "+Stopping:Arrival Damping"
|
|
float m_flMinSpringTension; // 0x58
|
|
// MPropertyFriendlyName "Max Tension"
|
|
// MPropertyGroupName "+Stopping:Arrival Damping"
|
|
float m_flMaxSpringTension; // 0x5c
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 24
|
|
class CAnimUserDifference
|
|
{
|
|
public:
|
|
CBufferString m_name; // 0x0
|
|
int32_t m_nType; // 0x10
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
class CAnimationGraphVisualizerSphere : public CAnimationGraphVisualizerPrimitiveBase
|
|
{
|
|
public:
|
|
VectorAligned m_vWsPosition; // 0x10
|
|
float m_flRadius; // 0x20
|
|
Color m_Color; // 0x24
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
class CBlendCurve
|
|
{
|
|
public:
|
|
Vector2D m_vControlPoint1; // 0x0
|
|
Vector2D m_vControlPoint2; // 0x8
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 6
|
|
class CAnimDesc_Flag
|
|
{
|
|
public:
|
|
bool m_bLooping; // 0x0
|
|
bool m_bAllZeros; // 0x1
|
|
bool m_bHidden; // 0x2
|
|
bool m_bDelta; // 0x3
|
|
bool m_bLegacyWorldspace; // 0x4
|
|
bool m_bModelDoc; // 0x5
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 72
|
|
class CAnimationSubGraph
|
|
{
|
|
public:
|
|
CSmartPtr< CAnimNodeManager > m_nodeManager; // 0x8
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 72
|
|
class CClothSettingsAnimTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Stiffness"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flStiffness; // 0x30
|
|
// MPropertyFriendlyName "EaseIn"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flEaseIn; // 0x34
|
|
// MPropertyFriendlyName "EaseOut"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flEaseOut; // 0x38
|
|
// MPropertyFriendlyName "VertexSet"
|
|
CUtlString m_nVertexSet; // 0x40
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 24
|
|
class CChoiceNodeChild
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x0
|
|
// MPropertyFriendlyName "Name"
|
|
CUtlString m_name; // 0x8
|
|
// MPropertyFriendlyName "Weight"
|
|
float m_weight; // 0x10
|
|
// MPropertyFriendlyName "Blend Time"
|
|
float m_blendTime; // 0x14
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 56
|
|
class CFinishedCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
FinishedConditionOption m_option; // 0x28
|
|
bool m_bIsFinished; // 0x2c
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 64
|
|
class CActivityValues
|
|
{
|
|
public:
|
|
CUtlVector< CSmartPtr< CParameterValue > > m_values; // 0x18
|
|
CUtlString m_activityName; // 0x30
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 80
|
|
class CDirectPlaybackAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Finish Early"
|
|
bool m_bFinishEarly; // 0x48
|
|
// MPropertyFriendlyName "Reset Child On Finish"
|
|
bool m_bResetOnFinish; // 0x49
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 104
|
|
class CFootStepTriggerAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Tolerance"
|
|
float m_flTolerance; // 0x48
|
|
// MPropertyFriendlyName "Feet"
|
|
// MPropertyAutoExpandGroup
|
|
CUtlVector< CFootStepTriggerItem > m_items; // 0x50
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 24
|
|
class CAnimInputDamping
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Speed Function"
|
|
DampingSpeedFunction m_speedFunction; // 0x8
|
|
// MPropertyFriendlyName "Speed Scale"
|
|
float m_fSpeedScale; // 0xc
|
|
// MPropertyFriendlyName "Minimum Speed"
|
|
float m_fMinSpeed; // 0x10
|
|
// MPropertyFriendlyName "Maximum Tension"
|
|
float m_fMaxTension; // 0x14
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 40
|
|
class CAnimFrameSegment
|
|
{
|
|
public:
|
|
int32_t m_nUniqueFrameIndex; // 0x0
|
|
uint32_t m_nLocalElementMasks; // 0x4
|
|
int32_t m_nLocalChannel; // 0x8
|
|
CUtlBinaryBlock m_container; // 0x10
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
class AnimTagID
|
|
{
|
|
public:
|
|
uint32_t m_id; // 0x0
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 88
|
|
class CEnumAnimParameter : public CAnimParameterBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Default Value"
|
|
uint8_t m_defaultValue; // 0x38
|
|
// MPropertyFriendlyName "Values"
|
|
CUtlVector< CUtlString > m_enumOptions; // 0x40
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 80
|
|
class CFootstepLandedAnimTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Footstep Type"
|
|
FootstepLandedFootSoundType_t m_FootstepType; // 0x30
|
|
// MPropertyFriendlyName "Override Sound"
|
|
// MPropertyAttributeChoiceName "Sound"
|
|
CUtlString m_OverrideSoundName; // 0x38
|
|
// MPropertyFriendlyName "Debug Name"
|
|
CUtlString m_DebugAnimSourceString; // 0x40
|
|
// MPropertyFriendlyName "Bone Name"
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
CUtlString m_BoneName; // 0x48
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 72
|
|
class CRootAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 24
|
|
class CAnimDecoder
|
|
{
|
|
public:
|
|
CBufferString m_szName; // 0x0
|
|
int32_t m_nVersion; // 0x10
|
|
int32_t m_nType; // 0x14
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CBonePositionMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Bone"
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
CUtlString m_boneName; // 0x28
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 96
|
|
class CAddAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_baseInput; // 0x40
|
|
// MPropertyHideField
|
|
CNodeConnection m_additiveInput; // 0x48
|
|
// MPropertyFriendlyName "Timing Control"
|
|
// MPropertyAttrChangeCallback
|
|
BinaryNodeTiming m_timingBehavior; // 0x50
|
|
// MPropertyFriendlyName "Timing Blend"
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyAttrStateCallback
|
|
float m_flTimingBlend; // 0x54
|
|
// MPropertyFriendlyName "Foot Motion Timing"
|
|
BinaryNodeChildOption m_footMotionTiming; // 0x58
|
|
// MPropertyFriendlyName "Reset Base Child"
|
|
bool m_bResetBase; // 0x5c
|
|
// MPropertyFriendlyName "Reset Additive Child"
|
|
bool m_bResetAdditive; // 0x5d
|
|
// MPropertyFriendlyName "Treat Translation Separately"
|
|
bool m_bApplyChannelsSeparately; // 0x5e
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 64
|
|
class CBlend2DItem
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
CUtlVector< CSmartPtr< CAnimTagSpan > > m_tagSpans; // 0x10
|
|
// MPropertyFriendlyName "Sequence"
|
|
// MPropertyAttributeChoiceName "Sequence"
|
|
CUtlString m_sequenceName; // 0x28
|
|
// MPropertyFriendlyName "Blend Value"
|
|
Vector2D m_blendValue; // 0x30
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 160
|
|
class CSelectorAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
CUtlVector< CNodeConnection > m_children; // 0x48
|
|
// MPropertySuppressField
|
|
CUtlVector< AnimTagID > m_tags; // 0x60
|
|
// MPropertyFriendlyName "Selection Source"
|
|
// MPropertyAttrChangeCallback
|
|
SelectionSource_t m_selectionSource; // 0x78
|
|
// MPropertyFriendlyName "Bool Parameter"
|
|
// MPropertyAttributeChoiceName "BoolParameter"
|
|
// MPropertyAttrChangeCallback
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_boolParamID; // 0x7c
|
|
// MPropertyFriendlyName "Enum Parameter"
|
|
// MPropertyAttributeChoiceName "EnumParameter"
|
|
// MPropertyAttrChangeCallback
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_enumParamID; // 0x80
|
|
// MPropertyFriendlyName "Blend Duration"
|
|
float m_blendDuration; // 0x84
|
|
// MPropertyFriendlyName "Tag Behavior"
|
|
SelectorTagBehavior_t m_tagBehavior; // 0x88
|
|
// MPropertyFriendlyName "Reset On Change"
|
|
bool m_bResetOnChange; // 0x8c
|
|
// MPropertyFriendlyName "Start new option at same cycle"
|
|
bool m_bSyncCyclesOnChange; // 0x8d
|
|
// MPropertySuppressField
|
|
CBlendCurve m_blendCurve; // 0x90
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 96
|
|
class CAnimReplayFrame
|
|
{
|
|
public:
|
|
CUtlBinaryBlock m_instanceData; // 0x10
|
|
CTransform m_localToWorldTransform; // 0x30
|
|
float m_timeStamp; // 0x50
|
|
};
|
|
|
|
// Aligment: 24
|
|
// Size: 232
|
|
class CMotionMatchingAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
CUtlVector< CSmartPtr< CMotionClipGroup > > m_clipGroups; // 0x50
|
|
// MPropertySuppressField
|
|
CUtlVector< CSmartPtr< CMotionMetricBase > > m_metrics; // 0x68
|
|
// MPropertySuppressField
|
|
CBlendCurve m_blendCurve; // 0x80
|
|
// MPropertyFriendlyName "Prediction Time"
|
|
float m_flPredictionTime; // 0x90
|
|
// MPropertyFriendlyName "Sampling Method"
|
|
// MPropertyAttrChangeCallback
|
|
MotionSamplingMethod m_samplingMethod; // 0x94
|
|
// MPropertyFriendlyName "Sample Rate"
|
|
// MPropertyAttrStateCallback
|
|
float m_flSampleRate; // 0x98
|
|
// MPropertyFriendlyName "Search at fixed interval"
|
|
// MPropertyGroupName "Search Triggers"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bSearchAtInterval; // 0x9c
|
|
// MPropertyFriendlyName "Search Interval"
|
|
// MPropertyGroupName "Search Triggers"
|
|
// MPropertyAttrStateCallback
|
|
float m_flSearchInterval; // 0xa0
|
|
// MPropertyFriendlyName "Search on Steps"
|
|
// MPropertyGroupName "Search Triggers"
|
|
bool m_bSearchOnSteps; // 0xa4
|
|
// MPropertyFriendlyName "Search when tags change"
|
|
// MPropertyGroupName "Search Triggers"
|
|
bool m_bForceSearchWhenTagsChange; // 0xa5
|
|
// MPropertyFriendlyName "Search when clip ends"
|
|
// MPropertyGroupName "Search Triggers"
|
|
bool m_bSearchWhenClipEnds; // 0xa6
|
|
// MPropertyFriendlyName "Search when goal changes"
|
|
// MPropertyGroupName "Search Triggers"
|
|
bool m_bSearchWhenGoalChanges; // 0xa7
|
|
// MPropertyFriendlyName "Blend Time"
|
|
float m_flBlendTime; // 0xa8
|
|
// MPropertyFriendlyName "Selection Threshold"
|
|
float m_flSelectionThreshold; // 0xac
|
|
// MPropertyFriendlyName "Lock Clip When Waning"
|
|
bool m_bLockClipWhenWaning; // 0xb0
|
|
// MPropertyFriendlyName "Enable Goal Assist"
|
|
// MPropertyGroupName "Goal Assist"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bGoalAssist; // 0xb1
|
|
// MPropertyFriendlyName "Goal Assist Distance"
|
|
// MPropertyGroupName "Goal Assist"
|
|
// MPropertyAttrStateCallback
|
|
float m_flGoalAssistDistance; // 0xb4
|
|
// MPropertyFriendlyName "Goal Assist Tolerance"
|
|
// MPropertyGroupName "Goal Assist"
|
|
// MPropertyAttrStateCallback
|
|
float m_flGoalAssistTolerance; // 0xb8
|
|
// MPropertyFriendlyName "Enable Distance Scaling"
|
|
// MPropertyGroupName "Distance Scaling"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bEnableDistanceScaling; // 0xbc
|
|
// MPropertyFriendlyName "Outer Stopping Radius"
|
|
// MPropertyGroupName "Distance Scaling"
|
|
// MPropertyAttrStateCallback
|
|
float m_flDistanceScale_OuterRadius; // 0xc0
|
|
// MPropertyFriendlyName "Inner Stopping Radius"
|
|
// MPropertyGroupName "Distance Scaling"
|
|
// MPropertyAttrStateCallback
|
|
float m_flDistanceScale_InnerRadius; // 0xc4
|
|
// MPropertyFriendlyName "Maximum Speed Scale"
|
|
// MPropertyGroupName "Distance Scaling"
|
|
// MPropertyAttrStateCallback
|
|
float m_flDistanceScale_MaxScale; // 0xc8
|
|
// MPropertyFriendlyName "Minimum Speed Scale"
|
|
// MPropertyGroupName "Distance Scaling"
|
|
// MPropertyAttrStateCallback
|
|
float m_flDistanceScale_MinScale; // 0xcc
|
|
// MPropertyFriendlyName "Damping"
|
|
// MPropertyGroupName "Distance Scaling"
|
|
// MPropertyAttrStateCallback
|
|
CAnimInputDamping m_distanceScale_Damping; // 0xd0
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 72
|
|
class CAnimBone
|
|
{
|
|
public:
|
|
CBufferString m_name; // 0x0
|
|
int32_t m_parent; // 0x10
|
|
Vector m_pos; // 0x14
|
|
Quaternion m_quat; // 0x20
|
|
Quaternion m_qAlignment; // 0x30
|
|
int32_t m_flags; // 0x40
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 48
|
|
class CAnimRetargetChainData
|
|
{
|
|
public:
|
|
CBufferString m_sChainName; // 0x0
|
|
int32_t m_nGroupType; // 0x10
|
|
int32_t m_nChainType; // 0x14
|
|
CUtlVector< int32 > m_nElement; // 0x18
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 96
|
|
class CAnimStateTransition
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
CUtlVector< CSmartPtr< CAnimStateConditionBase > > m_conditions; // 0x20
|
|
// MPropertyFriendlyName "Blend Duration"
|
|
float m_blendDuration; // 0x38
|
|
// MPropertyHideField
|
|
AnimStateID m_destState; // 0x3c
|
|
// MPropertyFriendlyName "Reset Destination"
|
|
bool m_bReset; // 0x40
|
|
// MPropertyFriendlyName "Start Cycle At"
|
|
ResetCycleOption m_resetCycleOption; // 0x44
|
|
// MPropertyFriendlyName "Fixed Start Cycle Value"
|
|
float m_flFixedCycleValue; // 0x48
|
|
// MPropertySuppressField
|
|
CBlendCurve m_blendCurve; // 0x4c
|
|
// MPropertyFriendlyName "Park Feet"
|
|
bool m_bForceFootPlant; // 0x5c
|
|
// MPropertyFriendlyName "Disable"
|
|
bool m_bDisabled; // 0x5d
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 80
|
|
class CMotionClip
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
CUtlVector< CSmartPtr< CAnimTagSpan > > m_tagSpans; // 0x20
|
|
// MPropertyFriendlyName "Sequence"
|
|
// MPropertyAttributeChoiceName "Sequence"
|
|
CUtlString m_sequenceName; // 0x38
|
|
// MPropertyFriendlyName "Loop"
|
|
bool m_bLoop; // 0x40
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 72
|
|
class CAnimMovementManager
|
|
{
|
|
public:
|
|
CAnimMotorList m_MotorList; // 0x18
|
|
CAnimMovementSettings m_MovementSettings; // 0x38
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 288
|
|
class CSequenceGroupData
|
|
{
|
|
public:
|
|
CBufferString m_sName; // 0x10
|
|
uint32_t m_nFlags; // 0x20
|
|
CUtlVector< CBufferString > m_localSequenceNameArray; // 0x28
|
|
CUtlVector< CSeqS1SeqDesc > m_localS1SeqDescArray; // 0x40
|
|
CUtlVector< CSeqS1SeqDesc > m_localMultiSeqDescArray; // 0x58
|
|
CUtlVector< CSeqSynthAnimDesc > m_localSynthAnimDescArray; // 0x70
|
|
CUtlVector< CSeqCmdSeqDesc > m_localCmdSeqDescArray; // 0x88
|
|
CUtlVector< CSeqBoneMaskList > m_localBoneMaskArray; // 0xa0
|
|
CUtlVector< CBufferString > m_localBoneNameArray; // 0xb8
|
|
CBufferString m_localNodeName; // 0xd0
|
|
CUtlVector< CSeqPoseParamDesc > m_localPoseParamArray; // 0xe0
|
|
KeyValues3 m_keyValues; // 0xf8
|
|
CUtlVector< CSeqIKLock > m_localIKAutoplayLockArray; // 0x108
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 32
|
|
class CAnimMotorList
|
|
{
|
|
public:
|
|
CUtlVector< CSmartPtr< CAnimMotorBase > > m_motors; // 0x8
|
|
};
|
|
|
|
// Aligment: 16
|
|
// Size: 176
|
|
class CGroundIKSolveAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "IK Chains"
|
|
// MPropertyAttributeChoiceName "IKChainOld"
|
|
CUtlVector< CUtlString > m_IkChains; // 0x48
|
|
// MPropertyFriendlyName "Tilt Source"
|
|
// MPropertyAttributeChoiceEnumName
|
|
GroundIKTiltSource_t m_TiltSource; // 0x60
|
|
// MPropertyFriendlyName "Override Tilt Root"
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
CUtlString m_OverrideTiltRoot; // 0x68
|
|
// MPropertyFriendlyName "Tilt Attachment"
|
|
// MPropertyAttributeChoiceName "Attachment"
|
|
CUtlString m_TiltAttachment; // 0x70
|
|
// MPropertyFriendlyName "Override Tilt Spring Strength"
|
|
float m_flOverrideTiltSpringStrength; // 0x78
|
|
// MPropertyFriendlyName "Apply Locks"
|
|
bool m_bApplyLocks; // 0x7c
|
|
// MPropertyFriendlyName "Enabled"
|
|
bool m_bEnabled; // 0x7d
|
|
// MPropertyFriendlyName "Target Blend Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
AnimParamID m_TargetBlendParameter; // 0x80
|
|
// MPropertyGroupName "Debug"
|
|
// MPropertyFriendlyName "Debug Bone Types to Draw"
|
|
// MPropertyAttributeChoiceEnumName
|
|
CUtlVector< CGroundIKSolveAnimNode::DebugSkeletonBoneType_t > m_DebugDrawBoneTypes; // 0x88
|
|
// MPropertyGroupName "Debug"
|
|
// MPropertyFriendlyName "Debug Draw Lock Values"
|
|
bool m_bDebugDrawLockValues; // 0xa0
|
|
// MPropertyGroupName "Debug"
|
|
// MPropertyFriendlyName "Debug Lock Values Color"
|
|
Color m_DebugDrawLockValuesColor; // 0xa1
|
|
// MPropertyGroupName "Debug"
|
|
// MPropertyFriendlyName "Debug Draw Before"
|
|
bool m_bDebugDrawBefore; // 0xa5
|
|
// MPropertyGroupName "Debug"
|
|
// MPropertyFriendlyName "Debug Before IK Color"
|
|
Color m_DebugDrawBeforeColor; // 0xa6
|
|
// MPropertyGroupName "Debug"
|
|
// MPropertyFriendlyName "Debug Draw After"
|
|
bool m_bDebugDrawAfter; // 0xaa
|
|
// MPropertyGroupName "Debug"
|
|
// MPropertyFriendlyName "Debug After IK Color"
|
|
Color m_DebugDrawAfterColor; // 0xab
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 72
|
|
class CQuaternionAnimParameter : public CAnimParameterBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Default Value"
|
|
Quaternion m_defaultValue; // 0x30
|
|
// MPropertyFriendlyName "Interpolate"
|
|
bool m_bInterpolate; // 0x40
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 72
|
|
class CFootPositionMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Foot"
|
|
// MPropertyAttributeChoiceName "Foot"
|
|
// MPropertyAutoExpandGroup
|
|
CUtlVector< CUtlString > m_feet; // 0x28
|
|
// MPropertyFriendlyName "Ignore Slope"
|
|
bool m_bIgnoreSlope; // 0x40
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 48
|
|
class CAnimLocalHierarchy
|
|
{
|
|
public:
|
|
CBufferString m_sBone; // 0x0
|
|
CBufferString m_sNewParent; // 0x10
|
|
int32_t m_nStartFrame; // 0x20
|
|
int32_t m_nPeakFrame; // 0x24
|
|
int32_t m_nTailFrame; // 0x28
|
|
int32_t m_nEndFrame; // 0x2c
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 144
|
|
class CAnimDataChannelDesc
|
|
{
|
|
public:
|
|
CBufferString m_szChannelClass; // 0x0
|
|
CBufferString m_szVariableName; // 0x10
|
|
int32_t m_nFlags; // 0x20
|
|
int32_t m_nType; // 0x24
|
|
CBufferString m_szGrouping; // 0x28
|
|
CBufferString m_szDescription; // 0x38
|
|
CUtlVector< CBufferString > m_szElementNameArray; // 0x48
|
|
CUtlVector< int32 > m_nElementIndexArray; // 0x60
|
|
CUtlVector< uint32 > m_nElementMaskArray; // 0x78
|
|
};
|
|
|
|
// Aligment: 12
|
|
// Size: 144
|
|
class CAnimState
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
CUtlVector< CSmartPtr< CAnimStateTransition > > m_transitions; // 0x20
|
|
// MPropertySuppressField
|
|
CUtlVector< AnimTagID > m_tags; // 0x38
|
|
// MPropertySuppressField
|
|
CUtlVector< uint8 > m_tagBehaviors; // 0x50
|
|
// MPropertyFriendlyName "Name"
|
|
// MPropertySortPriority "100"
|
|
CUtlString m_name; // 0x68
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x70
|
|
// MPropertyHideField
|
|
AnimStateID m_stateID; // 0x78
|
|
// MPropertyHideField
|
|
Vector2D m_position; // 0x7c
|
|
// MPropertyFriendlyName "Start State"
|
|
bool m_bIsStartState; // 0x84
|
|
// MPropertyFriendlyName "End State"
|
|
bool m_bIsEndtState; // 0x85
|
|
// MPropertyFriendlyName "Passthrough"
|
|
bool m_bIsPassthrough; // 0x86
|
|
// MPropertyFriendlyName "Exclusive Root Motion"
|
|
bool m_bIsRootMotionExclusive; // 0x87
|
|
// MPropertyFriendlyName "Always Evaluate"
|
|
bool m_bAlwaysEvaluate; // 0x88
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 20
|
|
class CAnimIKRuleStallFrame
|
|
{
|
|
public:
|
|
int16_t chain; // 0x0
|
|
int16_t slot; // 0x2
|
|
float start; // 0x4
|
|
float peak; // 0x8
|
|
float tail; // 0xc
|
|
float end; // 0x10
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 72
|
|
class CPathAnimMotorBase : public CAnimMotorBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Facing Damping"
|
|
// MPropertySortPriority "90"
|
|
CAnimInputDamping m_facingDamping; // 0x28
|
|
// MPropertyFriendlyName "Lock To Path"
|
|
// MPropertySortPriority "90"
|
|
bool m_bLockToPath; // 0x40
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
class CBoneMergeModel
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CUtlString m_name; // 0x0
|
|
// MPropertyHideField
|
|
bool m_bEnabled; // 0x8
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 96
|
|
class CCommentAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
CUtlString m_commentText; // 0x48
|
|
// MPropertySuppressField
|
|
Vector2D m_size; // 0x50
|
|
// MPropertyFriendlyName "Color"
|
|
// MPropertyColorWithNoAlpha
|
|
Color m_color; // 0x58
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 112
|
|
class CMoverAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Generate Movement"
|
|
bool m_bApplyMovement; // 0x48
|
|
// MPropertyFriendlyName "Orient Movement"
|
|
bool m_bOrientMovement; // 0x49
|
|
// MPropertyFriendlyName "Additive"
|
|
bool m_bAdditive; // 0x4a
|
|
// MPropertyFriendlyName "Turn to Face"
|
|
bool m_bTurnToFace; // 0x4b
|
|
// MPropertyFriendlyName "Turn to Face Offset"
|
|
// MPropertyAttributeRange "-180 180"
|
|
float m_flTurnToFaceOffset; // 0x4c
|
|
// MPropertyFriendlyName "Face Direction"
|
|
AnimValueSource m_facingTarget; // 0x50
|
|
// MPropertyFriendlyName "Damping"
|
|
CAnimInputDamping m_damping; // 0x58
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 112
|
|
class CDirectionalBlendAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Sequence Names Prefix"
|
|
CUtlString m_animNamePrefix; // 0x40
|
|
// MPropertyFriendlyName "Blend Source"
|
|
// MPropertyAttrChangeCallback
|
|
AnimValueSource m_blendValueSource; // 0x48
|
|
// MPropertyFriendlyName "Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_param; // 0x4c
|
|
// MPropertyFriendlyName "Loop"
|
|
bool m_bLoop; // 0x50
|
|
// MPropertyFriendlyName "Lock Blend on Reset"
|
|
bool m_bLockBlendOnReset; // 0x51
|
|
// MPropertyFriendlyName "Playback Speed"
|
|
float m_playbackSpeed; // 0x54
|
|
// MPropertyFriendlyName "Damping"
|
|
CAnimInputDamping m_damping; // 0x58
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 44
|
|
class CAnimMovement
|
|
{
|
|
public:
|
|
int32_t endframe; // 0x0
|
|
int32_t motionflags; // 0x4
|
|
float v0; // 0x8
|
|
float v1; // 0xc
|
|
float angle; // 0x10
|
|
Vector vector; // 0x14
|
|
Vector position; // 0x20
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 32
|
|
class CSeqPoseParamDesc
|
|
{
|
|
public:
|
|
CBufferString m_sName; // 0x0
|
|
float m_flStart; // 0x10
|
|
float m_flEnd; // 0x14
|
|
float m_flLoop; // 0x18
|
|
bool m_bLooping; // 0x1c
|
|
};
|
|
|
|
// Aligment: 17
|
|
// Size: 416
|
|
class CCompressorGroup
|
|
{
|
|
public:
|
|
int32_t m_nTotalElementCount; // 0x0
|
|
CUtlVector< char* > m_szChannelClass; // 0x8
|
|
CUtlVector< char* > m_szVariableName; // 0x20
|
|
CUtlVector< fieldtype_t > m_nType; // 0x38
|
|
CUtlVector< int32 > m_nFlags; // 0x50
|
|
CUtlVector< CUtlString > m_szGrouping; // 0x68
|
|
CUtlVector< int32 > m_nCompressorIndex; // 0x80
|
|
CUtlVector< CUtlVector< char* > > m_szElementNames; // 0x98
|
|
CUtlVector< CUtlVector< int32 > > m_nElementUniqueID; // 0xb0
|
|
CUtlVector< uint32 > m_nElementMask; // 0xc8
|
|
CUtlVector< CCompressor< Vector >* > m_vectorCompressor; // 0xf8
|
|
CUtlVector< CCompressor< Quaternion >* > m_quaternionCompressor; // 0x110
|
|
CUtlVector< CCompressor< int32 >* > m_intCompressor; // 0x128
|
|
CUtlVector< CCompressor< bool >* > m_boolCompressor; // 0x140
|
|
CUtlVector< CCompressor< Color >* > m_colorCompressor; // 0x158
|
|
CUtlVector< CCompressor< Vector2D >* > m_vector2DCompressor; // 0x170
|
|
CUtlVector< CCompressor< Vector4D >* > m_vector4DCompressor; // 0x188
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 272
|
|
struct AnimationSnapshotBase_t
|
|
{
|
|
public:
|
|
float m_flRealTime; // 0x0
|
|
matrix3x4a_t m_rootToWorld; // 0x10
|
|
bool m_bBonesInWorldSpace; // 0x40
|
|
CUtlVector< uint32 > m_boneSetupMask; // 0x48
|
|
CUtlVector< matrix3x4a_t > m_boneTransforms; // 0x60
|
|
CUtlVector< float32 > m_flexControllers; // 0x78
|
|
AnimationSnapshotType_t m_SnapshotType; // 0x90
|
|
bool m_bHasDecodeDump; // 0x94
|
|
AnimationDecodeDebugDumpElement_t m_DecodeDump; // 0x98
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CLookHeadingCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Comparison Value"
|
|
float m_comparisonValue; // 0x2c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 56
|
|
class CAnimAnimEvent
|
|
{
|
|
public:
|
|
int32_t m_nFrame; // 0x0
|
|
float m_flCycle; // 0x4
|
|
KeyValues3 m_EventData; // 0x8
|
|
CBufferString m_sLegacyOptions; // 0x18
|
|
CBufferString m_sEventName; // 0x28
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 72
|
|
class CParticleAnimTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyAttributeEditor "AssetBrowse( vpcf )"
|
|
// MPropertyFriendlyName "Particle System"
|
|
CUtlString m_particleSystemName; // 0x30
|
|
// MPropertyFriendlyName "Configuration"
|
|
CUtlString m_configName; // 0x38
|
|
// MPropertyFriendlyName "Stop on Tag End"
|
|
bool m_bStopWhenTagEnds; // 0x40
|
|
// MPropertyFriendlyName "Tag End Stop is Instant"
|
|
bool m_bTagEndStopIsInstant; // 0x41
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 72
|
|
class CMotionClipGroup
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CUtlVector< CSmartPtr< CMotionClip > > m_clips; // 0x20
|
|
// MPropertyFriendlyName "Name"
|
|
CUtlString m_name; // 0x38
|
|
// MPropertyFriendlyName "Enable On Tag"
|
|
// MPropertyAttributeChoiceName "Tag"
|
|
AnimTagID m_tagID; // 0x40
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 64
|
|
class CCycleCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
float m_comparisonValue; // 0x28
|
|
int32_t m_comparisonValueType; // 0x2c
|
|
ControlValue m_comparisonControlValue; // 0x30
|
|
AnimParamID m_comparisonParamID; // 0x34
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 80
|
|
class CSlowDownOnSlopesAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Slow Down Strength"
|
|
// MPropertyAttributeRange "0.1 2"
|
|
float m_flSlowDownStrength; // 0x48
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
class CAnimMovementSettings
|
|
{
|
|
public:
|
|
bool m_bShouldCalculateSlope; // 0x8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 72
|
|
class CStepsRemainingMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Feet"
|
|
// MPropertyAttributeChoiceName "Foot"
|
|
// MPropertyAutoExpandGroup
|
|
CUtlVector< CUtlString > m_feet; // 0x28
|
|
// MPropertyFriendlyName "Min Steps Remaining"
|
|
float m_flMinStepsRemaining; // 0x40
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 64
|
|
class CPostGraphIKChainBlendTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Chain Name"
|
|
CUtlString m_ChainName; // 0x30
|
|
// MPropertyFriendlyName "Blend Amount on Enter"
|
|
float m_flBlendAmountOnEnter; // 0x38
|
|
// MPropertyFriendlyName "Blend Amount on Exit"
|
|
float m_flBlendAmountOnExit; // 0x3c
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 64
|
|
class CSeqSynthAnimDesc
|
|
{
|
|
public:
|
|
CBufferString m_sName; // 0x0
|
|
CSeqSeqDescFlag m_flags; // 0x10
|
|
CSeqTransition m_transition; // 0x1c
|
|
int16_t m_nLocalBaseReference; // 0x24
|
|
int16_t m_nLocalBoneMask; // 0x26
|
|
CUtlVector< CAnimActivity > m_activityArray; // 0x28
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 24
|
|
class CAnimUser
|
|
{
|
|
public:
|
|
CBufferString m_name; // 0x0
|
|
int32_t m_nType; // 0x10
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 64
|
|
class CInputStreamAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 152
|
|
class CSubGraphAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
AnimNodeID m_inputNodeID; // 0x48
|
|
// MPropertyHideField
|
|
AnimNodeID m_outputNodeID; // 0x4c
|
|
// MPropertyAttributeEditor "AssetBrowse( vsubgrph )"
|
|
// MPropertyFriendlyName "SubGraph File"
|
|
// MPropertyAttrChangeCallback
|
|
CUtlString m_subGraphFilename; // 0x70
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 96
|
|
class CFollowAttachmentAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Bone"
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
CUtlString m_boneName; // 0x48
|
|
// MPropertyFriendlyName "Target Attachment"
|
|
// MPropertyAttributeChoiceName "Attachment"
|
|
CUtlString m_attachmentName; // 0x50
|
|
// MPropertyFriendlyName "Match Translation"
|
|
bool m_bMatchTranslation; // 0x58
|
|
// MPropertyFriendlyName "Match Rotation"
|
|
bool m_bMatchRotation; // 0x59
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 64
|
|
class CAnimationGraphVisualizerLine : public CAnimationGraphVisualizerPrimitiveBase
|
|
{
|
|
public:
|
|
VectorAligned m_vWsPositionStart; // 0x10
|
|
VectorAligned m_vWsPositionEnd; // 0x20
|
|
Color m_Color; // 0x30
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 144
|
|
class CAnimationGraph
|
|
{
|
|
public:
|
|
CSmartPtr< CAnimNodeManager > m_nodeManager; // 0x8
|
|
CSmartPtr< CAnimParameterList > m_pParameterList; // 0x10
|
|
CSmartPtr< CAnimTagManager > m_pTagManager; // 0x18
|
|
CSmartPtr< CAnimMovementManager > m_pMovementManager; // 0x20
|
|
CSmartPtr< CAnimGraphSettingsManager > m_pSettingsManager; // 0x28
|
|
CSmartPtr< CActivityValueList > m_pActivityValuesList; // 0x40
|
|
CUtlVector< CUtlString > m_previewModels; // 0x48
|
|
CUtlVector< CBoneMergeModel > m_boneMergeModels; // 0x60
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 48
|
|
class CJiggleBoneItem
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Bone"
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
CUtlString m_boneName; // 0x0
|
|
// MPropertyFriendlyName "Spring Strength"
|
|
float m_flSpringStrength; // 0x8
|
|
// MPropertyFriendlyName "Sim Rate (FPS)"
|
|
float m_flSimRateFPS; // 0xc
|
|
// MPropertyFriendlyName "Damping"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flDamping; // 0x10
|
|
// MPropertyFriendlyName "Sim Space"
|
|
JiggleBoneSimSpace m_eSimSpace; // 0x14
|
|
// MPropertyFriendlyName "Max"
|
|
// MPropertyGroupName "Movement Limits"
|
|
Vector m_vBoundsMaxLS; // 0x18
|
|
// MPropertyFriendlyName "Min"
|
|
// MPropertyGroupName "Movement Limits"
|
|
Vector m_vBoundsMinLS; // 0x24
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 64
|
|
class CFootCycleMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Foot"
|
|
// MPropertyAttributeChoiceName "Foot"
|
|
// MPropertyAutoExpandGroup
|
|
CUtlVector< CUtlString > m_feet; // 0x28
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 80
|
|
class CSkeletalInputAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Data Source"
|
|
// MPropertyAttrChangeCallback
|
|
AnimVrBoneTransformSource_t m_transformSource; // 0x40
|
|
// MPropertyFriendlyName "Motion Range"
|
|
// MPropertyAttrStateCallback
|
|
AnimVRHandMotionRange_t m_motionRange; // 0x44
|
|
// MPropertyFriendlyName "Enable IK"
|
|
// MPropertyGroupName "+Retargetting"
|
|
bool m_bEnableIK; // 0x48
|
|
// MPropertyFriendlyName "Enable Collision"
|
|
// MPropertyGroupName "+Retargetting"
|
|
bool m_bEnableCollision; // 0x49
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
class AnimOutputID
|
|
{
|
|
public:
|
|
uint32_t m_id; // 0x0
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
class CNodeConnection
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
AnimNodeID m_nodeID; // 0x0
|
|
// MPropertySuppressField
|
|
AnimOutputID m_outputID; // 0x4
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 104
|
|
class CSolveIKChainAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x48
|
|
// MPropertyFriendlyName "IK Chains"
|
|
// MPropertyAutoExpandGroup
|
|
CUtlVector< CSolveIKChainAnimNodeChainData > m_IkChains; // 0x50
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 152
|
|
class CLookAtAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Target"
|
|
AnimVectorSource m_target; // 0x48
|
|
// MPropertyFriendlyName "Target Parameter"
|
|
// MPropertyAttributeChoiceName "VectorParameter"
|
|
AnimParamID m_param; // 0x4c
|
|
// MPropertyFriendlyName "Weight Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
AnimParamID m_weightParam; // 0x50
|
|
// MPropertyFriendlyName "LookAt Chain"
|
|
// MPropertyAttributeChoiceName "LookAtChain"
|
|
CUtlString m_lookatChainName; // 0x58
|
|
// MPropertyFriendlyName "Aim Attachment"
|
|
// MPropertyAttributeChoiceName "Attachment"
|
|
CUtlString m_attachmentName; // 0x60
|
|
// MPropertyFriendlyName "Yaw Limit"
|
|
// MPropertyAttributeRange "0 180"
|
|
float m_flYawLimit; // 0x68
|
|
// MPropertyFriendlyName "Pitch Limit"
|
|
// MPropertyAttributeRange "0 180"
|
|
float m_flPitchLimit; // 0x6c
|
|
// MPropertyFriendlyName "Reset Child"
|
|
bool m_bResetBase; // 0x70
|
|
// MPropertyFriendlyName "Lock Blend When Waning"
|
|
bool m_bLockWhenWaning; // 0x71
|
|
// MPropertyFriendlyName "Use Hysteresis"
|
|
// MPropertyGroupName "Hysteresis"
|
|
bool m_bUseHysteresis; // 0x72
|
|
// MPropertyFriendlyName "Inner Angle"
|
|
// MPropertyGroupName "Hysteresis"
|
|
float m_flHysteresisInnerAngle; // 0x74
|
|
// MPropertyFriendlyName "Outer Angle"
|
|
// MPropertyGroupName "Hysteresis"
|
|
float m_flHysteresisOuterAngle; // 0x78
|
|
// MPropertyFriendlyName "Damping"
|
|
CAnimInputDamping m_damping; // 0x80
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 56
|
|
class CTagCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Tag"
|
|
// MPropertyAttributeChoiceName "Tag"
|
|
AnimTagID m_tagID; // 0x28
|
|
// MPropertyFriendlyName "Value"
|
|
bool m_comparisonValue; // 0x2c
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 96
|
|
class CJiggleBoneAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Jiggle Bones"
|
|
// MPropertyAutoExpandGroup
|
|
CUtlVector< CJiggleBoneItem > m_items; // 0x48
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 40
|
|
class CFootStepTriggerItem
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Foot"
|
|
// MPropertyAttributeChoiceName "Foot"
|
|
CUtlString m_footName; // 0x0
|
|
// MPropertyFriendlyName "Trigger Phase"
|
|
StepPhase m_triggerPhase; // 0x8
|
|
// MPropertyFriendlyName "Tags"
|
|
// MPropertyAttributeChoiceName "Tag"
|
|
CUtlVector< AnimTagID > m_tags; // 0x10
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 56
|
|
class CFootFallAnimTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Foot"
|
|
FootFallTagFoot_t m_foot; // 0x30
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 40
|
|
class CAnimMotorBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Name"
|
|
// MPropertySortPriority "100"
|
|
CUtlString m_name; // 0x18
|
|
// MPropertyHideField
|
|
bool m_bDefault; // 0x20
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CAnimTagManager
|
|
{
|
|
public:
|
|
CUtlVector< CSmartPtr< CAnimTagBase > > m_tags; // 0x18
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 48
|
|
class CAnimBoneDifference
|
|
{
|
|
public:
|
|
CBufferString m_name; // 0x0
|
|
CBufferString m_parent; // 0x10
|
|
Vector m_posError; // 0x20
|
|
bool m_bHasRotation; // 0x2c
|
|
bool m_bHasMovement; // 0x2d
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 112
|
|
class CStopAtGoalAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Outer Stopping Radius"
|
|
float m_flOuterRadius; // 0x48
|
|
// MPropertyFriendlyName "Inner Stopping Radius"
|
|
float m_flInnerRadius; // 0x4c
|
|
// MPropertyFriendlyName "Maximum Speed Scale"
|
|
float m_flMaxScale; // 0x50
|
|
// MPropertyFriendlyName "Minimum Speed Scale"
|
|
float m_flMinScale; // 0x54
|
|
// MPropertyFriendlyName "Damping"
|
|
CAnimInputDamping m_damping; // 0x58
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 56
|
|
class CPathStatusCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
PathStatusOptions m_optionToCheck; // 0x28
|
|
bool m_bComparisonValue; // 0x2c
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 6
|
|
class CSeqMultiFetchFlag
|
|
{
|
|
public:
|
|
bool m_bRealtime; // 0x0
|
|
bool m_bCylepose; // 0x1
|
|
bool m_b0D; // 0x2
|
|
bool m_b1D; // 0x3
|
|
bool m_b2D; // 0x4
|
|
bool m_b2D_TRI; // 0x5
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CFacingHeadingCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Comparison Value"
|
|
float m_comparisonValue; // 0x2c
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 72
|
|
class CParameterAnimCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Parameter"
|
|
// MPropertyAttributeChoiceName "Parameter"
|
|
AnimParamID m_paramID; // 0x28
|
|
// MPropertyFriendlyName "Comparison Value"
|
|
CAnimVariant m_comparisonValue; // 0x2c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
class CAnimTagSpan
|
|
{
|
|
public:
|
|
AnimTagID m_id; // 0x20
|
|
float m_fStartCycle; // 0x24
|
|
float m_fDuration; // 0x28
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 72
|
|
class CPathAnimMotor : public CPathAnimMotorBase, CAnimMotorBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 40
|
|
class CAnimNodeList
|
|
{
|
|
public:
|
|
CUtlVector< CAnimNodeBase* > m_nodes; // 0x10
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 120
|
|
class CSequenceAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
CUtlVector< CSmartPtr< CAnimTagSpan > > m_tagSpans; // 0x50
|
|
// MPropertyFriendlyName "Sequence"
|
|
// MPropertyAttributeChoiceName "Sequence"
|
|
CUtlString m_sequenceName; // 0x68
|
|
// MPropertyFriendlyName "Playback Speed"
|
|
float m_playbackSpeed; // 0x70
|
|
// MPropertyFriendlyName "Loop"
|
|
bool m_bLoop; // 0x74
|
|
};
|
|
|
|
// Aligment: 36
|
|
// Size: 296
|
|
class CFootLockAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Feet"
|
|
// MPropertyAutoExpandGroup
|
|
CUtlVector< CFootLockItem > m_items; // 0x48
|
|
// MPropertyFriendlyName "Hip Bone"
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
CUtlString m_hipBoneName; // 0x60
|
|
// MPropertyFriendlyName "Blend Time"
|
|
float m_flBlendTime; // 0x68
|
|
// MPropertyFriendlyName "Apply Foot Rotation Limits"
|
|
bool m_bApplyFootRotationLimits; // 0x6c
|
|
// MPropertyFriendlyName "Reset Child"
|
|
bool m_bResetChild; // 0x6d
|
|
// MPropertyFriendlyName "IK Solver Type"
|
|
// MPropertyGroupName "IK"
|
|
// MPropertyAttrChangeCallback
|
|
IKSolverType m_ikSolverType; // 0x70
|
|
// MPropertyFriendlyName "Always use fallback hinge"
|
|
// MPropertyGroupName "IK"
|
|
// MPropertyAttrStateCallback
|
|
bool m_bAlwaysUseFallbackHinge; // 0x74
|
|
// MPropertyFriendlyName "Curve Foot Paths"
|
|
// MPropertyGroupName "Curve Paths"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flStrideCurveScale; // 0x78
|
|
// MPropertyFriendlyName "Curve Paths Limit"
|
|
// MPropertyGroupName "Curve Paths"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flStrideCurveLimitScale; // 0x7c
|
|
// MPropertyFriendlyName "Enable Vertical Curved Paths"
|
|
// MPropertyGroupName "Curve Paths"
|
|
bool m_bEnableVerticalCurvedPaths; // 0x80
|
|
// MPropertyFriendlyName "Modulate Step Height"
|
|
// MPropertyGroupName "Step Height"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bModulateStepHeight; // 0x81
|
|
// MPropertyFriendlyName "Height Increase Scale"
|
|
// MPropertyGroupName "Step Height"
|
|
// MPropertyAttrStateCallback
|
|
float m_flStepHeightIncreaseScale; // 0x84
|
|
// MPropertyFriendlyName "Height Decrease Scale"
|
|
// MPropertyGroupName "Step Height"
|
|
// MPropertyAttrStateCallback
|
|
float m_flStepHeightDecreaseScale; // 0x88
|
|
// MPropertyFriendlyName "Enable Hip Shift"
|
|
// MPropertyGroupName "Hip Shift"
|
|
bool m_bEnableHipShift; // 0x8c
|
|
// MPropertyFriendlyName "Hip Shift Scale"
|
|
// MPropertyGroupName "Hip Shift"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flHipShiftScale; // 0x90
|
|
// MPropertyFriendlyName "Damping"
|
|
// MPropertyGroupName "Hip Shift"
|
|
CAnimInputDamping m_hipShiftDamping; // 0x98
|
|
// MPropertyFriendlyName "Apply Tilt"
|
|
// MPropertyGroupName "Tilt"
|
|
bool m_bApplyTilt; // 0xb0
|
|
// MPropertyFriendlyName "Tilt Plane Pitch Spring Strength"
|
|
// MPropertyGroupName "Tilt"
|
|
float m_flTiltPlanePitchSpringStrength; // 0xb4
|
|
// MPropertyFriendlyName "Tilt Plane Roll Spring Strength"
|
|
// MPropertyGroupName "Tilt"
|
|
float m_flTiltPlaneRollSpringStrength; // 0xb8
|
|
// MPropertyFriendlyName "Enable Lock Breaking"
|
|
// MPropertyGroupName "Lock Breaking"
|
|
bool m_bEnableLockBreaking; // 0xbc
|
|
// MPropertyFriendlyName "Tolerance"
|
|
// MPropertyGroupName "Lock Breaking"
|
|
float m_flLockBreakTolerance; // 0xc0
|
|
// MPropertyFriendlyName "Blend Time"
|
|
// MPropertyGroupName "Lock Breaking"
|
|
float m_flLockBreakBlendTime; // 0xc4
|
|
// MPropertyFriendlyName "Enable Stretching"
|
|
// MPropertyGroupName "Stretch"
|
|
bool m_bEnableStretching; // 0xc8
|
|
// MPropertyFriendlyName "Max Stretch Amount"
|
|
// MPropertyGroupName "Stretch"
|
|
float m_flMaxStretchAmount; // 0xcc
|
|
// MPropertyFriendlyName "Extension Scale"
|
|
// MPropertyGroupName "Stretch"
|
|
// MPropertyAttributeRange "0 1"
|
|
float m_flStretchExtensionScale; // 0xd0
|
|
// MPropertyFriendlyName "Enable Ground Tracing"
|
|
// MPropertyGroupName "Ground IK"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bEnableGroundTracing; // 0xd4
|
|
// MPropertyFriendlyName "Angle Traces with Slope"
|
|
// MPropertyGroupName "Ground IK"
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyAttrStateCallback
|
|
float m_flTraceAngleBlend; // 0xd8
|
|
// MPropertyFriendlyName "Apply Hip Drop"
|
|
// MPropertyGroupName "Ground IK"
|
|
// MPropertyAttrChangeCallback
|
|
// MPropertyAttrStateCallback
|
|
bool m_bApplyHipDrop; // 0xdc
|
|
// MPropertyFriendlyName "Max Foot Lift"
|
|
// MPropertyGroupName "Ground IK"
|
|
// MPropertyAttrStateCallback
|
|
float m_flMaxFootHeight; // 0xe0
|
|
// MPropertyFriendlyName "Leg Extension Scale"
|
|
// MPropertyGroupName "Ground IK"
|
|
// MPropertyAttrStateCallback
|
|
float m_flExtensionScale; // 0xe4
|
|
// MPropertyFriendlyName "Hip Damping"
|
|
// MPropertyGroupName "Ground IK"
|
|
// MPropertyAttrStateCallback
|
|
CAnimInputDamping m_hipDampingSettings; // 0xe8
|
|
// MPropertyFriendlyName "Enable Root Height Damping"
|
|
// MPropertyGroupName "Root Height Damping"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bEnableRootHeightDamping; // 0x100
|
|
// MPropertyFriendlyName "Damping Settings"
|
|
// MPropertyGroupName "Root Height Damping"
|
|
// MPropertyAttrStateCallback
|
|
CAnimInputDamping m_rootHeightDamping; // 0x108
|
|
// MPropertyFriendlyName "Max Offset"
|
|
// MPropertyGroupName "Root Height Damping"
|
|
// MPropertyAttrStateCallback
|
|
float m_flMaxRootHeightOffset; // 0x120
|
|
// MPropertyFriendlyName "Min Offset"
|
|
// MPropertyGroupName "Root Height Damping"
|
|
// MPropertyAttrStateCallback
|
|
float m_flMinRootHeightOffset; // 0x124
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CTimeCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Value"
|
|
float m_comparisonValue; // 0x28
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 120
|
|
class CSingleFrameAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Sequence"
|
|
// MPropertyAttributeChoiceName "Sequence"
|
|
CUtlString m_sequenceName; // 0x50
|
|
// MPropertyFriendlyName "Frame"
|
|
int32_t m_nFrameIndex; // 0x58
|
|
// MPropertySuppressField
|
|
CUtlVector< CSmartPtr< CAnimTagSpan > > m_tagSpans; // 0x60
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 136
|
|
class CTwoBoneIKAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "IK Chain"
|
|
// MPropertyAttributeChoiceName "IKChain"
|
|
CUtlString m_ikChainName; // 0x48
|
|
// MPropertyGroupName "End Effector"
|
|
// MPropertyFriendlyName "End Effector Type"
|
|
// MPropertyAttrChangeCallback
|
|
IkEndEffectorType m_endEffectorType; // 0x50
|
|
// MPropertyGroupName "End Effector"
|
|
// MPropertyFriendlyName "Attachment"
|
|
// MPropertyAttributeChoiceName "Attachment"
|
|
// MPropertyAttrStateCallback
|
|
CUtlString m_endEffectorAttachmentName; // 0x58
|
|
// MPropertyGroupName "Target"
|
|
// MPropertyFriendlyName "Target Type"
|
|
// MPropertyAttrChangeCallback
|
|
IkTargetType m_targetType; // 0x60
|
|
// MPropertyGroupName "Target"
|
|
// MPropertyFriendlyName "Attachment"
|
|
// MPropertyAttributeChoiceName "Attachment"
|
|
// MPropertyAttrStateCallback
|
|
CUtlString m_attachmentName; // 0x68
|
|
// MPropertyGroupName "Target"
|
|
// MPropertyFriendlyName "Bone"
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
// MPropertyAttrStateCallback
|
|
CUtlString m_targetBoneName; // 0x70
|
|
// MPropertyGroupName "Target"
|
|
// MPropertyFriendlyName "Position Parameter"
|
|
// MPropertyAttributeChoiceName "VectorParameter"
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_targetParam; // 0x78
|
|
// MPropertyGroupName "Target"
|
|
// MPropertyFriendlyName "Match Target Orientation"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bMatchTargetOrientation; // 0x7c
|
|
// MPropertyGroupName "Target"
|
|
// MPropertyFriendlyName "Rotation Parameter"
|
|
// MPropertyAttributeChoiceName "QuaternionParameter"
|
|
// MPropertyAttrStateCallback
|
|
AnimParamID m_rotationParam; // 0x80
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 120
|
|
class CChoiceAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Options"
|
|
// MPropertyAutoExpandGroup
|
|
CUtlVector< CChoiceNodeChild > m_children; // 0x48
|
|
// MPropertyHideField
|
|
int32_t m_seed; // 0x60
|
|
// MPropertyFriendlyName "Method"
|
|
ChoiceMethod m_choiceMethod; // 0x64
|
|
// MPropertyFriendlyName "Change Selection"
|
|
ChoiceChangeMethod m_choiceChangeMethod; // 0x68
|
|
// MPropertyGroupName "Blending"
|
|
// MPropertyFriendlyName "Blend Method"
|
|
// MPropertyAttrChangeCallback
|
|
ChoiceBlendMethod m_blendMethod; // 0x6c
|
|
// MPropertyGroupName "Blending"
|
|
// MPropertyFriendlyName "Blend Duration"
|
|
// MPropertyAttrStateCallback
|
|
float m_blendTime; // 0x70
|
|
// MPropertyGroupName "Blending"
|
|
// MPropertyFriendlyName "Cross Fade"
|
|
bool m_bCrossFade; // 0x74
|
|
// MPropertyFriendlyName "Reset On Selection"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bResetChosen; // 0x75
|
|
// MPropertyFriendlyName "Don't Reset Same Selection"
|
|
// MPropertyAttrStateCallback
|
|
bool m_bDontResetSameSelection; // 0x76
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 56
|
|
class CFutureVelocityMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Distance"
|
|
float m_flDistance; // 0x28
|
|
// MPropertyFriendlyName "Stopping Distance"
|
|
float m_flStoppingDistance; // 0x2c
|
|
// MPropertyFriendlyName "Ignore Direction"
|
|
bool m_bIgnoreDirection; // 0x30
|
|
// MPropertyFriendlyName "Auto-Calculate target speed"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bAutoTargetSpeed; // 0x31
|
|
// MPropertyFriendlyName "Target Speed"
|
|
// MPropertyAttrStateCallback
|
|
float m_flManualTargetSpeed; // 0x34
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 64
|
|
class CSeqPoseSetting
|
|
{
|
|
public:
|
|
CBufferString m_sPoseParameter; // 0x0
|
|
CBufferString m_sAttachment; // 0x10
|
|
CBufferString m_sReferenceSequence; // 0x20
|
|
float m_flValue; // 0x30
|
|
bool m_bX; // 0x34
|
|
bool m_bY; // 0x35
|
|
bool m_bZ; // 0x36
|
|
int32_t m_eType; // 0x38
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 80
|
|
class CPathMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Distance"
|
|
float m_flDistance; // 0x28
|
|
// MPropertyFriendlyName "Samples Times"
|
|
CUtlVector< float32 > m_pathSamples; // 0x30
|
|
// MPropertyFriendlyName "Extrapolate Movement"
|
|
// MPropertyAttrChangeCallback
|
|
bool m_bExtrapolateMovement; // 0x48
|
|
// MPropertyFriendlyName "Min Extrapolation Speed"
|
|
// MPropertyAttrStateCallback
|
|
float m_flMinExtrapolationSpeed; // 0x4c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
class AnimStateID
|
|
{
|
|
public:
|
|
uint32_t m_id; // 0x0
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 8
|
|
class CSeqAutoLayerFlag
|
|
{
|
|
public:
|
|
bool m_bPost; // 0x0
|
|
bool m_bSpline; // 0x1
|
|
bool m_bXFade; // 0x2
|
|
bool m_bNoBlend; // 0x3
|
|
bool m_bLocal; // 0x4
|
|
bool m_bPose; // 0x5
|
|
bool m_bFetchFrame; // 0x6
|
|
bool m_bSubtract; // 0x7
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CGroundCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Value"
|
|
bool m_comparisonValue; // 0x28
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 40
|
|
class CAnimGraphNetworkSettings : public CAnimGraphSettingsGroup
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Enable Networking"
|
|
bool m_bNetworkingEnabled; // 0x20
|
|
// MPropertyFriendlyName "Default Network Mode"
|
|
AnimNodeNetworkMode m_defaultNetworkMode; // 0x24
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
class AnimNodeID
|
|
{
|
|
public:
|
|
uint32_t m_id; // 0x0
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 168
|
|
class CAnimEncodeDifference
|
|
{
|
|
public:
|
|
CUtlVector< CAnimBoneDifference > m_boneArray; // 0x0
|
|
CUtlVector< CAnimMorphDifference > m_morphArray; // 0x18
|
|
CUtlVector< CAnimUserDifference > m_userArray; // 0x30
|
|
CUtlVector< uint8 > m_bHasRotationBitArray; // 0x48
|
|
CUtlVector< uint8 > m_bHasMovementBitArray; // 0x60
|
|
CUtlVector< uint8 > m_bHasMorphBitArray; // 0x78
|
|
CUtlVector< uint8 > m_bHasUserBitArray; // 0x90
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 40
|
|
class CAnimStateList
|
|
{
|
|
public:
|
|
CUtlVector< CAnimState* > m_states; // 0x10
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 64
|
|
class CVectorAnimParameter : public CAnimParameterBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Default Value"
|
|
Vector m_defaultValue; // 0x30
|
|
// MPropertyFriendlyName "Interpolate"
|
|
bool m_bInterpolate; // 0x3c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 112
|
|
class CAnimGraphDebugReplay
|
|
{
|
|
public:
|
|
CAnimationGraph* m_pAnimGraph; // 0x40
|
|
CUtlVector< CSmartPtr< CAnimReplayFrame > > m_frameList; // 0x48
|
|
int32_t m_startIndex; // 0x60
|
|
int32_t m_writeIndex; // 0x64
|
|
int32_t m_frameCount; // 0x68
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 56
|
|
class CParameterValue
|
|
{
|
|
public:
|
|
AnimParamID m_id; // 0x18
|
|
CAnimVariant m_value; // 0x1c
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 32
|
|
class CAnimGraphSettingsGroup
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
class CSeqTransition
|
|
{
|
|
public:
|
|
float m_flFadeInTime; // 0x0
|
|
float m_flFadeOutTime; // 0x4
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 288
|
|
struct AnimationSnapshot_t : public AnimationSnapshotBase_t
|
|
{
|
|
public:
|
|
int32_t m_nEntIndex; // 0x110
|
|
CUtlString m_modelName; // 0x118
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 40
|
|
class CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Name"
|
|
// MPropertySortPriority "100"
|
|
CUtlString m_name; // 0x18
|
|
// MPropertyHideField
|
|
AnimTagID m_tagID; // 0x20
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
struct IKBoneNameAndIndex_t
|
|
{
|
|
public:
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
CUtlString m_Name; // 0x0
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 11
|
|
class CSeqSeqDescFlag
|
|
{
|
|
public:
|
|
bool m_bLooping; // 0x0
|
|
bool m_bSnap; // 0x1
|
|
bool m_bAutoplay; // 0x2
|
|
bool m_bPost; // 0x3
|
|
bool m_bHidden; // 0x4
|
|
bool m_bMulti; // 0x5
|
|
bool m_bLegacyDelta; // 0x6
|
|
bool m_bLegacyWorldspace; // 0x7
|
|
bool m_bLegacyCyclepose; // 0x8
|
|
bool m_bLegacyRealtime; // 0x9
|
|
bool m_bModelDoc; // 0xa
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 112
|
|
struct AnimationDecodeDebugDumpElement_t
|
|
{
|
|
public:
|
|
int32_t m_nEntityIndex; // 0x0
|
|
CUtlString m_modelName; // 0x8
|
|
CUtlVector< CUtlString > m_poseParams; // 0x10
|
|
CUtlVector< CUtlString > m_decodeOps; // 0x28
|
|
CUtlVector< CUtlString > m_internalOps; // 0x40
|
|
CUtlVector< CUtlString > m_decodedAnims; // 0x58
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
class CMoveHeadingCondition : public CAnimStateConditionBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Comparison Value"
|
|
float m_comparisonValue; // 0x2c
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 40
|
|
class CCurrentVelocityMetric : public CMotionMetricBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 32
|
|
class CAnimActivity
|
|
{
|
|
public:
|
|
CBufferString m_name; // 0x0
|
|
int32_t m_nActivity; // 0x10
|
|
int32_t m_nFlags; // 0x14
|
|
int32_t m_nWeight; // 0x18
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 64
|
|
class CTaskStatusAnimTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CUtlString m_identifierString; // 0x30
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 216
|
|
class CAnimEncodedFrames
|
|
{
|
|
public:
|
|
CBufferString m_fileName; // 0x0
|
|
int32_t m_nFrames; // 0x10
|
|
int32_t m_nFramesPerBlock; // 0x14
|
|
CUtlVector< CAnimFrameBlockAnim > m_frameblockArray; // 0x18
|
|
CAnimEncodeDifference m_usageDifferences; // 0x30
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 96
|
|
class CSeqBoneMaskList
|
|
{
|
|
public:
|
|
CBufferString m_sName; // 0x0
|
|
CUtlVector< int16 > m_nLocalBoneArray; // 0x10
|
|
CUtlVector< float32 > m_flBoneWeightArray; // 0x28
|
|
float m_flDefaultMorphCtrlWeight; // 0x40
|
|
CUtlVector< CUtlPair< CBufferString, float32 > > m_morphCtrlWeightArray; // 0x48
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 144
|
|
class CLeanMatrixAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Sequence"
|
|
// MPropertyAttributeChoiceName "Sequence"
|
|
CUtlString m_sequenceName; // 0x48
|
|
// MPropertyFriendlyName "Max Value"
|
|
float m_flMaxValue; // 0x50
|
|
// MPropertyFriendlyName "Blend Source"
|
|
AnimVectorSource m_blendSource; // 0x54
|
|
// MPropertyFriendlyName "Parameter"
|
|
// MPropertyAttributeChoiceName "VectorParameter"
|
|
AnimParamID m_param; // 0x58
|
|
// MPropertyFriendlyName "Vertical Axis"
|
|
Vector m_verticalAxisDirection; // 0x5c
|
|
// MPropertyFriendlyName "Horizontal Axis"
|
|
Vector m_horizontalAxisDirection; // 0x68
|
|
// MPropertyFriendlyName "Damping"
|
|
CAnimInputDamping m_damping; // 0x78
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 40
|
|
class CFootLockItem
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Foot"
|
|
// MPropertyAttributeChoiceName "Foot"
|
|
CUtlString m_footName; // 0x0
|
|
// MPropertyFriendlyName "Target Bone"
|
|
// MPropertyAttributeChoiceName "Bone"
|
|
CUtlString m_targetBoneName; // 0x8
|
|
// MPropertyFriendlyName "IK Chain"
|
|
// MPropertyAttributeChoiceName "IKChain"
|
|
CUtlString m_ikChainName; // 0x10
|
|
// MPropertyFriendlyName "Disable Tag"
|
|
// MPropertyAttributeChoiceName "Tag"
|
|
AnimTagID m_disableTagID; // 0x18
|
|
// MPropertyFriendlyName "Max Left Rotation"
|
|
// MPropertyAttributeRange "0 180"
|
|
float m_flMaxRotationLeft; // 0x1c
|
|
// MPropertyFriendlyName "Max Right Rotation"
|
|
// MPropertyAttributeRange "0 180"
|
|
float m_flMaxRotationRight; // 0x20
|
|
// MPropertyFriendlyName "Footstep Landed Tag"
|
|
// MPropertyAttributeChoiceName "Tag"
|
|
AnimTagID m_footstepLandedTag; // 0x24
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 80
|
|
class CAnimRetargetData
|
|
{
|
|
public:
|
|
int32_t m_bEnableRetarget; // 0x0
|
|
int32_t m_nRetargetStyle; // 0x4
|
|
CUtlVector< CAnimRetargetElementData > m_element; // 0x8
|
|
CUtlVector< CAnimRetargetChainData > m_chain; // 0x20
|
|
CUtlVector< CBufferString > m_replicated; // 0x38
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 64
|
|
class CIntAnimParameter : public CAnimParameterBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Default Value"
|
|
int32_t m_defaultValue; // 0x30
|
|
// MPropertyFriendlyName "Min Value"
|
|
int32_t m_minValue; // 0x34
|
|
// MPropertyFriendlyName "Max Value"
|
|
int32_t m_maxValue; // 0x38
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 64
|
|
class CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Name"
|
|
// MPropertySortPriority "100"
|
|
CUtlString m_sName; // 0x20
|
|
// MPropertyHideField
|
|
Vector2D m_vecPosition; // 0x28
|
|
// MPropertyHideField
|
|
AnimNodeID m_nNodeID; // 0x30
|
|
// MPropertyFriendlyName "Network Mode"
|
|
// MPropertyAttrStateCallback
|
|
AnimNodeNetworkMode m_networkMode; // 0x34
|
|
// MPropertyHideField
|
|
CUtlString m_sNote; // 0x38
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 96
|
|
class CTurnHelperAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Turn to Face"
|
|
AnimValueSource m_facingTarget; // 0x48
|
|
// MPropertyFriendlyName "Turn Start Time"
|
|
float m_turnStartTime; // 0x4c
|
|
// MPropertyFriendlyName "Turn Duration"
|
|
float m_turnDuration; // 0x50
|
|
// MPropertyFriendlyName "Match Child Duration"
|
|
bool m_bMatchChildDuration; // 0x54
|
|
// MPropertyFriendlyName "Use Manual Turn Offset"
|
|
bool m_bUseManualTurnOffset; // 0x55
|
|
// MPropertyFriendlyName "Manual Turn Offset"
|
|
float m_manualTurnOffset; // 0x58
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 80
|
|
class CCycleControlAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Blend Source"
|
|
AnimValueSource m_valueSource; // 0x48
|
|
// MPropertyFriendlyName "Parameter"
|
|
// MPropertyAttributeChoiceName "FloatParameter"
|
|
AnimParamID m_param; // 0x4c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 56
|
|
class CSequenceFinishedAnimTag : public CAnimTagBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Sequence"
|
|
// MPropertyAttributeChoiceName "Sequence"
|
|
CUtlString m_sequenceName; // 0x30
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 48
|
|
class CAnimParameterBase
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Name"
|
|
// MPropertySortPriority "100"
|
|
CUtlString m_name; // 0x18
|
|
// MPropertyHideField
|
|
AnimParamID m_id; // 0x20
|
|
// MPropertyFriendlyName "Preview Button"
|
|
AnimParamButton_t m_previewButton; // 0x24
|
|
// MPropertyFriendlyName "Network"
|
|
bool m_bNetwork; // 0x28
|
|
// MPropertyFriendlyName "Force Latest Value"
|
|
bool m_bUseMostRecentValue; // 0x29
|
|
// MPropertyFriendlyName "Auto Reset"
|
|
bool m_bAutoReset; // 0x2a
|
|
// MPropertyFriendlyName "Predicted"
|
|
bool m_bPredicted; // 0x2b
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 80
|
|
class CSetFacingAnimNode : public CAnimNodeBase
|
|
{
|
|
public:
|
|
// MPropertyHideField
|
|
CNodeConnection m_inputConnection; // 0x40
|
|
// MPropertyFriendlyName "Facing Mode"
|
|
FacingMode m_facingMode; // 0x48
|
|
// MPropertyFriendlyName "Reset Child"
|
|
bool m_bResetChild; // 0x4c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 32
|
|
class CAnimFrameBlockAnim
|
|
{
|
|
public:
|
|
int32_t m_nStartFrame; // 0x0
|
|
int32_t m_nEndFrame; // 0x4
|
|
CUtlVector< int32 > m_segmentIndexArray; // 0x8
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 12
|
|
struct FeFitInfluence_t
|
|
{
|
|
public:
|
|
uint32_t nVertexNode; // 0x0
|
|
float flWeight; // 0x4
|
|
uint32_t nMatrixNode; // 0x8
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
struct VertexPositionColor_t
|
|
{
|
|
public:
|
|
Vector m_vPosition; // 0x0
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 56
|
|
class CFingerBone
|
|
{
|
|
public:
|
|
CUtlString m_boneName; // 0x0
|
|
Vector m_hingeAxis; // 0x8
|
|
Vector m_vCapsulePos1; // 0x14
|
|
Vector m_vCapsulePos2; // 0x20
|
|
float m_flMinAngle; // 0x2c
|
|
float m_flMaxAngle; // 0x30
|
|
float m_flRadius; // 0x34
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 128
|
|
struct FeSimdTri_t
|
|
{
|
|
public:
|
|
uint32[4][3] nNode; // 0x0
|
|
fltx4 w1; // 0x30
|
|
fltx4 w2; // 0x40
|
|
fltx4 v1x; // 0x50
|
|
FourVectors2D v2; // 0x60
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 4
|
|
struct RnHalfEdge_t
|
|
{
|
|
public:
|
|
uint8_t m_nNext; // 0x0
|
|
uint8_t m_nTwin; // 0x1
|
|
uint8_t m_nOrigin; // 0x2
|
|
uint8_t m_nFace; // 0x3
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 144
|
|
struct PhysSoftbodyDesc_t
|
|
{
|
|
public:
|
|
CUtlVector< uint32 > m_ParticleBoneHash; // 0x0
|
|
CUtlVector< RnSoftbodyParticle_t > m_Particles; // 0x18
|
|
CUtlVector< RnSoftbodySpring_t > m_Springs; // 0x30
|
|
CUtlVector< RnSoftbodyCapsule_t > m_Capsules; // 0x48
|
|
CUtlVector< CTransform > m_InitPose; // 0x60
|
|
CUtlVector< CUtlString > m_ParticleBoneName; // 0x78
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 8
|
|
struct FeFitWeight_t
|
|
{
|
|
public:
|
|
float flWeight; // 0x0
|
|
uint16_t nNode; // 0x4
|
|
uint16_t nDummy; // 0x6
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 20
|
|
struct FeRodConstraint_t
|
|
{
|
|
public:
|
|
uint16[2] nNode; // 0x0
|
|
float flMaxDist; // 0x4
|
|
float flMinDist; // 0x8
|
|
float flWeight0; // 0xc
|
|
float flRelaxationFactor; // 0x10
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 24
|
|
class CPhysSurfacePropertiesAudio
|
|
{
|
|
public:
|
|
float m_hardnessFactor; // 0x0
|
|
float m_roughnessFactor; // 0x4
|
|
float m_roughThreshold; // 0x8
|
|
float m_hardThreshold; // 0xc
|
|
// MDefaultString
|
|
float m_hardVelocityThreshold; // 0x10
|
|
float m_flStaticImpactVolume; // 0x14
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 40
|
|
class CBoneConstraintBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
struct FeTreeChildren_t
|
|
{
|
|
public:
|
|
uint16[2] nChild; // 0x0
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 160
|
|
struct VPhysXBodyPart_t
|
|
{
|
|
public:
|
|
uint32_t m_nFlags; // 0x0
|
|
float m_flMass; // 0x4
|
|
VPhysics2ShapeDef_t m_rnShape; // 0x8
|
|
uint16_t m_nCollisionAttributeIndex; // 0x80
|
|
uint16_t m_nReserved; // 0x82
|
|
float m_flInertiaScale; // 0x84
|
|
float m_flLinearDamping; // 0x88
|
|
float m_flAngularDamping; // 0x8c
|
|
bool m_bOverrideMassCenter; // 0x90
|
|
Vector m_vMassCenterOverride; // 0x94
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 16
|
|
struct RnShapeDesc_t
|
|
{
|
|
public:
|
|
uint32_t m_nCollisionAttributeIndex; // 0x0
|
|
uint32_t m_nSurfacePropertyIndex; // 0x4
|
|
CUtlString m_UserFriendlyName; // 0x8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 24
|
|
struct SkeletonBoneBounds_t
|
|
{
|
|
public:
|
|
Vector m_vecCenter; // 0x0
|
|
Vector m_vecSize; // 0xc
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct FeSoftParent_t
|
|
{
|
|
public:
|
|
int32_t nParent; // 0x0
|
|
float flAlpha; // 0x4
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 64
|
|
struct FeBuildTaperedCapsuleRigid_t : public FeTaperedCapsuleRigid_t
|
|
{
|
|
public:
|
|
int32_t m_nPriority; // 0x30
|
|
uint32_t m_nVertexMapHash; // 0x34
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 32
|
|
struct FeSphereRigid_t
|
|
{
|
|
public:
|
|
fltx4 vSphere; // 0x0
|
|
float flStickiness; // 0x10
|
|
uint16_t nNode; // 0x14
|
|
uint16_t nCollisionMask; // 0x16
|
|
uint16_t nVertexMapIndex; // 0x18
|
|
uint16_t nFlags; // 0x1a
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 48
|
|
struct RnCapsuleDesc_t : public RnShapeDesc_t
|
|
{
|
|
public:
|
|
RnCapsule_t m_Capsule; // 0x10
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 96
|
|
class FourCovMatrices3
|
|
{
|
|
public:
|
|
FourVectors m_vDiag; // 0x0
|
|
fltx4 m_flXY; // 0x30
|
|
fltx4 m_flXZ; // 0x40
|
|
fltx4 m_flYZ; // 0x50
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
class CFootTrajectories
|
|
{
|
|
public:
|
|
CUtlVector< CFootTrajectory > m_trajectories; // 0x0
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 40
|
|
struct FeAxialEdgeBend_t
|
|
{
|
|
public:
|
|
float te; // 0x0
|
|
float tv; // 0x4
|
|
float flDist; // 0x8
|
|
float32[4] flWeight; // 0xc
|
|
uint16[6] nNode; // 0x1c
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 8
|
|
struct FeNodeWindBase_t
|
|
{
|
|
public:
|
|
uint16_t nNodeX0; // 0x0
|
|
uint16_t nNodeX1; // 0x2
|
|
uint16_t nNodeY0; // 0x4
|
|
uint16_t nNodeY1; // 0x6
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
struct FeSourceEdge_t
|
|
{
|
|
public:
|
|
uint16[2] nNode; // 0x0
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 112
|
|
class COrientConstraint : public CBaseConstraint, CBoneConstraintBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 4
|
|
struct FeCtrlOsOffset_t
|
|
{
|
|
public:
|
|
uint16_t nCtrlParent; // 0x0
|
|
uint16_t nCtrlChild; // 0x2
|
|
};
|
|
|
|
// Aligment: 46
|
|
// Size: 248
|
|
struct VPhysXConstraintParams_t
|
|
{
|
|
public:
|
|
int8_t m_nType; // 0x0
|
|
int8_t m_nTranslateMotion; // 0x1
|
|
int8_t m_nRotateMotion; // 0x2
|
|
int8_t m_nFlags; // 0x3
|
|
Vector[2] m_anchor; // 0x4
|
|
Quaternion[2] m_axes; // 0x1c
|
|
float 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
|
|
Vector m_goalPosition; // 0x94
|
|
Quaternion m_goalOrientation; // 0xa0
|
|
Vector m_goalAngularVelocity; // 0xb0
|
|
float 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
|
|
int32_t m_solverIterationCount; // 0xec
|
|
float m_projectionLinearTolerance; // 0xf0
|
|
float m_projectionAngularTolerance; // 0xf4
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 112
|
|
class CPointConstraint : public CBaseConstraint, CBoneConstraintBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 24
|
|
class CPhysSurfacePropertiesPhysics
|
|
{
|
|
public:
|
|
float m_friction; // 0x0
|
|
float m_elasticity; // 0x4
|
|
float m_density; // 0x8
|
|
// MDefaultString
|
|
float m_thickness; // 0xc
|
|
float m_dampening; // 0x10
|
|
// MDefaultString
|
|
float m_bouncethreshold; // 0x14
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 1
|
|
struct RnFace_t
|
|
{
|
|
public:
|
|
uint8_t m_nEdge; // 0x0
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 80
|
|
class CRenderSkeleton
|
|
{
|
|
public:
|
|
CUtlVector< RenderSkeletonBone_t > m_bones; // 0x0
|
|
CUtlVector< int32 > m_boneParents; // 0x30
|
|
int32_t m_nBoneWeightCount; // 0x48
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 168
|
|
class CBoneConstraintPoseSpaceMorph : public CBoneConstraintBase
|
|
{
|
|
public:
|
|
CUtlString m_sBoneName; // 0x28
|
|
CUtlString m_sAttachmentName; // 0x30
|
|
CUtlVector< CUtlString > m_outputMorph; // 0x38
|
|
CUtlVector< CBoneConstraintPoseSpaceMorph::Input_t > m_inputList; // 0x50
|
|
bool m_bClamp; // 0x68
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 152
|
|
class CBoneConstraintPoseSpaceBone : public CBaseConstraint, CBoneConstraintBase
|
|
{
|
|
public:
|
|
CUtlVector< CBoneConstraintPoseSpaceBone::Input_t > m_inputList; // 0x70
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 104
|
|
struct Dop26_t
|
|
{
|
|
public:
|
|
float32[26] m_flSupport; // 0x0
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
class CVPhysXSurfacePropertiesList
|
|
{
|
|
public:
|
|
CUtlVector< CPhysSurfaceProperties* > m_surfacePropertiesList; // 0x0
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 160
|
|
class CTiltTwistConstraint : public CBaseConstraint, CBoneConstraintBase
|
|
{
|
|
public:
|
|
int32_t m_nTargetAxis; // 0x70
|
|
int32_t m_nSlaveAxis; // 0x74
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 232
|
|
struct RnHullDesc_t : public RnShapeDesc_t
|
|
{
|
|
public:
|
|
RnHull_t m_Hull; // 0x10
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 32
|
|
class CFlexRule
|
|
{
|
|
public:
|
|
int32_t m_nFlex; // 0x0
|
|
CUtlVector< CFlexOp > m_FlexOps; // 0x8
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 96
|
|
struct RenderSkeletonBone_t
|
|
{
|
|
public:
|
|
CUtlString m_boneName; // 0x0
|
|
CUtlString m_parentName; // 0x8
|
|
matrix3x4_t m_invBindPose; // 0x10
|
|
SkeletonBoneBounds_t m_bbox; // 0x40
|
|
float m_flSphereRadius; // 0x58
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 32
|
|
struct ModelBoneFlexDriverControl_t
|
|
{
|
|
public:
|
|
ModelBoneFlexComponent_t m_nBoneComponent; // 0x0
|
|
CUtlString m_flexController; // 0x8
|
|
uint32_t m_flexControllerToken; // 0x10
|
|
float m_flMin; // 0x14
|
|
float m_flMax; // 0x18
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 152
|
|
class CTwistConstraint : public CBaseConstraint, CBoneConstraintBase
|
|
{
|
|
public:
|
|
bool m_bInverse; // 0x70
|
|
Quaternion m_qParentBindRotation; // 0x74
|
|
Quaternion m_qChildBindRotation; // 0x84
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 24
|
|
class CovMatrix3
|
|
{
|
|
public:
|
|
Vector m_vDiag; // 0x0
|
|
float m_flXY; // 0xc
|
|
float m_flXZ; // 0x10
|
|
float m_flYZ; // 0x14
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 120
|
|
struct VPhysics2ShapeDef_t
|
|
{
|
|
public:
|
|
CUtlVector< RnSphereDesc_t > m_spheres; // 0x0
|
|
CUtlVector< RnCapsuleDesc_t > m_capsules; // 0x18
|
|
CUtlVector< RnHullDesc_t > m_hulls; // 0x30
|
|
CUtlVector< RnMeshDesc_t > m_meshes; // 0x48
|
|
CUtlVector< uint16 > m_CollisionAttributeIndices; // 0x60
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 448
|
|
class CRenderMesh
|
|
{
|
|
public:
|
|
CUtlVectorFixedGrowable< CSceneObjectData > m_sceneObjects; // 0x10
|
|
CUtlVector< CBaseConstraint* > m_constraints; // 0x88
|
|
CRenderSkeleton m_skeleton; // 0xa0
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 8
|
|
class CFlexDesc
|
|
{
|
|
public:
|
|
CUtlString m_szFacs; // 0x0
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 48
|
|
class CWristBone
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
Vector m_vForwardLS; // 0x8
|
|
Vector m_vUpLS; // 0x14
|
|
Vector m_vOffset; // 0x20
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 216
|
|
struct RnHull_t
|
|
{
|
|
public:
|
|
Vector m_vCentroid; // 0x0
|
|
float m_flMaxAngularRadius; // 0xc
|
|
CUtlVector< Vector > m_Vertices; // 0x10
|
|
CUtlVector< RnPlane_t > m_Planes; // 0x28
|
|
CUtlVector< RnHalfEdge_t > m_Edges; // 0x40
|
|
CUtlVector< RnFace_t > m_Faces; // 0x58
|
|
Vector m_vOrthographicAreas; // 0x70
|
|
matrix3x4_t m_MassProperties; // 0x7c
|
|
float m_flVolume; // 0xac
|
|
float m_flMaxMotionRadius; // 0xb0
|
|
float m_flMinMotionThickness; // 0xb4
|
|
AABB_t m_Bounds; // 0xb8
|
|
uint32_t m_nFlags; // 0xd0
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 24
|
|
struct FeCollisionSphere_t
|
|
{
|
|
public:
|
|
uint16_t nCtrlParent; // 0x0
|
|
uint16_t nChildNode; // 0x2
|
|
float m_flRFactor; // 0x4
|
|
Vector m_vOrigin; // 0x8
|
|
float flStickiness; // 0x14
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
class CFingerSource
|
|
{
|
|
public:
|
|
AnimVRFinger_t m_nFingerIndex; // 0x0
|
|
float m_flFingerWeight; // 0x4
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 24
|
|
class CFlexController
|
|
{
|
|
public:
|
|
CUtlString m_szName; // 0x0
|
|
CUtlString m_szType; // 0x8
|
|
float min; // 0x10
|
|
float max; // 0x14
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 20
|
|
class CFootTrajectory
|
|
{
|
|
public:
|
|
Vector m_vOffset; // 0x0
|
|
float m_flRotationOffset; // 0xc
|
|
float m_flProgression; // 0x10
|
|
public:
|
|
static CFootTrajectory &Get_Identity() { return *reinterpret_cast<CFootTrajectory*>(interfaces::g_schema->FindTypeScopeForModule("!GlobalTypes")->FindDeclaredClass("CFootTrajectory")->m_static_fiels[0]->m_instance); }
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 28
|
|
struct FeTri_t
|
|
{
|
|
public:
|
|
uint16[3] nNode; // 0x0
|
|
float w1; // 0x8
|
|
float w2; // 0xc
|
|
float v1x; // 0x10
|
|
Vector2D v2; // 0x14
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 40
|
|
struct FeVertexMapBuild_t
|
|
{
|
|
public:
|
|
CUtlString m_VertexMapName; // 0x0
|
|
uint32_t m_nNameHash; // 0x8
|
|
CUtlVector< float32 > m_Weights; // 0x10
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 32
|
|
struct FeNodeBase_t
|
|
{
|
|
public:
|
|
uint16_t nNode; // 0x0
|
|
uint16[3] nDummy; // 0x2
|
|
uint16_t nNodeX0; // 0x8
|
|
uint16_t nNodeX1; // 0xa
|
|
uint16_t nNodeY0; // 0xc
|
|
uint16_t nNodeY1; // 0xe
|
|
Quaternion qAdjust; // 0x10
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 64
|
|
class CPhysSurfacePropertiesSoundNames
|
|
{
|
|
public:
|
|
CUtlString 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
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 40
|
|
struct CBoneConstraintPoseSpaceBone::Input_t
|
|
{
|
|
public:
|
|
Vector m_inputValue; // 0x0
|
|
CUtlVector< CTransform > m_outputTransformList; // 0x10
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 112
|
|
class CFingerChain
|
|
{
|
|
public:
|
|
CUtlVector< CFingerSource > m_targets; // 0x0
|
|
CUtlVector< CFingerBone > m_bones; // 0x18
|
|
CUtlString m_name; // 0x30
|
|
CUtlString m_tipParentBoneName; // 0x38
|
|
Vector m_vTipOffset; // 0x40
|
|
CUtlString m_metacarpalBoneName; // 0x50
|
|
Vector m_vSplayHingeAxis; // 0x58
|
|
float m_flSplayMinAngle; // 0x64
|
|
float m_flSplayMaxAngle; // 0x68
|
|
float m_flFingerScaleRatio; // 0x6c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 32
|
|
struct RnSoftbodyCapsule_t
|
|
{
|
|
public:
|
|
Vector[2] m_vCenter; // 0x0
|
|
float m_flRadius; // 0x18
|
|
uint16[2] m_nParticle; // 0x1c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 16
|
|
struct FeCtrlOffset_t
|
|
{
|
|
public:
|
|
uint16_t nCtrlParent; // 0x0
|
|
uint16_t nCtrlChild; // 0x2
|
|
Vector vOffset; // 0x4
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 144
|
|
class CMorphConstraint : public CBaseConstraint, CBoneConstraintBase
|
|
{
|
|
public:
|
|
CUtlString m_sTargetMorph; // 0x70
|
|
int32_t m_nSlaveChannel; // 0x78
|
|
float m_flMin; // 0x7c
|
|
float m_flMax; // 0x80
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 160
|
|
class CMorphSetData
|
|
{
|
|
public:
|
|
int32_t m_nWidth; // 0x10
|
|
int32_t m_nHeight; // 0x14
|
|
MorphLookupType_t m_nLookupType; // 0x18
|
|
MorphEncodingType_t m_nEncodingType; // 0x1c
|
|
CUtlVector< MorphBundleType_t > m_bundleTypes; // 0x20
|
|
CUtlVector< CMorphData > m_morphDatas; // 0x38
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_pTextureAtlas; // 0x50
|
|
CUtlVector< CFlexDesc > m_FlexDesc; // 0x58
|
|
CUtlVector< CFlexController > m_FlexControllers; // 0x70
|
|
CUtlVector< CFlexRule > m_FlexRules; // 0x88
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 144
|
|
struct FeMorphLayerDepr_t
|
|
{
|
|
public:
|
|
CUtlString m_Name; // 0x0
|
|
uint32_t m_nNameHash; // 0x8
|
|
CUtlVector< uint16 > m_Nodes; // 0x10
|
|
CUtlVector< Vector > m_InitPos; // 0x28
|
|
CUtlVector< float32 > m_Gravity; // 0x40
|
|
CUtlVector< float32 > m_GoalStrength; // 0x58
|
|
CUtlVector< float32 > m_GoalDamping; // 0x70
|
|
uint32_t m_nFlags; // 0x88
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
class CRenderBufferBinding
|
|
{
|
|
public:
|
|
uint64_t m_hBuffer; // 0x0
|
|
uint32_t m_nBindOffsetBytes; // 0x8
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 80
|
|
struct FeBoxRigid_t
|
|
{
|
|
public:
|
|
uint16_t nNode; // 0x0
|
|
uint16_t nCollisionMask; // 0x2
|
|
Vector vSize; // 0x4
|
|
float flStickiness; // 0x10
|
|
uint16_t nVertexMapIndex; // 0x14
|
|
uint16_t nFlags; // 0x16
|
|
float32[2] flReserved; // 0x18
|
|
matrix3x4a_t tmFrame; // 0x20
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 12
|
|
struct FeStiffHingeBuild_t
|
|
{
|
|
public:
|
|
float flMaxAngle; // 0x0
|
|
uint16[3] nNode; // 0x4
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 64
|
|
class CFootCycleDefinition
|
|
{
|
|
public:
|
|
Vector m_vStancePositionMS; // 0x0
|
|
Vector m_vMidpointPositionMS; // 0xc
|
|
float m_flStanceDirectionMS; // 0x18
|
|
Vector m_vToStrideStartPos; // 0x1c
|
|
float m_flMaxExtent; // 0x28
|
|
CAnimCycle m_stanceCycle; // 0x2c
|
|
CFootCycle m_footLiftCycle; // 0x30
|
|
CFootCycle m_footOffCycle; // 0x34
|
|
CFootCycle m_footStrikeCycle; // 0x38
|
|
CFootCycle m_footLandCycle; // 0x3c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 88
|
|
class CConstraintSlave
|
|
{
|
|
public:
|
|
uint32_t m_nBoneHash; // 0x0
|
|
float m_flWeight; // 0x4
|
|
Vector m_vBasePosition; // 0x8
|
|
Quaternion m_qBaseOrientation; // 0x14
|
|
CUtlString m_sName; // 0x28
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
struct RnSoftbodyParticle_t
|
|
{
|
|
public:
|
|
float m_flMassInv; // 0x0
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 48
|
|
class CHitBoxSet
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
uint32_t m_nNameHash; // 0x8
|
|
CUtlVector< CHitBox > m_HitBoxes; // 0x10
|
|
CUtlString m_SourceFilename; // 0x28
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 80
|
|
class CVrSkeletalInputSettings
|
|
{
|
|
public:
|
|
CUtlVector< CWristBone > m_wristBones; // 0x0
|
|
CUtlVector< CFingerChain > m_fingers; // 0x18
|
|
CUtlString m_name; // 0x30
|
|
CUtlString m_outerKnuckle1; // 0x38
|
|
CUtlString m_outerKnuckle2; // 0x40
|
|
AnimVRHand_t m_eHand; // 0x48
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 88
|
|
class CFootStride
|
|
{
|
|
public:
|
|
CFootCycleDefinition m_definition; // 0x0
|
|
CFootTrajectories m_trajectories; // 0x40
|
|
};
|
|
|
|
// Aligment: 98
|
|
// Size: 1512
|
|
struct PhysFeModelDesc_t
|
|
{
|
|
public:
|
|
CUtlVector< uint32 > m_CtrlHash; // 0x0
|
|
CUtlVector< CUtlString > m_CtrlName; // 0x18
|
|
uint32_t m_nStaticNodeFlags; // 0x30
|
|
uint32_t m_nDynamicNodeFlags; // 0x34
|
|
float m_flLocalForce; // 0x38
|
|
float m_flLocalRotation; // 0x3c
|
|
uint16_t m_nNodeCount; // 0x40
|
|
uint16_t m_nStaticNodes; // 0x42
|
|
uint16_t m_nRotLockStaticNodes; // 0x44
|
|
uint16_t m_nSimdTriCount1; // 0x46
|
|
uint16_t m_nSimdTriCount2; // 0x48
|
|
uint16_t m_nSimdQuadCount1; // 0x4a
|
|
uint16_t m_nSimdQuadCount2; // 0x4c
|
|
uint16_t m_nQuadCount1; // 0x4e
|
|
uint16_t m_nQuadCount2; // 0x50
|
|
uint16_t m_nCollisionSphereInclusiveCount; // 0x52
|
|
uint16_t m_nTreeDepth; // 0x54
|
|
uint16_t m_nNodeBaseJiggleboneDependsCount; // 0x56
|
|
uint16_t m_nRopeCount; // 0x58
|
|
CUtlVector< uint16 > m_Ropes; // 0x60
|
|
CUtlVector< FeNodeBase_t > m_NodeBases; // 0x78
|
|
CUtlVector< FeSimdNodeBase_t > m_SimdNodeBases; // 0x90
|
|
CUtlVector< FeQuad_t > m_Quads; // 0xa8
|
|
CUtlVector< FeSimdQuad_t > m_SimdQuads; // 0xc0
|
|
CUtlVector< FeSimdTri_t > m_SimdTris; // 0xd8
|
|
CUtlVector< FeSimdRodConstraint_t > m_SimdRods; // 0xf0
|
|
CUtlVector< CTransform > m_InitPose; // 0x108
|
|
CUtlVector< FeRodConstraint_t > m_Rods; // 0x120
|
|
CUtlVector< FeAxialEdgeBend_t > m_AxialEdges; // 0x138
|
|
CUtlVector< float32 > m_NodeInvMasses; // 0x150
|
|
CUtlVector< FeCtrlOffset_t > m_CtrlOffsets; // 0x168
|
|
CUtlVector< FeCtrlOsOffset_t > m_CtrlOsOffsets; // 0x180
|
|
CUtlVector< FeFollowNode_t > m_FollowNodes; // 0x198
|
|
CUtlVector< FeCollisionSphere_t > m_CollisionSpheres; // 0x1b0
|
|
CUtlVector< FeCollisionPlane_t > m_CollisionPlanes; // 0x1c8
|
|
CUtlVector< FeNodeIntegrator_t > m_NodeIntegrator; // 0x1e0
|
|
CUtlVector< FeSpringIntegrator_t > m_SpringIntegrator; // 0x1f8
|
|
CUtlVector< FeSimdSpringIntegrator_t > m_SimdSpringIntegrator; // 0x210
|
|
CUtlVector< FeWorldCollisionParams_t > m_WorldCollisionParams; // 0x228
|
|
CUtlVector< float32 > m_LegacyStretchForce; // 0x240
|
|
CUtlVector< float32 > m_NodeCollisionRadii; // 0x258
|
|
CUtlVector< float32 > m_DynNodeFriction; // 0x270
|
|
CUtlVector< float32 > m_LocalRotation; // 0x288
|
|
CUtlVector< float32 > m_LocalForce; // 0x2a0
|
|
CUtlVector< FeTaperedCapsuleStretch_t > m_TaperedCapsuleStretches; // 0x2b8
|
|
CUtlVector< FeTaperedCapsuleRigid_t > m_TaperedCapsuleRigids; // 0x2d0
|
|
CUtlVector< FeSphereRigid_t > m_SphereRigids; // 0x2e8
|
|
CUtlVector< uint16 > m_WorldCollisionNodes; // 0x300
|
|
CUtlVector< uint16 > m_TreeParents; // 0x318
|
|
CUtlVector< uint16 > m_TreeCollisionMasks; // 0x330
|
|
CUtlVector< FeTreeChildren_t > m_TreeChildren; // 0x348
|
|
CUtlVector< uint16 > m_FreeNodes; // 0x360
|
|
CUtlVector< FeFitMatrix_t > m_FitMatrices; // 0x378
|
|
CUtlVector< FeFitWeight_t > m_FitWeights; // 0x390
|
|
CUtlVector< FeNodeReverseOffset_t > m_ReverseOffsets; // 0x3a8
|
|
CUtlVector< FeAnimStrayRadius_t > m_AnimStrayRadii; // 0x3c0
|
|
CUtlVector< FeSimdAnimStrayRadius_t > m_SimdAnimStrayRadii; // 0x3d8
|
|
CUtlVector< FeKelagerBend2_t > m_KelagerBends; // 0x3f0
|
|
CUtlVector< FeCtrlSoftOffset_t > m_CtrlSoftOffsets; // 0x408
|
|
CUtlVector< CFeIndexedJiggleBone > m_JiggleBones; // 0x420
|
|
CUtlVector< uint16 > m_SourceElems; // 0x438
|
|
CUtlVector< uint32 > m_GoalDampedSpringIntegrators; // 0x450
|
|
CUtlVector< FeTri_t > m_Tris; // 0x468
|
|
uint16_t m_nTriCount1; // 0x480
|
|
uint16_t m_nTriCount2; // 0x482
|
|
uint8_t m_nReservedUint8; // 0x484
|
|
uint8_t m_nExtraPressureIterations; // 0x485
|
|
uint8_t m_nExtraGoalIterations; // 0x486
|
|
uint8_t m_nExtraIterations; // 0x487
|
|
CUtlVector< FeBoxRigid_t > m_BoxRigids; // 0x488
|
|
CUtlVector< uint8 > m_DynNodeVertexSet; // 0x4a0
|
|
CUtlVector< uint32 > m_VertexSetNames; // 0x4b8
|
|
CUtlVector< FeRigidColliderIndices_t > m_RigidColliderPriorities; // 0x4d0
|
|
CUtlVector< FeMorphLayerDepr_t > m_MorphLayers; // 0x4e8
|
|
CUtlVector< uint8 > m_MorphSetData; // 0x500
|
|
CUtlVector< FeVertexMapDesc_t > m_VertexMaps; // 0x518
|
|
CUtlVector< uint8 > m_VertexMapValues; // 0x530
|
|
CUtlVector< FeEffectDesc_t > m_Effects; // 0x548
|
|
CUtlVector< FeCtrlOffset_t > m_LockToParent; // 0x560
|
|
CUtlVector< uint16 > m_LockToGoal; // 0x578
|
|
CUtlVector< FeNodeWindBase_t > m_DynNodeWindBases; // 0x590
|
|
float 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
|
|
uint16_t m_nRodVelocitySmoothIterations; // 0x5e4
|
|
uint16_t m_nQuadVelocitySmoothIterations; // 0x5e6
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 24
|
|
struct FeCollisionPlane_t
|
|
{
|
|
public:
|
|
uint16_t nCtrlParent; // 0x0
|
|
uint16_t nChildNode; // 0x2
|
|
RnPlane_t m_Plane; // 0x4
|
|
float flStickiness; // 0x14
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 12
|
|
struct FeRigidColliderIndices_t
|
|
{
|
|
public:
|
|
uint16_t m_nTaperedCapsuleRigidIndex; // 0x0
|
|
uint16_t m_nSphereRigidIndex; // 0x2
|
|
uint16_t m_nBoxRigidIndex; // 0x4
|
|
uint16[2] m_nCollisionSphereIndex; // 0x6
|
|
uint16_t m_nCollisionPlaneIndex; // 0xa
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 32
|
|
struct RnSphereDesc_t : public RnShapeDesc_t
|
|
{
|
|
public:
|
|
RnSphere_t m_Sphere; // 0x10
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 40
|
|
struct CBoneConstraintPoseSpaceMorph::Input_t
|
|
{
|
|
public:
|
|
Vector m_inputValue; // 0x0
|
|
CUtlVector< float32 > m_outputWeightList; // 0x10
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
class CFlexOp
|
|
{
|
|
public:
|
|
FlexOpCode_t m_OpCode; // 0x0
|
|
int32_t m_Data; // 0x4
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 24
|
|
struct FeKelagerBend2_t
|
|
{
|
|
public:
|
|
float32[3] flWeight; // 0x0
|
|
float flHeight0; // 0xc
|
|
uint16[3] nNode; // 0x10
|
|
uint16_t nReserved; // 0x16
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 32
|
|
class FourVectors2D
|
|
{
|
|
public:
|
|
fltx4 x; // 0x0
|
|
fltx4 y; // 0x10
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 20
|
|
struct FeSpringIntegrator_t
|
|
{
|
|
public:
|
|
uint16[2] nNode; // 0x0
|
|
float flSpringRestLength; // 0x4
|
|
float flSpringConstant; // 0x8
|
|
float flSpringDamping; // 0xc
|
|
float flNodeWeight0; // 0x10
|
|
};
|
|
|
|
// Aligment: 20
|
|
// Size: 632
|
|
struct PermModelData_t
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
PermModelInfo_t m_modelInfo; // 0x8
|
|
CUtlVector< PermModelExtPart_t > m_ExtParts; // 0x60
|
|
CUtlVector< CStrongHandle< InfoForResourceTypeCRenderMesh > > m_refMeshes; // 0x78
|
|
CUtlVector< uint64 > m_refMeshGroupMasks; // 0x90
|
|
CUtlVector< uint64 > m_refPhysGroupMasks; // 0xa8
|
|
CUtlVector< uint8 > m_refLODGroupMasks; // 0xc0
|
|
CUtlVector< float32 > m_lodGroupSwitchDistances; // 0xd8
|
|
CUtlVector< CStrongHandle< InfoForResourceTypeCPhysAggregateData > > m_refPhysicsData; // 0xf0
|
|
CUtlVector< CStrongHandle< InfoForResourceTypeCPhysAggregateData > > m_refPhysicsHitboxData; // 0x108
|
|
CUtlVector< CStrongHandle< InfoForResourceTypeCAnimationGroup > > m_refAnimGroups; // 0x120
|
|
CUtlVector< CStrongHandle< InfoForResourceTypeCSequenceGroupData > > m_refSequenceGroups; // 0x138
|
|
CUtlVector< CUtlString > m_meshGroups; // 0x150
|
|
CUtlVector< MaterialGroup_t > m_materialGroups; // 0x168
|
|
uint64_t m_nDefaultMeshGroupMask; // 0x180
|
|
ModelSkeletonData_t m_modelSkeleton; // 0x188
|
|
CUtlVector< int16 > m_remappingTable; // 0x218
|
|
CUtlVector< uint16 > m_remappingTableStarts; // 0x230
|
|
CUtlVector< ModelBoneFlexDriver_t > m_boneFlexDrivers; // 0x248
|
|
CUtlVector< CUtlString > m_BodyGroupsHiddenInTools; // 0x260
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 32
|
|
struct FeEffectDesc_t
|
|
{
|
|
public:
|
|
CUtlString sName; // 0x0
|
|
uint32_t nNameHash; // 0x8
|
|
int32_t nType; // 0xc
|
|
KeyValues3 m_Params; // 0x10
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 4
|
|
struct FeWeightedNode_t
|
|
{
|
|
public:
|
|
uint16_t nNode; // 0x0
|
|
uint16_t nWeight; // 0x2
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 112
|
|
class CParentConstraint : public CBaseConstraint, CBoneConstraintBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 40
|
|
class CMorphRectData
|
|
{
|
|
public:
|
|
int16_t m_nXLeftDst; // 0x0
|
|
int16_t m_nYTopDst; // 0x2
|
|
float m_flUWidthSrc; // 0x4
|
|
float m_flVHeightSrc; // 0x8
|
|
CUtlVector< CMorphBundleData > m_bundleDatas; // 0x10
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 76
|
|
struct FeQuad_t
|
|
{
|
|
public:
|
|
uint16[4] nNode; // 0x0
|
|
float flSlack; // 0x8
|
|
Vector4D[4] vShape; // 0xc
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 112
|
|
struct FeSimdNodeBase_t
|
|
{
|
|
public:
|
|
uint16[4] nNode; // 0x0
|
|
uint16[4] nNodeX0; // 0x8
|
|
uint16[4] nNodeX1; // 0x10
|
|
uint16[4] nNodeY0; // 0x18
|
|
uint16[4] nNodeY1; // 0x20
|
|
uint16[4] nDummy; // 0x28
|
|
FourQuaternions qAdjust; // 0x30
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 80
|
|
struct FeSimdSpringIntegrator_t
|
|
{
|
|
public:
|
|
uint16[4][2] nNode; // 0x0
|
|
fltx4 flSpringRestLength; // 0x10
|
|
fltx4 flSpringConstant; // 0x20
|
|
fltx4 flSpringDamping; // 0x30
|
|
fltx4 flNodeWeight0; // 0x40
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 304
|
|
struct FeSimdQuad_t
|
|
{
|
|
public:
|
|
uint16[4][4] nNode; // 0x0
|
|
fltx4 f4Slack; // 0x20
|
|
FourVectors[4] vShape; // 0x30
|
|
fltx4[4] f4Weights; // 0xf0
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 64
|
|
struct FeFitMatrix_t
|
|
{
|
|
public:
|
|
CTransform bone; // 0x0
|
|
Vector vCenter; // 0x20
|
|
uint16_t nEnd; // 0x2c
|
|
uint16_t nNode; // 0x2e
|
|
uint16_t nBeginDynamic; // 0x30
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 32
|
|
struct RnNode_t
|
|
{
|
|
public:
|
|
Vector m_vMin; // 0x0
|
|
uint32_t m_nChildren; // 0xc
|
|
Vector m_vMax; // 0x10
|
|
uint32_t m_nTriangleOffset; // 0x1c
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 12
|
|
struct FeWorldCollisionParams_t
|
|
{
|
|
public:
|
|
float flWorldFriction; // 0x0
|
|
float flGroundFriction; // 0x4
|
|
uint16_t nListBegin; // 0x8
|
|
uint16_t nListEnd; // 0xa
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 184
|
|
class CPhysSurfaceProperties
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
uint32_t m_nameHash; // 0x8
|
|
uint32_t m_baseNameHash; // 0xc
|
|
bool m_bHidden; // 0x18
|
|
CUtlString m_description; // 0x20
|
|
CPhysSurfacePropertiesPhysics m_physics; // 0x28
|
|
CPhysSurfacePropertiesSoundNames m_audioSounds; // 0x40
|
|
CPhysSurfacePropertiesAudio m_audioParams; // 0x80
|
|
};
|
|
|
|
// Aligment: 35
|
|
// Size: 156
|
|
class CFeJiggleBone
|
|
{
|
|
public:
|
|
uint32_t m_nFlags; // 0x0
|
|
float 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
|
|
Vector m_vPoint0; // 0x80
|
|
Vector m_vPoint1; // 0x8c
|
|
uint16_t m_nCollisionMask; // 0x98
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
struct RnPlane_t
|
|
{
|
|
public:
|
|
Vector m_vNormal; // 0x0
|
|
float m_flOffset; // 0xc
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 16
|
|
struct FeNodeReverseOffset_t
|
|
{
|
|
public:
|
|
uint16_t nBoneCtrl; // 0x0
|
|
uint16_t nTargetNode; // 0x2
|
|
Vector vOffset; // 0x4
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 152
|
|
struct RnMeshDesc_t : public RnShapeDesc_t
|
|
{
|
|
public:
|
|
RnMesh_t m_Mesh; // 0x10
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
class CCycleBase
|
|
{
|
|
public:
|
|
float m_flCycle; // 0x0
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 16
|
|
struct FeEdgeDesc_t
|
|
{
|
|
public:
|
|
uint16[2] nEdge; // 0x0
|
|
uint16[2][2] nSide; // 0x4
|
|
uint16[2] nVirtElem; // 0xc
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 12
|
|
struct FeAnimStrayRadius_t
|
|
{
|
|
public:
|
|
uint16[2] nNode; // 0x0
|
|
float flMaxDist; // 0x4
|
|
float flRelaxationFactor; // 0x8
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 48
|
|
struct FeTaperedCapsuleRigid_t
|
|
{
|
|
public:
|
|
fltx4[2] vSphere; // 0x0
|
|
float flStickiness; // 0x20
|
|
uint16_t nNode; // 0x24
|
|
uint16_t nCollisionMask; // 0x26
|
|
uint16_t nVertexMapIndex; // 0x28
|
|
uint16_t nFlags; // 0x2a
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
class CHitBoxSetList
|
|
{
|
|
public:
|
|
CUtlVector< CHitBoxSet > m_HitBoxSets; // 0x0
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 32
|
|
struct FeVertexMapDesc_t
|
|
{
|
|
public:
|
|
CUtlString sName; // 0x0
|
|
uint32_t nNameHash; // 0x8
|
|
uint32_t nFlags; // 0xc
|
|
uint16_t nVertexBase; // 0x10
|
|
uint16_t nVertexCount; // 0x12
|
|
uint32_t nMapOffset; // 0x14
|
|
uint32_t nNodeListOffset; // 0x18
|
|
uint16_t nNodeListCount; // 0x1c
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 64
|
|
struct PermModelExtPart_t
|
|
{
|
|
public:
|
|
CTransform m_Transform; // 0x0
|
|
CUtlString m_Name; // 0x20
|
|
int32_t m_nParent; // 0x28
|
|
CStrongHandle< InfoForResourceTypeCModel > m_refModel; // 0x30
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 64
|
|
class CFootDefinition
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
CUtlString m_ankleBoneName; // 0x8
|
|
CUtlString m_toeBoneName; // 0x10
|
|
Vector m_vBallOffset; // 0x18
|
|
Vector m_vHeelOffset; // 0x24
|
|
float m_flFootLength; // 0x30
|
|
float m_flBindPoseDirectionMS; // 0x34
|
|
float m_flTraceHeight; // 0x38
|
|
float m_flTraceRadius; // 0x3c
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 112
|
|
class CConstraintTarget
|
|
{
|
|
public:
|
|
uint32_t m_nBoneHash; // 0x0
|
|
float m_flWeight; // 0x4
|
|
Vector m_vOffset; // 0x8
|
|
Quaternion m_qOffset; // 0x14
|
|
bool m_bIsAttachment; // 0x24
|
|
CUtlString m_sName; // 0x28
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 20
|
|
struct FeCtrlSoftOffset_t
|
|
{
|
|
public:
|
|
uint16_t nCtrlParent; // 0x0
|
|
uint16_t nCtrlChild; // 0x2
|
|
Vector vOffset; // 0x4
|
|
float flAlpha; // 0x10
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 256
|
|
struct VPhysXConstraint2_t
|
|
{
|
|
public:
|
|
uint32_t m_nFlags; // 0x0
|
|
uint16_t m_nParent; // 0x4
|
|
uint16_t m_nChild; // 0x6
|
|
VPhysXConstraintParams_t m_params; // 0x8
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 136
|
|
class CFeMorphLayer
|
|
{
|
|
public:
|
|
CUtlString m_Name; // 0x0
|
|
uint32_t m_nNameHash; // 0x8
|
|
CUtlVector< uint16 > m_Nodes; // 0x10
|
|
CUtlVector< Vector > m_InitPos; // 0x28
|
|
CUtlVector< float32 > m_Gravity; // 0x40
|
|
CUtlVector< float32 > m_GoalStrength; // 0x58
|
|
CUtlVector< float32 > m_GoalDamping; // 0x70
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 16
|
|
struct RnBlendVertex_t
|
|
{
|
|
public:
|
|
uint16_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
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 112
|
|
class CBaseConstraint : public CBoneConstraintBase
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x28
|
|
Vector m_vUpVector; // 0x30
|
|
CUtlVector< CConstraintSlave > m_slaves; // 0x40
|
|
CUtlVector< CConstraintTarget > m_targets; // 0x58
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 144
|
|
struct ModelSkeletonData_t
|
|
{
|
|
public:
|
|
CUtlVector< CUtlString > m_boneName; // 0x0
|
|
CUtlVector< int16 > m_nParent; // 0x18
|
|
CUtlVector< float32 > m_boneSphere; // 0x30
|
|
CUtlVector< uint32 > m_nFlag; // 0x48
|
|
CUtlVector< Vector > m_bonePosParent; // 0x60
|
|
CUtlVector< Quaternion > m_boneRotParent; // 0x78
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct RnSoftbodySpring_t
|
|
{
|
|
public:
|
|
uint16[2] m_nParticle; // 0x0
|
|
float m_flLength; // 0x4
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 112
|
|
class CHitBox
|
|
{
|
|
public:
|
|
Vector m_vMinBounds; // 0x20
|
|
Vector m_vMaxBounds; // 0x2c
|
|
CUtlString m_name; // 0x38
|
|
CUtlString m_sSurfaceProperty; // 0x40
|
|
CUtlString m_sBoneName; // 0x48
|
|
float m_flShapeRadius; // 0x50
|
|
uint32_t m_nBoneNameHash; // 0x54
|
|
int32_t m_nGroupId; // 0x58
|
|
Color m_cRenderColor; // 0x5c
|
|
uint16_t m_nHitBoxIndex; // 0x60
|
|
uint8_t m_nShapeType; // 0x62
|
|
bool m_bTranslationOnly; // 0x64
|
|
bool m_bVisible; // 0x65
|
|
bool m_bSelected; // 0x66
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 24
|
|
struct VertexPositionNormal_t
|
|
{
|
|
public:
|
|
Vector m_vPosition; // 0x0
|
|
Vector m_vNormal; // 0xc
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 192
|
|
class CMaterialDrawDescriptor
|
|
{
|
|
public:
|
|
RenderPrimitiveType_t m_nPrimitiveType; // 0x0
|
|
int32_t m_nBaseVertex; // 0x4
|
|
int32_t m_nVertexCount; // 0x8
|
|
int32_t m_nStartIndex; // 0xc
|
|
int32_t m_nIndexCount; // 0x10
|
|
int32_t m_nStartInstance; // 0x14
|
|
int32_t m_nInstanceCount; // 0x18
|
|
float m_flUvDensity; // 0x1c
|
|
// MDefaultString
|
|
Vector m_vTintColor; // 0x24
|
|
int16_t m_CullDataIndex; // 0x32
|
|
int32_t m_nMeshID; // 0x34
|
|
CRenderBufferBinding m_indexBuffer; // 0xa0
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_material; // 0xb8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 136
|
|
class CAimConstraint : public CBaseConstraint, CBoneConstraintBase
|
|
{
|
|
public:
|
|
Quaternion m_qAimOffset; // 0x70
|
|
uint32_t m_nUpType; // 0x80
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 56
|
|
class CMorphBundleData
|
|
{
|
|
public:
|
|
float m_flULeftSrc; // 0x0
|
|
float m_flVTopSrc; // 0x4
|
|
CUtlVector< float32 > m_offsets; // 0x8
|
|
CUtlVector< float32 > m_ranges; // 0x20
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 32
|
|
struct MaterialGroup_t
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
CUtlVector< CStrongHandle< InfoForResourceTypeIMaterial2 > > m_materials; // 0x8
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 136
|
|
struct RnMesh_t
|
|
{
|
|
public:
|
|
Vector m_vMin; // 0x0
|
|
Vector m_vMax; // 0xc
|
|
CUtlVector< RnNode_t > m_Nodes; // 0x18
|
|
CUtlVectorSIMDPaddedVector m_Vertices; // 0x30
|
|
CUtlVector< RnTriangle_t > m_Triangles; // 0x48
|
|
CUtlVector< uint8 > m_Materials; // 0x60
|
|
Vector m_vOrthographicAreas; // 0x78
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 8
|
|
struct FeFollowNode_t
|
|
{
|
|
public:
|
|
uint16_t nParentNode; // 0x0
|
|
uint16_t nChildNode; // 0x2
|
|
float flWeight; // 0x4
|
|
};
|
|
|
|
// Aligment: 12
|
|
// Size: 72
|
|
struct OldFeEdge_t
|
|
{
|
|
public:
|
|
float32[3] m_flK; // 0x0
|
|
float 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
|
|
float32[4] flAxialModelWeights; // 0x30
|
|
uint16[4] m_nNode; // 0x40
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 4
|
|
class CAnimCycle : public CCycleBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct VPhysXRange_t
|
|
{
|
|
public:
|
|
float m_flMin; // 0x0
|
|
float m_flMax; // 0x4
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 208
|
|
class CFeNamedJiggleBone
|
|
{
|
|
public:
|
|
CUtlString m_strParentBone; // 0x0
|
|
CTransform m_transform; // 0x10
|
|
uint32_t m_nJiggleParent; // 0x30
|
|
CFeJiggleBone m_jiggleBone; // 0x34
|
|
};
|
|
|
|
// Aligment: 16
|
|
// Size: 312
|
|
struct VPhysXAggregateData_t
|
|
{
|
|
public:
|
|
uint16_t m_nFlags; // 0x0
|
|
uint16_t m_nRefCounter; // 0x2
|
|
CUtlVector< uint32 > m_bonesHash; // 0x8
|
|
CUtlVector< CUtlString > m_boneNames; // 0x20
|
|
CUtlVector< uint16 > m_indexNames; // 0x38
|
|
CUtlVector< uint16 > m_indexHash; // 0x50
|
|
CUtlVector< matrix3x4a_t > m_bindPose; // 0x68
|
|
CUtlVector< VPhysXBodyPart_t > m_parts; // 0x80
|
|
CUtlVector< VPhysXConstraint2_t > m_constraints2; // 0x98
|
|
CUtlVector< VPhysXJoint_t > m_joints; // 0xb0
|
|
PhysFeModelDesc_t* m_pFeModel; // 0xc8
|
|
CUtlVector< uint16 > m_boneParents; // 0xd0
|
|
CUtlVector< uint32 > m_surfacePropertyHashes; // 0xe8
|
|
CUtlVector< VPhysXCollisionAttributes_t > m_collisionAttributes; // 0x100
|
|
CUtlVector< CUtlString > m_debugPartNames; // 0x118
|
|
CUtlString m_embeddedKeyvalues; // 0x130
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 28
|
|
struct RnCapsule_t
|
|
{
|
|
public:
|
|
Vector[2] m_vCenter; // 0x0
|
|
float m_flRadius; // 0x18
|
|
};
|
|
|
|
// Aligment: 23
|
|
// Size: 176
|
|
struct VPhysXJoint_t
|
|
{
|
|
public:
|
|
uint16_t m_nType; // 0x0
|
|
uint16_t m_nBody1; // 0x2
|
|
uint16_t m_nBody2; // 0x4
|
|
uint16_t m_nFlags; // 0x6
|
|
CTransform m_Frame1; // 0x10
|
|
CTransform m_Frame2; // 0x30
|
|
bool m_bEnableCollision; // 0x50
|
|
bool m_bEnableLinearLimit; // 0x51
|
|
VPhysXRange_t m_LinearLimit; // 0x54
|
|
bool m_bEnableLinearMotor; // 0x5c
|
|
Vector m_vLinearTargetVelocity; // 0x60
|
|
float m_flMaxForce; // 0x6c
|
|
bool m_bEnableSwingLimit; // 0x70
|
|
VPhysXRange_t m_SwingLimit; // 0x74
|
|
bool m_bEnableTwistLimit; // 0x7c
|
|
VPhysXRange_t m_TwistLimit; // 0x80
|
|
bool m_bEnableAngularMotor; // 0x88
|
|
Vector m_vAngularTargetVelocity; // 0x8c
|
|
float m_flMaxTorque; // 0x98
|
|
float m_flLinearFrequency; // 0x9c
|
|
float m_flLinearDampingRatio; // 0xa0
|
|
float m_flAngularFrequency; // 0xa4
|
|
float m_flAngularDampingRatio; // 0xa8
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 16
|
|
class CDrawCullingData
|
|
{
|
|
public:
|
|
Vector m_vConeApex; // 0x0
|
|
int8[3] m_ConeAxis; // 0xc
|
|
int8_t m_ConeCutoff; // 0xf
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 16
|
|
struct FeNodeIntegrator_t
|
|
{
|
|
public:
|
|
float flPointDamping; // 0x0
|
|
float flAnimationForceAttraction; // 0x4
|
|
float flAnimationVertexAttraction; // 0x8
|
|
float flGravity; // 0xc
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 136
|
|
class CAttachment
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
CUtlString[3] m_influenceNames; // 0x8
|
|
Vector[3] m_vInfluenceOffsets; // 0x20
|
|
Quaternion[3] m_vInfluenceRotations; // 0x44
|
|
float32[3] m_influenceWeights; // 0x74
|
|
bool[3] m_bInfluenceRootTransform; // 0x80
|
|
uint8_t m_nInfluences; // 0x83
|
|
bool m_bIgnoreRotation; // 0x84
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
struct FeProxyVertexMap_t
|
|
{
|
|
public:
|
|
CUtlString m_Name; // 0x0
|
|
float m_flWeight; // 0x8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 32
|
|
class CMorphData
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
CUtlVector< CMorphRectData > m_morphRectDatas; // 0x8
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 40
|
|
struct ModelBoneFlexDriver_t
|
|
{
|
|
public:
|
|
CUtlString m_boneName; // 0x0
|
|
uint32_t m_boneNameToken; // 0x8
|
|
CUtlVector< ModelBoneFlexDriverControl_t > m_controls; // 0x10
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 12
|
|
struct RnTriangle_t
|
|
{
|
|
public:
|
|
int32[3] m_nIndex; // 0x0
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
struct FeSimdAnimStrayRadius_t
|
|
{
|
|
public:
|
|
uint16[4][2] nNode; // 0x0
|
|
fltx4 flMaxDist; // 0x10
|
|
fltx4 flRelaxationFactor; // 0x20
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 48
|
|
struct FeBuildSphereRigid_t : public FeSphereRigid_t
|
|
{
|
|
public:
|
|
int32_t m_nPriority; // 0x20
|
|
uint32_t m_nVertexMapHash; // 0x24
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
struct RnSphere_t
|
|
{
|
|
public:
|
|
Vector m_vCenter; // 0x0
|
|
float m_flRadius; // 0xc
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 80
|
|
struct FeSimdRodConstraint_t
|
|
{
|
|
public:
|
|
uint16[4][2] nNode; // 0x0
|
|
fltx4 f4MaxDist; // 0x10
|
|
fltx4 f4MinDist; // 0x20
|
|
fltx4 f4Weight0; // 0x30
|
|
fltx4 f4RelaxationFactor; // 0x40
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 20
|
|
struct FeTaperedCapsuleStretch_t
|
|
{
|
|
public:
|
|
uint16[2] nNode; // 0x0
|
|
uint16_t nCollisionMask; // 0x4
|
|
// MPropertySuppressField
|
|
uint16_t nDummy; // 0x6
|
|
float32[2] flRadius; // 0x8
|
|
float flStickiness; // 0x10
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 20
|
|
struct FeBandBendLimit_t
|
|
{
|
|
public:
|
|
float flDistMin; // 0x0
|
|
float flDistMax; // 0x4
|
|
uint16[6] nNode; // 0x8
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 88
|
|
struct PermModelInfo_t
|
|
{
|
|
public:
|
|
uint32_t m_nFlags; // 0x0
|
|
Vector m_vHullMin; // 0x4
|
|
Vector m_vHullMax; // 0x10
|
|
Vector m_vViewMin; // 0x1c
|
|
Vector m_vViewMax; // 0x28
|
|
float m_flMass; // 0x34
|
|
Vector m_vEyePosition; // 0x38
|
|
float m_flMaxEyeDeflection; // 0x44
|
|
CUtlString m_sSurfaceProperty; // 0x48
|
|
CUtlString m_keyValueText; // 0x50
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
struct VPhysXCollisionAttributes_t
|
|
{
|
|
public:
|
|
CUtlVector< CUtlString > m_PhysicsTagStrings; // 0x0
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 164
|
|
class CFeIndexedJiggleBone
|
|
{
|
|
public:
|
|
uint32_t m_nNode; // 0x0
|
|
uint32_t m_nJiggleParent; // 0x4
|
|
CFeJiggleBone m_jiggleBone; // 0x8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 96
|
|
struct FeBuildBoxRigid_t : public FeBoxRigid_t
|
|
{
|
|
public:
|
|
int32_t m_nPriority; // 0x50
|
|
uint32_t m_nVertexMapHash; // 0x54
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 4
|
|
class CFootCycle : public CCycleBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 96
|
|
class CSceneObjectData
|
|
{
|
|
public:
|
|
Vector m_vMinBounds; // 0x0
|
|
Vector m_vMaxBounds; // 0xc
|
|
CUtlVector< CMaterialDrawDescriptor > m_drawCalls; // 0x20
|
|
CUtlVector< CDrawCullingData > m_drawCullData; // 0x38
|
|
Vector4D m_vTintColor; // 0x50
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 40
|
|
class CFootMotion
|
|
{
|
|
public:
|
|
CUtlVector< CFootStride > m_strides; // 0x0
|
|
CUtlString m_name; // 0x18
|
|
bool m_bAdditive; // 0x20
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 16
|
|
struct vmix_pitch_shift_desc_t
|
|
{
|
|
public:
|
|
int32_t m_nGrainSampleCount; // 0x0
|
|
float m_flPitchShift; // 0x4
|
|
int32_t m_nQuality; // 0x8
|
|
int32_t m_nProcType; // 0xc
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 32
|
|
class CSosGroupActionTimeLimitSchema : public CSosGroupActionSchema
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Max Time"
|
|
float m_flMaxDuration; // 0x18
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 40
|
|
class CSosGroupActionLimitSchema : public CSosGroupActionSchema
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Max Count"
|
|
int32_t m_nMaxCount; // 0x18
|
|
// MPropertyAttributeChoiceEnumName
|
|
// MPropertyFriendlyName "Stop Type"
|
|
SosActionStopType_t m_nStopType; // 0x1c
|
|
// MPropertyAttributeChoiceEnumName
|
|
// MPropertyFriendlyName "Sort Type"
|
|
SosActionSortType_t m_nSortType; // 0x20
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 16
|
|
struct vmix_filter_desc_t
|
|
{
|
|
public:
|
|
vmix_filter_type_t m_nFilterType; // 0x0
|
|
bool m_bEnabled; // 0x2
|
|
float m_fldbGain; // 0x4
|
|
float m_flCutoffFreq; // 0x8
|
|
float m_flQ; // 0xc
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 48
|
|
struct SosEditItemInfo_t
|
|
{
|
|
public:
|
|
SosEditItemType_t itemType; // 0x0
|
|
CUtlString itemName; // 0x8
|
|
CUtlString itemTypeName; // 0x10
|
|
CUtlString itemKVString; // 0x20
|
|
Vector2D itemPos; // 0x28
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 40
|
|
class CSosGroupMatchPattern : public CSosGroupBranchPattern
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Event Name"
|
|
CUtlString m_matchSoundEventName; // 0x10
|
|
// MPropertyFriendlyName "Sub-String"
|
|
CUtlString m_matchSoundEventSubString; // 0x18
|
|
// MPropertyFriendlyName "Entity Index"
|
|
float m_flEntIndex; // 0x20
|
|
// MPropertyFriendlyName "Operator Variable Value"
|
|
float m_flOpvar; // 0x24
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
class CSosSoundEventGroupListSchema
|
|
{
|
|
public:
|
|
// MPropertyAutoExpandGroup
|
|
// MPropertyFriendlyName "Groups"
|
|
CUtlVector< CSosSoundEventGroupSchema > m_groupList; // 0x0
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 40
|
|
struct vmix_dynamics_desc_t
|
|
{
|
|
public:
|
|
float 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
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 16
|
|
class CSosGroupBranchPattern
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Event Name"
|
|
bool m_bMatchEventName; // 0x8
|
|
// MPropertyFriendlyName "Sub-String"
|
|
bool m_bMatchEventSubString; // 0x9
|
|
// MPropertyFriendlyName "Source Entity Index"
|
|
bool m_bMatchEntIndex; // 0xa
|
|
// MPropertyFriendlyName "Operator Variable"
|
|
bool m_bMatchOpvar; // 0xb
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 208
|
|
class CSosSoundEventGroupSchema
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Group Name"
|
|
CUtlString m_name; // 0x0
|
|
// MPropertyAttributeChoiceEnumName
|
|
// MPropertyFriendlyName "Group Type"
|
|
SosGroupType_t m_nType; // 0x8
|
|
// MPropertyFriendlyName "Blocks Events"
|
|
bool m_bIsBlocking; // 0xc
|
|
// MPropertyFriendlyName "Block Max Count"
|
|
int32_t m_nBlockMaxCount; // 0x10
|
|
// MPropertyFriendlyName "Invert Match"
|
|
bool m_bInvertMatch; // 0x14
|
|
// MPropertyFriendlyName "Match Rules"
|
|
CSosGroupMatchPattern m_matchPattern; // 0x18
|
|
// MPropertyFriendlyName "Branch Rules"
|
|
CSosGroupBranchPattern m_branchPattern; // 0x40
|
|
// MPropertyFriendlyName "Actions"
|
|
CSosGroupActionSchema*[4] m_vActions; // 0xb0
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 24
|
|
class CSosGroupActionSchema
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Name"
|
|
CUtlString m_name; // 0x8
|
|
// MPropertyFriendlyName "Action Type"
|
|
ActionType_t m_actionType; // 0x10
|
|
// MPropertySuppressField
|
|
ActionType_t m_actionInstanceType; // 0x14
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 12
|
|
struct vmix_envelope_desc_t
|
|
{
|
|
public:
|
|
float m_flAttackTimeMS; // 0x0
|
|
float m_flHoldTimeMS; // 0x4
|
|
float m_flReleaseTimeMS; // 0x8
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
struct SelectedEditItemInfo_t
|
|
{
|
|
public:
|
|
CUtlVector< SosEditItemInfo_t > m_EditItems; // 0x0
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 40
|
|
struct vmix_vocoder_desc_t
|
|
{
|
|
public:
|
|
int32_t m_nBandCount; // 0x0
|
|
float 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
|
|
int32_t m_nDebugBand; // 0x20
|
|
bool m_bPeakMode; // 0x24
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 128
|
|
struct vmix_eq8_desc_t
|
|
{
|
|
public:
|
|
vmix_filter_desc_t[8] m_stages; // 0x0
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 40
|
|
struct vmix_delay_desc_t
|
|
{
|
|
public:
|
|
vmix_filter_desc_t m_feedbackFilter; // 0x0
|
|
bool m_bEnableFilter; // 0x10
|
|
float m_flDelay; // 0x14
|
|
float m_flDirectGain; // 0x18
|
|
float m_flDelayGain; // 0x1c
|
|
float m_flFeedbackGain; // 0x20
|
|
float m_flWidth; // 0x24
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
class CSSDSMsg_EndFrame
|
|
{
|
|
public:
|
|
CUtlVector< CSSDSEndFrameViewInfo > m_Views; // 0x0
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 24
|
|
class CSSDSMsg_ViewRender
|
|
{
|
|
public:
|
|
SceneViewId_t m_viewId; // 0x0
|
|
CUtlString m_ViewName; // 0x10
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 48
|
|
class CSSDSMsg_ViewTargetList
|
|
{
|
|
public:
|
|
SceneViewId_t m_viewId; // 0x0
|
|
CUtlString m_ViewName; // 0x10
|
|
CUtlVector< CSSDSMsg_ViewTarget > m_Targets; // 0x18
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 56
|
|
class CSSDSMsg_PreLayer : public CSSDSMsg_LayerBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 56
|
|
class CSSDSMsg_LayerBase
|
|
{
|
|
public:
|
|
SceneViewId_t m_viewId; // 0x0
|
|
CUtlString m_ViewName; // 0x10
|
|
int32_t m_nLayerIndex; // 0x18
|
|
uint64_t m_nLayerId; // 0x20
|
|
CUtlString m_LayerName; // 0x28
|
|
CUtlString m_displayText; // 0x30
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 56
|
|
class CSSDSMsg_PostLayer : public CSSDSMsg_LayerBase
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
class CSSDSEndFrameViewInfo
|
|
{
|
|
public:
|
|
uint64_t m_nViewId; // 0x0
|
|
CUtlString m_ViewName; // 0x8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
struct SceneViewId_t
|
|
{
|
|
public:
|
|
uint64_t m_nViewId; // 0x0
|
|
uint64_t m_nFrameCount; // 0x8
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 48
|
|
class CSSDSMsg_ViewTarget
|
|
{
|
|
public:
|
|
CUtlString m_Name; // 0x0
|
|
uint64_t m_TextureId; // 0x8
|
|
int32_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
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 216
|
|
class CVoxelVisibility
|
|
{
|
|
public:
|
|
CUtlVector< uint32 > m_blockOffset; // 0x40
|
|
CUtlVector< voxel_vis_cluster_t > m_clusters; // 0x58
|
|
CUtlVector< uint16 > m_mergeClusters; // 0x70
|
|
CUtlVector< voxel_vis_mergelist_t > m_mergeLists; // 0x88
|
|
Vector m_vMinBounds; // 0xa0
|
|
Vector m_vMaxBounds; // 0xac
|
|
float m_flGridSize; // 0xb8
|
|
int32_t m_nNodeCount; // 0xbc
|
|
int32_t m_nRegionCount; // 0xc0
|
|
voxel_vis_cluster_t m_skyVisibilityCluster; // 0xc4
|
|
voxel_vis_compression_t m_nPVSCompression; // 0xcc
|
|
uint32_t m_nTreeSize; // 0xd0
|
|
uint32_t m_nPVSSizeCompressed; // 0xd4
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 48
|
|
struct EntityKeyValueData_t
|
|
{
|
|
public:
|
|
CUtlBinaryBlock m_keyValuesData; // 0x0
|
|
CUtlVector< EntityIOConnectionData_t > m_connections; // 0x18
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 24
|
|
struct MaterialOverride_t : public BaseSceneObjectOverride_t
|
|
{
|
|
public:
|
|
uint32_t m_nSubSceneObject; // 0x4
|
|
uint32_t m_nDrawCallIndex; // 0x8
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_pMaterial; // 0x10
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 112
|
|
struct InfoOverlayData_t
|
|
{
|
|
public:
|
|
matrix3x4_t m_transform; // 0x0
|
|
float m_flWidth; // 0x30
|
|
float m_flHeight; // 0x34
|
|
float m_flDepth; // 0x38
|
|
Vector2D m_vUVStart; // 0x3c
|
|
Vector2D m_vUVEnd; // 0x44
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_pMaterial; // 0x50
|
|
int32_t m_nRenderOrder; // 0x58
|
|
Vector4D m_vTintColor; // 0x5c
|
|
int32_t m_nSequenceOverride; // 0x6c
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 200
|
|
struct World_t
|
|
{
|
|
public:
|
|
WorldBuilderParams_t m_builderParams; // 0x0
|
|
CUtlVector< NodeData_t > m_worldNodes; // 0x68
|
|
BakedLightingInfo_t m_worldLightingInfo; // 0x80
|
|
CUtlVector< CStrongHandleCopyable< InfoForResourceTypeCEntityLump > > m_entityLumps; // 0xb0
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 56
|
|
struct AggregateMeshInfo_t
|
|
{
|
|
public:
|
|
Vector4D m_vTintColor; // 0x0
|
|
Vector[2] m_vWorldBounds; // 0x10
|
|
uint16_t m_nDrawDescriptorIndex; // 0x28
|
|
uint16_t m_nVisClusterMemberOffset; // 0x2a
|
|
uint8_t m_nVisClusterMemberCount; // 0x2c
|
|
uint8_t _pad; // 0x2d
|
|
int32_t m_nCubeMapPrecomputedHandshake; // 0x30
|
|
ObjectTypeFlags_t m_objectFlags; // 0x34
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 56
|
|
struct WorldNodeOnDiskBufferData_t
|
|
{
|
|
public:
|
|
int32_t m_nElementCount; // 0x0
|
|
int32_t m_nElementSizeInBytes; // 0x4
|
|
CUtlVector< RenderInputLayoutField_t > m_inputLayoutFields; // 0x8
|
|
CUtlVector< uint8 > m_pData; // 0x20
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
struct InfoForResourceTypeVMapResourceData_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct voxel_vis_mergelist_t
|
|
{
|
|
public:
|
|
uint32_t m_nFirstCluster; // 0x0
|
|
uint32_t m_nClusterCount; // 0x4
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 48
|
|
struct BakedLightingInfo_t
|
|
{
|
|
public:
|
|
uint32_t m_nLightmapVersionNumber; // 0x0
|
|
uint32_t m_nLightmapGameVersionNumber; // 0x4
|
|
Vector2D m_vLightmapUvScale; // 0x8
|
|
bool m_bHasLightmaps; // 0x10
|
|
CUtlVector< CStrongHandle< InfoForResourceTypeCTextureBase > > m_lightMaps; // 0x18
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct voxel_vis_cluster_t
|
|
{
|
|
public:
|
|
uint32_t m_nBlockIndex; // 0x0
|
|
uint32_t m_nOffsetIntoBlock; // 0x4
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 48
|
|
struct EntityIOConnectionData_t
|
|
{
|
|
public:
|
|
CUtlString m_outputName; // 0x0
|
|
uint32_t m_targetType; // 0x8
|
|
CUtlString m_targetName; // 0x10
|
|
CUtlString m_inputName; // 0x18
|
|
CUtlString m_overrideParam; // 0x20
|
|
float m_flDelay; // 0x28
|
|
int32_t m_nTimesToFire; // 0x2c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
struct BaseSceneObjectOverride_t
|
|
{
|
|
public:
|
|
uint32_t m_nSceneObjectIndex; // 0x0
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 320
|
|
struct WorldNode_t
|
|
{
|
|
public:
|
|
CUtlVector< SceneObject_t > m_sceneObjects; // 0x0
|
|
CUtlVector< InfoOverlayData_t > m_infoOverlays; // 0x18
|
|
CUtlVector< uint16 > m_visClusterMembership; // 0x30
|
|
CUtlVector< AABB_t > m_boundsGroups; // 0x48
|
|
CUtlVector< AggregateSceneObject_t > m_aggregateSceneObjects; // 0x60
|
|
CUtlVector< ExtraVertexStreamOverride_t > m_extraVertexStreamOverrides; // 0x78
|
|
CUtlVector< MaterialOverride_t > m_materialOverrides; // 0x90
|
|
CUtlVector< WorldNodeOnDiskBufferData_t > m_extraVertexStreams; // 0xa8
|
|
CUtlVector< CUtlString > m_layerNames; // 0xc0
|
|
CUtlVector< uint8 > m_sceneObjectLayerIndices; // 0xd8
|
|
CUtlVector< uint8 > m_overlayLayerIndices; // 0xf0
|
|
CUtlString m_grassFileName; // 0x108
|
|
BakedLightingInfo_t m_nodeLightingInfo; // 0x110
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 80
|
|
struct PermEntityLumpData_t
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
CUtlString m_hammerUniqueId; // 0x8
|
|
EntityLumpFlags_t m_flags; // 0x10
|
|
CUtlString m_manifestName; // 0x18
|
|
CUtlVector< CStrongHandleCopyable< InfoForResourceTypeCEntityLump > > m_childLumps; // 0x20
|
|
CUtlVector< EntityKeyValueData_t > m_entityKeyValues; // 0x38
|
|
};
|
|
|
|
// Aligment: 21
|
|
// Size: 104
|
|
struct WorldBuilderParams_t
|
|
{
|
|
public:
|
|
int32_t m_nSizeBytesPerVoxel; // 0x0
|
|
float m_flMinDrawVolumeSize; // 0x4
|
|
float m_flMinDistToCamera; // 0x8
|
|
float m_flMinAtlasDist; // 0xc
|
|
float m_flMinSimplifiedDist; // 0x10
|
|
float m_flHorzFOV; // 0x14
|
|
float m_flHalfScreenWidth; // 0x18
|
|
int32_t m_nAtlasTextureSizeX; // 0x1c
|
|
int32_t m_nAtlasTextureSizeY; // 0x20
|
|
int32_t m_nUniqueTextureSizeX; // 0x24
|
|
int32_t m_nUniqueTextureSizeY; // 0x28
|
|
int32_t m_nCompressedAtlasSize; // 0x2c
|
|
float m_flGutterSize; // 0x30
|
|
float m_flUVMapThreshold; // 0x34
|
|
Vector m_vWorldUnitsPerTile; // 0x38
|
|
int32_t m_nMaxTexScaleSlots; // 0x44
|
|
bool m_bWrapInAtlas; // 0x48
|
|
bool m_bBuildBakedLighting; // 0x49
|
|
Vector2D m_vLightmapUvScale; // 0x4c
|
|
uint64_t m_nCompileTimestamp; // 0x58
|
|
uint64_t m_nCompileFingerprint; // 0x60
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
struct VMapResourceData_t
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 80
|
|
struct NodeData_t
|
|
{
|
|
public:
|
|
int32_t m_Flags; // 0x0
|
|
int32_t m_nParent; // 0x4
|
|
Vector m_vOrigin; // 0x8
|
|
Vector m_vMinBounds; // 0x14
|
|
Vector m_vMaxBounds; // 0x20
|
|
float m_flMinimumDistance; // 0x2c
|
|
CUtlVector< int32 > m_ChildNodeIndices; // 0x30
|
|
CUtlString m_worldNodePrefix; // 0x48
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 96
|
|
struct AggregateSceneObject_t
|
|
{
|
|
public:
|
|
Vector[2] m_vWorldBounds; // 0x0
|
|
ObjectTypeFlags_t m_allFlags; // 0x18
|
|
ObjectTypeFlags_t m_anyFlags; // 0x1c
|
|
int16_t m_nLayer; // 0x20
|
|
int16_t m_nBoundsGroupIndex; // 0x22
|
|
CUtlVector< AggregateMeshInfo_t > m_aggregateMeshes; // 0x28
|
|
CUtlVector< uint16 > m_visClusterMembership; // 0x40
|
|
CStrongHandle< InfoForResourceTypeCModel > m_renderableModel; // 0x58
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 32
|
|
struct ExtraVertexStreamOverride_t : public BaseSceneObjectOverride_t
|
|
{
|
|
public:
|
|
uint32_t m_nSubSceneObject; // 0x4
|
|
uint32_t m_nDrawCallIndex; // 0x8
|
|
MeshDrawPrimitiveFlags_t m_nAdditionalMeshDrawPrimitiveFlags; // 0xc
|
|
CRenderBufferBinding m_extraBufferBinding; // 0x10
|
|
};
|
|
|
|
// Aligment: 16
|
|
// Size: 144
|
|
struct SceneObject_t
|
|
{
|
|
public:
|
|
uint32_t m_nObjectID; // 0x0
|
|
Vector4D[3] m_vTransform; // 0x4
|
|
float m_flFadeStartDistance; // 0x34
|
|
float m_flFadeEndDistance; // 0x38
|
|
Vector4D m_vTintColor; // 0x3c
|
|
CUtlString m_skin; // 0x50
|
|
ObjectTypeFlags_t m_nObjectTypeFlags; // 0x58
|
|
Vector m_vLightingOrigin; // 0x5c
|
|
uint32_t m_nLightGroup; // 0x68
|
|
int16_t m_nOverlayRenderOrder; // 0x6c
|
|
int16_t m_nLODOverride; // 0x6e
|
|
int32_t m_nCubeMapPrecomputedHandshake; // 0x70
|
|
int32_t m_nLightProbeVolumePrecomputedHandshake; // 0x74
|
|
int16_t m_nBoundsGroupIndex; // 0x78
|
|
CStrongHandle< InfoForResourceTypeCModel > m_renderableModel; // 0x80
|
|
CStrongHandle< InfoForResourceTypeCRenderMesh > m_renderable; // 0x88
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 40
|
|
class CParticleProperty
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_LerpEndCapScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "value to lerp to"
|
|
// MDefaultString
|
|
float m_flOutput; // 0x184
|
|
// MPropertyFriendlyName "lerp time"
|
|
// MDefaultString
|
|
float m_flLerpTime; // 0x188
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 432
|
|
class C_OP_CPOffsetToPercentageBetweenCPs : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "percentage minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x180
|
|
// MPropertyFriendlyName "percentage maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x184
|
|
// MPropertyFriendlyName "percentage bias"
|
|
// MDefaultString
|
|
float m_flInputBias; // 0x188
|
|
// MPropertyFriendlyName "starting control point"
|
|
// MDefaultString
|
|
int32_t m_nStartCP; // 0x18c
|
|
// MPropertyFriendlyName "ending control point"
|
|
// MDefaultString
|
|
int32_t m_nEndCP; // 0x190
|
|
// MPropertyFriendlyName "offset control point"
|
|
// MDefaultString
|
|
int32_t m_nOffsetCP; // 0x194
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOuputCP; // 0x198
|
|
// MPropertyFriendlyName "input control point"
|
|
// MDefaultString
|
|
int32_t m_nInputCP; // 0x19c
|
|
// MPropertyFriendlyName "treat distance between points as radius"
|
|
// MDefaultString
|
|
bool m_bRadialCheck; // 0x1a0
|
|
// MPropertyFriendlyName "treat offset as scale of total distance"
|
|
// MDefaultString
|
|
bool m_bScaleOffset; // 0x1a1
|
|
// MPropertyFriendlyName "offset amount"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecOffset; // 0x1a4
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 1472
|
|
class C_INIT_InitVecCollection : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "value"
|
|
CParticleCollectionVecInput m_InputValue; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nOutputField; // 0x5b0
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 656
|
|
class C_OP_RotateVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "rotation axis min"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecRotAxisMin; // 0x184
|
|
// MPropertyFriendlyName "rotation axis max"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecRotAxisMax; // 0x190
|
|
// MPropertyFriendlyName "rotation rate min"
|
|
// MDefaultString
|
|
float m_flRotRateMin; // 0x19c
|
|
// MPropertyFriendlyName "rotation rate max"
|
|
// MDefaultString
|
|
float m_flRotRateMax; // 0x1a0
|
|
// MPropertyFriendlyName "normalize output"
|
|
// MDefaultString
|
|
bool m_bNormalize; // 0x1a4
|
|
// MPropertyFriendlyName "per particle scale"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flScale; // 0x1a8
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 464
|
|
class C_OP_RampScalarLinear : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "ramp rate min"
|
|
// MDefaultString
|
|
float m_RateMin; // 0x180
|
|
// MPropertyFriendlyName "ramp rate max"
|
|
// MDefaultString
|
|
float m_RateMax; // 0x184
|
|
// MPropertyFriendlyName "start time min"
|
|
// MDefaultString
|
|
float m_flStartTime_min; // 0x188
|
|
// MPropertyFriendlyName "start time max"
|
|
// MDefaultString
|
|
float m_flStartTime_max; // 0x18c
|
|
// MPropertyFriendlyName "end time min"
|
|
// MDefaultString
|
|
float m_flEndTime_min; // 0x190
|
|
// MPropertyFriendlyName "end time max"
|
|
// MDefaultString
|
|
float m_flEndTime_max; // 0x194
|
|
// MPropertyFriendlyName "ramp field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nField; // 0x1c0
|
|
// MPropertyFriendlyName "start/end proportional"
|
|
// MDefaultString
|
|
bool m_bProportionalOp; // 0x1c4
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 240
|
|
struct FloatInputMaterialVariable_t
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "material variable"
|
|
// MDefaultString
|
|
CUtlString m_strVariable; // 0x0
|
|
// MPropertyFriendlyName "input"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flInput; // 0x8
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 432
|
|
class C_OP_CycleScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "destination scalar field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nDestField; // 0x180
|
|
// MPropertyFriendlyName "Value at start of cycle"
|
|
// MDefaultString
|
|
float m_flStartValue; // 0x184
|
|
// MPropertyFriendlyName "Value at end of cycle"
|
|
// MDefaultString
|
|
float m_flEndValue; // 0x188
|
|
// MPropertyFriendlyName "Cycle time"
|
|
// MDefaultString
|
|
float m_flCycleTime; // 0x18c
|
|
// MPropertyFriendlyName "Do not repeat cycle"
|
|
// MDefaultString
|
|
bool m_bDoNotRepeatCycle; // 0x190
|
|
// MPropertyFriendlyName "Synchronize particles"
|
|
// MDefaultString
|
|
bool m_bSynchronizeParticles; // 0x191
|
|
// MPropertyFriendlyName "Scale Start/End Control Point"
|
|
// MDefaultString
|
|
int32_t m_nCPScale; // 0x194
|
|
// MPropertyFriendlyName "start scale control point field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nCPFieldMin; // 0x198
|
|
// MPropertyFriendlyName "end scale control point field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nCPFieldMax; // 0x19c
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x1a0
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 896
|
|
class C_OP_SetAttributeToScalarExpression : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "expression"
|
|
// MDefaultString
|
|
ScalarExpressionType_t m_nExpression; // 0x180
|
|
// MPropertyFriendlyName "input 1"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInput1; // 0x188
|
|
// MPropertyFriendlyName "input 2"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInput2; // 0x270
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nOutputField; // 0x358
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x35c
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 384
|
|
class C_OP_WorldCollideConstraint : public CParticleFunctionConstraint, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 512
|
|
class C_OP_RenderTreeShake : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "peak strength"
|
|
// MDefaultString
|
|
float m_flPeakStrength; // 0x1d0
|
|
// MPropertyFriendlyName "peak strength field override"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nPeakStrengthFieldOverride; // 0x1d4
|
|
// MPropertyFriendlyName "radius"
|
|
// MDefaultString
|
|
float m_flRadius; // 0x1d8
|
|
// MPropertyFriendlyName "strength field override"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nRadiusFieldOverride; // 0x1dc
|
|
// MPropertyFriendlyName "shake duration after end"
|
|
// MDefaultString
|
|
float m_flShakeDuration; // 0x1e0
|
|
// MPropertyFriendlyName "amount of time taken to smooth between different shake parameters"
|
|
// MDefaultString
|
|
float m_flTransitionTime; // 0x1e4
|
|
// MPropertyFriendlyName "Twist amount (-1..1)"
|
|
// MDefaultString
|
|
float m_flTwistAmount; // 0x1e8
|
|
// MPropertyFriendlyName "Radial Amount (-1..1)"
|
|
// MDefaultString
|
|
float m_flRadialAmount; // 0x1ec
|
|
// MPropertyFriendlyName "Control Point Orientation Amount (-1..1)"
|
|
// MDefaultString
|
|
float m_flControlPointOrientationAmount; // 0x1f0
|
|
// MPropertyFriendlyName "Control Point for Orientation Amount"
|
|
// MDefaultString
|
|
int32_t m_nControlPointForLinearDirection; // 0x1f4
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 880
|
|
class C_OP_SetPerChildControlPoint : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "group ID to affect"
|
|
// MDefaultString
|
|
int32_t m_nChildGroupID; // 0x180
|
|
// MPropertyFriendlyName "control point to set"
|
|
// MDefaultString
|
|
int32_t m_nFirstControlPoint; // 0x184
|
|
// MPropertyFriendlyName "# of children to set"
|
|
// MDefaultString
|
|
int32_t m_nNumControlPoints; // 0x188
|
|
// MPropertyFriendlyName "particle increment amount"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nParticleIncrement; // 0x190
|
|
// MPropertyFriendlyName "first particle to copy"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nFirstSourcePoint; // 0x278
|
|
// MPropertyFriendlyName "set orientation"
|
|
// MDefaultString
|
|
bool m_bSetOrientation; // 0x360
|
|
// MPropertyFriendlyName "set number of children based on particle count"
|
|
// MDefaultString
|
|
bool m_bNumBasedOnParticleCount; // 0x361
|
|
};
|
|
|
|
// Aligment: 42
|
|
// Size: 6528
|
|
class C_OP_RenderSprites : public CBaseRendererSource2, CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "sequence id override"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nSequenceOverride; // 0xca0
|
|
// MPropertyFriendlyName "orientation type"
|
|
// MPropertyAttributeChoiceEnumName
|
|
// MDefaultString
|
|
int32_t m_nOrientationType; // 0xd88
|
|
// MPropertyFriendlyName "orientation control point"
|
|
// MDefaultString
|
|
int32_t m_nOrientationControlPoint; // 0xd8c
|
|
// MPropertyFriendlyName "flip normal"
|
|
// MDefaultString
|
|
bool m_bFlipNormal; // 0xd90
|
|
// MPropertyFriendlyName "minimum visual size"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flMinSize; // 0xd94
|
|
// MPropertyFriendlyName "maximum visual size"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flMaxSize; // 0xd98
|
|
// MPropertyFriendlyName "Factor to map size adjustment to alpha"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flAlphaAdjustWithSizeAdjust; // 0xd9c
|
|
// MPropertyFriendlyName "size at which to start fading"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
CParticleCollectionFloatInput m_flStartFadeSize; // 0xda0
|
|
// MPropertyFriendlyName "size at which to fade away"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
CParticleCollectionFloatInput m_flEndFadeSize; // 0xe88
|
|
// MPropertyFriendlyName "start dot product value for fading as the particle normal becomes aligned with the view vector"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flStartFadeDot; // 0xf70
|
|
// MPropertyFriendlyName "end dot product value for fading as the particle normal becomes aligned with the view vector"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flEndFadeDot; // 0xf74
|
|
// MPropertyFriendlyName "depth comparison bias"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Depth buffer control and effects"
|
|
float m_flDepthBias; // 0xf78
|
|
// MPropertyFriendlyName "horizontal texture scale"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture UV control"
|
|
CParticleCollectionFloatInput m_flFinalTextureScaleU; // 0xf80
|
|
// MPropertyFriendlyName "vertical texture scale"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture UV control"
|
|
CParticleCollectionFloatInput m_flFinalTextureScaleV; // 0x1068
|
|
// MPropertyFriendlyName "horizontal texture offset"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture UV control"
|
|
CParticleCollectionFloatInput m_flFinalTextureOffsetU; // 0x1150
|
|
// MPropertyFriendlyName "vertical texture offset"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture UV control"
|
|
CParticleCollectionFloatInput m_flFinalTextureOffsetV; // 0x1238
|
|
// MPropertyFriendlyName "X offset of center point"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture UV control"
|
|
float m_flCenterXOffset; // 0x1320
|
|
// MPropertyFriendlyName "Y offset of center point"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture UV control"
|
|
float m_flCenterYOffset; // 0x1324
|
|
// MPropertyFriendlyName "intraframe zoom amount for sequence 0"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture UV control"
|
|
float m_flZoomAmount0; // 0x1328
|
|
// MPropertyFriendlyName "intraframe zoom amount for sequence 1"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture UV control"
|
|
float m_flZoomAmount1; // 0x132c
|
|
// MPropertyFriendlyName "distance alpha"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Distance to alpha coding"
|
|
bool m_bDistanceAlpha; // 0x1330
|
|
// MPropertyFriendlyName "use soft edges for distance alpha"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Distance to alpha coding"
|
|
bool m_bSoftEdges; // 0x1331
|
|
// MPropertyFriendlyName "start value for soft edges for distance alpha"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Distance to alpha coding"
|
|
float m_flEdgeSoftnessStart; // 0x1334
|
|
// MPropertyFriendlyName "end value for soft edges for distance alpha"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Distance to alpha coding"
|
|
float m_flEdgeSoftnessEnd; // 0x1338
|
|
// MPropertyFriendlyName "enable particle outlining"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Outlining"
|
|
bool m_bOutline; // 0x133c
|
|
// MPropertyFriendlyName "outline color"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Outlining"
|
|
Color m_OutlineColor; // 0x133d
|
|
// MPropertyFriendlyName "outline alpha"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 255"
|
|
// MPropertyGroupName "Outlining"
|
|
int32_t m_nOutlineAlpha; // 0x1344
|
|
// MPropertyFriendlyName "outline start 0"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Outlining"
|
|
float m_flOutlineStart0; // 0x1348
|
|
// MPropertyFriendlyName "outline start 1"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Outlining"
|
|
float m_flOutlineStart1; // 0x134c
|
|
// MPropertyFriendlyName "outline end 0"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Outlining"
|
|
float m_flOutlineEnd0; // 0x1350
|
|
// MPropertyFriendlyName "outline end 1"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Outlining"
|
|
float m_flOutlineEnd1; // 0x1354
|
|
// MPropertyFriendlyName "enable yaw for particles aligned to normals"
|
|
// MDefaultString
|
|
bool m_bUseYawWithNormalAligned; // 0x1358
|
|
// MPropertyFriendlyName "Normal Mapping"
|
|
// MDefaultString
|
|
bool m_bNormalMap; // 0x1359
|
|
// MPropertyFriendlyName "Bump Strength"
|
|
// MDefaultString
|
|
float m_flBumpStrength; // 0x135c
|
|
// MPropertyFriendlyName "Radius Scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flRadiusScale; // 0x1360
|
|
// MPropertyFriendlyName "alpha scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flAlphaScale; // 0x1448
|
|
// MPropertyFriendlyName "color blend"
|
|
// MPropertyColorWithNoAlpha
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecColorScale; // 0x1530
|
|
// MPropertyFriendlyName "color blend type"
|
|
// MDefaultString
|
|
ParticleColorBlendType_t m_nColorBlendType; // 0x1960
|
|
// MPropertyFriendlyName "normal texture"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex, *showassetpreview )"
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_hNormalTexture; // 0x1968
|
|
// MPropertyFriendlyName "Sort Method"
|
|
// MPropertyAttributeChoiceEnumName
|
|
// MDefaultString
|
|
int32_t m_nSortMethod; // 0x1974
|
|
// MPropertyFriendlyName "Particle Shadows"
|
|
// MDefaultString
|
|
bool m_bParticleShadows; // 0x1978
|
|
// MPropertyFriendlyName "Shadow Density"
|
|
// MDefaultString
|
|
float m_flShadowDensity; // 0x197c
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_ExternalWindForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point to sample wind"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "scale"
|
|
// MDefaultString
|
|
Vector m_vecScale; // 0x184
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
struct PointDefinitionWithTimeValues_t : public PointDefinition_t
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Duration value for path point"
|
|
// MDefaultString
|
|
float m_flTimeDuration; // 0x14
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 416
|
|
class C_OP_SpinYaw : public CGeneralSpin, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_OP_ParentVortices : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "amount of force"
|
|
// MDefaultString
|
|
float m_flForceScale; // 0x180
|
|
// MPropertyFriendlyName "twist axis"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecTwistAxis; // 0x184
|
|
// MPropertyFriendlyName "flip twist axis with yaw"
|
|
// MDefaultString
|
|
bool m_bFlipBasedOnYaw; // 0x190
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 48
|
|
struct ParticleControlPointDriver_t
|
|
{
|
|
public:
|
|
int32_t m_iControlPoint; // 0x0
|
|
ParticleAttachment_t m_iAttachType; // 0x4
|
|
CUtlString m_attachmentName; // 0x8
|
|
Vector m_vecOffset; // 0x10
|
|
QAngle m_angOffset; // 0x1c
|
|
CUtlString m_entityName; // 0x28
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_OP_SetToCP : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "offset"
|
|
// MDefaultString
|
|
Vector m_vecOffset; // 0x184
|
|
// MPropertyFriendlyName "offset in local space"
|
|
// MDefaultString
|
|
bool m_bOffsetLocal; // 0x190
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_OP_RemapModelVolumetoCP : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point"
|
|
// MDefaultString
|
|
int32_t m_nInControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutControlPointNumber; // 0x184
|
|
// MPropertyFriendlyName "input volume minimum in cubic units"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x188
|
|
// MPropertyFriendlyName "input volume maximum in cubic units"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x18c
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x190
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x194
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 1328
|
|
class C_OP_RemapParticleCountToScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nInputMin; // 0x188
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nInputMax; // 0x270
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flOutputMin; // 0x358
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flOutputMax; // 0x440
|
|
// MPropertyFriendlyName
|
|
// MDefaultString
|
|
bool m_bActiveRange; // 0x528
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x52c
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 16
|
|
class IParticleCollection
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 448
|
|
class C_OP_VectorNoise : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vecOutputMin; // 0x184
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vecOutputMax; // 0x190
|
|
// MPropertyFriendlyName "noise coordinate scale"
|
|
// MDefaultString
|
|
fltx4 m_fl4NoiseScale; // 0x1a0
|
|
// MPropertyFriendlyName "additive"
|
|
// MDefaultString
|
|
bool m_bAdditive; // 0x1b0
|
|
// MPropertyFriendlyName "offset instead of accelerate position"
|
|
// MDefaultString
|
|
bool m_bOffset; // 0x1b1
|
|
// MPropertyFriendlyName "Noise animation time scale"
|
|
// MDefaultString
|
|
float m_flNoiseAnimationTimeScale; // 0x1b4
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_OP_ForceControlPointStub : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_ControlPoint; // 0x180
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 656
|
|
class C_INIT_PositionWarpScalar : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "warp min"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecWarpMin; // 0x180
|
|
// MPropertyFriendlyName "warp max"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecWarpMax; // 0x18c
|
|
// MPropertyFriendlyName "warp amount"
|
|
CPerParticleFloatInput m_InputValue; // 0x198
|
|
// MPropertyFriendlyName "previous position scale"
|
|
// MDefaultString
|
|
float m_flPrevPosScale; // 0x280
|
|
// MPropertyFriendlyName "warp scale control point number"
|
|
// MDefaultString
|
|
int32_t m_nScaleControlPointNumber; // 0x284
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x288
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 1328
|
|
class C_OP_RopeSpringConstraint : public CParticleFunctionConstraint, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "slack"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flRestLength; // 0x180
|
|
// MPropertyFriendlyName "minimum segment length %"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flMinDistance; // 0x268
|
|
// MPropertyFriendlyName "maximum segment length %"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flMaxDistance; // 0x350
|
|
// MPropertyFriendlyName "scale factor for spring correction"
|
|
// MDefaultString
|
|
float m_flAdjustmentScale; // 0x438
|
|
// MPropertyFriendlyName "manual resting spacing"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flInitialRestingLength; // 0x440
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 1344
|
|
class C_OP_CylindricalDistanceToCP : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "cylinder inner radius"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInputMin; // 0x188
|
|
// MPropertyFriendlyName "cylinder outer radius"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInputMax; // 0x270
|
|
// MPropertyFriendlyName "cylinder inner output"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flOutputMin; // 0x358
|
|
// MPropertyFriendlyName "cylinder outer output"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flOutputMax; // 0x440
|
|
// MPropertyFriendlyName "cylinder top control point"
|
|
// MDefaultString
|
|
int32_t m_nStartCP; // 0x528
|
|
// MPropertyFriendlyName "cylinder bottom control point"
|
|
// MDefaultString
|
|
int32_t m_nEndCP; // 0x52c
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x530
|
|
// MPropertyFriendlyName "only active within specified distance"
|
|
// MDefaultString
|
|
bool m_bActiveRange; // 0x534
|
|
// MPropertyFriendlyName "output is additive"
|
|
// MDefaultString
|
|
bool m_bAdditive; // 0x535
|
|
// MPropertyFriendlyName "apply radius to ends (capsule)"
|
|
// MDefaultString
|
|
bool m_bCapsule; // 0x536
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 384
|
|
class CParticleFunctionEmitter : public CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_INIT_RemapInitialCPDirectionToRotation : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "rotation field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_rotation"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "offset rotation"
|
|
// MDefaultString
|
|
float m_flOffsetRot; // 0x188
|
|
// MPropertyFriendlyName "control point axis"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
// MVectorIsSometimesCoordinate
|
|
int32_t m_nComponent; // 0x18c
|
|
};
|
|
|
|
// Aligment: 37
|
|
// Size: 4016
|
|
class C_OP_RenderModels : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "activity override"
|
|
// MDefaultString
|
|
char[256] m_ActivityName; // 0x1d0
|
|
// MPropertyFriendlyName "model override economy loadout slot type"
|
|
// MDefaultString
|
|
char[256] m_EconSlotName; // 0x2d0
|
|
// MPropertyFriendlyName "models"
|
|
CUtlVector< ModelReference_t > m_ModelList; // 0x3d0
|
|
// MPropertyFriendlyName "ignore normal"
|
|
// MDefaultString
|
|
bool m_bIgnoreNormal; // 0x3ec
|
|
// MPropertyFriendlyName "ignore radius"
|
|
// MDefaultString
|
|
bool m_bIgnoreRadius; // 0x3ed
|
|
// MPropertyFriendlyName "orient model z to normal"
|
|
// MDefaultString
|
|
bool m_bOrientZ; // 0x3ee
|
|
// MPropertyFriendlyName "scale animation rate"
|
|
// MDefaultString
|
|
bool m_bScaleAnimationRate; // 0x3ef
|
|
// MPropertyFriendlyName "reset animation frame on stop"
|
|
// MDefaultString
|
|
bool m_bResetAnimOnStop; // 0x3f0
|
|
// MPropertyFriendlyName "set animation frame manually"
|
|
// MDefaultString
|
|
bool m_bManualAnimFrame; // 0x3f1
|
|
// MPropertyFriendlyName "animation rate scale field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nAnimationScaleField; // 0x3f4
|
|
// MPropertyFriendlyName "skin number"
|
|
// MDefaultString
|
|
int32_t m_nSkin; // 0x3f8
|
|
// MPropertyFriendlyName "bodygroup field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nBodyGroupField; // 0x3fc
|
|
// MPropertyFriendlyName "submodel field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nSubModelField; // 0x400
|
|
// MPropertyFriendlyName "animation sequence field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nAnimationField; // 0x404
|
|
// MPropertyFriendlyName "manual animation frame field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nManualFrameField; // 0x408
|
|
// MPropertyFriendlyName "model LOD"
|
|
// MDefaultString
|
|
int32_t m_nLOD; // 0x40c
|
|
// MPropertyFriendlyName "material override"
|
|
// MPropertyAttributeEditor "AssetBrowse( vmat )"
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_hOverrideMaterial; // 0x410
|
|
// MPropertyFriendlyName "override translucent materials"
|
|
// MDefaultString
|
|
bool m_bOverrideTranslucentMaterials; // 0x418
|
|
// MPropertyFriendlyName "skin override CP"
|
|
// MDefaultString
|
|
int32_t m_nSkinCP; // 0x41c
|
|
// MPropertyFriendlyName "model override CP"
|
|
// MDefaultString
|
|
int32_t m_nModelCP; // 0x420
|
|
// MPropertyFriendlyName "model scale CP"
|
|
// MDefaultString
|
|
int32_t m_nModelScaleCP; // 0x424
|
|
// MPropertyFriendlyName "animation rate"
|
|
// MDefaultString
|
|
float m_flAnimationRate; // 0x428
|
|
// MPropertyFriendlyName "animated"
|
|
// MDefaultString
|
|
bool m_bAnimated; // 0x42c
|
|
// MPropertyFriendlyName "force looping animations"
|
|
// MDefaultString
|
|
bool m_bForceLoopingAnimation; // 0x42d
|
|
// MPropertyFriendlyName "forcedrawinterlevedwithsiblings"
|
|
// MDefaultString
|
|
bool m_bForceDrawInterlevedWithSiblings; // 0x42e
|
|
// MPropertyFriendlyName "Only Render in effects bloom pass"
|
|
// MDefaultString
|
|
bool m_bOnlyRenderInEffectsBloomPass; // 0x42f
|
|
// MPropertyFriendlyName "model override original model only (ignore shapeshift/hex/etc)"
|
|
// MDefaultString
|
|
bool m_bOriginalModel; // 0x430
|
|
// MPropertyFriendlyName "suppress tinting of the model"
|
|
// MDefaultString
|
|
bool m_bSuppressTint; // 0x431
|
|
// MPropertyFriendlyName "use raw mesh group (ignore bodygroup field and use submodel field as raw meshgroup)"
|
|
// MDefaultString
|
|
bool m_bUseRawMeshGroup; // 0x432
|
|
// MPropertyFriendlyName "disable shadows"
|
|
// MDefaultString
|
|
bool m_bDisableShadows; // 0x433
|
|
// MPropertyFriendlyName "render attribute"
|
|
// MDefaultString
|
|
char[260] m_szRenderAttribute; // 0x434
|
|
// MPropertyFriendlyName "material variables"
|
|
CUtlVector< MaterialVariable_t > m_MaterialVars; // 0x538
|
|
// MPropertyFriendlyName "Radius Scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flRadiusScale; // 0x550
|
|
// MPropertyFriendlyName "alpha scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flAlphaScale; // 0x638
|
|
// MPropertyFriendlyName "color blend"
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecColorScale; // 0x720
|
|
// MPropertyFriendlyName "color blend type"
|
|
// MDefaultString
|
|
ParticleColorBlendType_t m_nColorBlendType; // 0xb50
|
|
// MPropertyFriendlyName "model component scale"
|
|
// MDefaultString
|
|
CPerParticleVecInput m_vecComponentScale; // 0xb58
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 416
|
|
class C_OP_RemapSpeed : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x184
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x188
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x18c
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x190
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x194
|
|
// MPropertyFriendlyName "ignore delta time"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
bool m_bIgnoreDelta; // 0x198
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 384
|
|
class CParticleFunctionConstraint : public CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 16
|
|
struct MaterialVariable_t
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "material variable"
|
|
// MDefaultString
|
|
CUtlString m_strVariable; // 0x0
|
|
// MPropertyFriendlyName "particle field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nVariableField; // 0x8
|
|
// MPropertyFriendlyName "scale"
|
|
// MDefaultString
|
|
float m_flScale; // 0xc
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_INIT_SetRigidAttachment : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "attribute to read from"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x184
|
|
// MPropertyFriendlyName "attribute to cache to"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x188
|
|
// MPropertyFriendlyName "local space"
|
|
// MDefaultString
|
|
bool m_bLocalSpace; // 0x18c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 120
|
|
struct ParticleControlPointConfiguration_t
|
|
{
|
|
public:
|
|
CUtlString m_name; // 0x0
|
|
CUtlVector< ParticleControlPointDriver_t > m_drivers; // 0x8
|
|
ParticlePreviewState_t m_previewState; // 0x20
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 448
|
|
class C_OP_ForceBasedOnDistanceToPlane : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "min distance from plane"
|
|
// MDefaultString
|
|
float m_flMinDist; // 0x180
|
|
// MPropertyFriendlyName "force at min distance"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecForceAtMinDist; // 0x184
|
|
// MPropertyFriendlyName "max distance from plane"
|
|
// MDefaultString
|
|
float m_flMaxDist; // 0x190
|
|
// MPropertyFriendlyName "force at max distance"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecForceAtMaxDist; // 0x194
|
|
// MPropertyFriendlyName "plane normal"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecPlaneNormal; // 0x1a0
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x1ac
|
|
// MPropertyFriendlyName "exponent"
|
|
// MDefaultString
|
|
float m_flExponent; // 0x1b0
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 384
|
|
class C_OP_EndCapDecay : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 12
|
|
// Size: 432
|
|
class C_OP_PercentageBetweenCPLerpCPs : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "percentage minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x184
|
|
// MPropertyFriendlyName "percentage maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x188
|
|
// MPropertyFriendlyName "starting control point"
|
|
// MDefaultString
|
|
int32_t m_nStartCP; // 0x18c
|
|
// MPropertyFriendlyName "ending control point"
|
|
// MDefaultString
|
|
int32_t m_nEndCP; // 0x190
|
|
// MPropertyFriendlyName "output starting control point number"
|
|
// MDefaultString
|
|
int32_t m_nOutputStartCP; // 0x194
|
|
// MPropertyFriendlyName "output starting control point field 0-2 X/Y/Z"
|
|
// MDefaultString
|
|
int32_t m_nOutputStartField; // 0x198
|
|
// MPropertyFriendlyName "output ending control point number"
|
|
// MDefaultString
|
|
int32_t m_nOutputEndCP; // 0x19c
|
|
// MPropertyFriendlyName "output ending control point field 0-2 X/Y/Z"
|
|
// MDefaultString
|
|
int32_t m_nOutputEndField; // 0x1a0
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x1a4
|
|
// MPropertyFriendlyName "only active within input range"
|
|
// MDefaultString
|
|
bool m_bActiveRange; // 0x1a8
|
|
// MPropertyFriendlyName "treat distance between points as radius"
|
|
// MDefaultString
|
|
bool m_bRadialCheck; // 0x1a9
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 576
|
|
class C_INIT_DistanceToCPInit : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "distance minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x184
|
|
// MPropertyFriendlyName "distance maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x188
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x18c
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x190
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nStartCP; // 0x194
|
|
// MPropertyFriendlyName "ensure line of sight"
|
|
// MDefaultString
|
|
bool m_bLOS; // 0x198
|
|
// MPropertyFriendlyName "LOS collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x199
|
|
// MPropertyFriendlyName "Maximum Trace Length"
|
|
// MDefaultString
|
|
float m_flMaxTraceLength; // 0x21c
|
|
// MPropertyFriendlyName "LOS Failure Scalar"
|
|
// MDefaultString
|
|
float m_flLOSScale; // 0x220
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x224
|
|
// MPropertyFriendlyName "only active within specified distance"
|
|
// MDefaultString
|
|
bool m_bActiveRange; // 0x228
|
|
// MPropertyFriendlyName "distance component scale"
|
|
// MDefaultString
|
|
Vector m_vecDistanceScale; // 0x22c
|
|
// MPropertyFriendlyName "remap bias"
|
|
// MDefaultString
|
|
float m_flRemapBias; // 0x238
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 624
|
|
class C_OP_EnableChildrenFromParentParticleCount : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "group ID to affect"
|
|
// MDefaultString
|
|
int32_t m_nChildGroupID; // 0x180
|
|
// MPropertyFriendlyName "first child to enable"
|
|
// MDefaultString
|
|
int32_t m_nFirstChild; // 0x184
|
|
// MPropertyFriendlyName "max # of children to enable (-1 for max particle count)"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nNumChildrenToEnable; // 0x188
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 480
|
|
class C_OP_RenderFlattenGrass : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "flattening strength"
|
|
// MDefaultString
|
|
float m_flFlattenStrength; // 0x1d0
|
|
// MPropertyFriendlyName "strength field override"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nStrengthFieldOverride; // 0x1d4
|
|
// MPropertyFriendlyName "radius scale"
|
|
// MDefaultString
|
|
float m_flRadiusScale; // 0x1d8
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_OP_MovementRigidAttachToCP : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "scale control point number"
|
|
// MDefaultString
|
|
int32_t m_nScaleControlPoint; // 0x184
|
|
// MPropertyFriendlyName "scale control point field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nScaleCPField; // 0x188
|
|
// MPropertyFriendlyName "cache attribute to read from"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x18c
|
|
// MPropertyFriendlyName "attribute to write to"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x190
|
|
// MPropertyFriendlyName "local space"
|
|
// MDefaultString
|
|
bool m_bOffsetLocal; // 0x194
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 432
|
|
class C_INIT_ChaoticAttractor : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "pickover A parameter"
|
|
// MDefaultString
|
|
float m_flAParm; // 0x180
|
|
// MPropertyFriendlyName "pickover B parameter"
|
|
// MDefaultString
|
|
float m_flBParm; // 0x184
|
|
// MPropertyFriendlyName "pickover C parameter"
|
|
// MDefaultString
|
|
float m_flCParm; // 0x188
|
|
// MPropertyFriendlyName "pickover D parameter"
|
|
// MDefaultString
|
|
float m_flDParm; // 0x18c
|
|
// MPropertyFriendlyName "scale"
|
|
// MDefaultString
|
|
float m_flScale; // 0x190
|
|
// MPropertyFriendlyName "speed min"
|
|
// MDefaultString
|
|
float m_flSpeedMin; // 0x194
|
|
// MPropertyFriendlyName "speed max"
|
|
// MDefaultString
|
|
float m_flSpeedMax; // 0x198
|
|
// MPropertyFriendlyName "relative control point number"
|
|
// MDefaultString
|
|
int32_t m_nBaseCP; // 0x19c
|
|
// MPropertyFriendlyName "uniform speed"
|
|
// MDefaultString
|
|
bool m_bUniformSpeed; // 0x1a0
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 448
|
|
class C_OP_RampScalarLinearSimple : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "ramp rate"
|
|
// MDefaultString
|
|
float m_Rate; // 0x180
|
|
// MPropertyFriendlyName "start time"
|
|
// MDefaultString
|
|
float m_flStartTime; // 0x184
|
|
// MPropertyFriendlyName "end time"
|
|
// MDefaultString
|
|
float m_flEndTime; // 0x188
|
|
// MPropertyFriendlyName "ramp field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nField; // 0x1b0
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_INIT_InheritFromParentParticles : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "scale"
|
|
// MDefaultString
|
|
float m_flScale; // 0x180
|
|
// MPropertyFriendlyName "inherited field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "particle increment amount"
|
|
// MDefaultString
|
|
int32_t m_nIncrement; // 0x188
|
|
// MPropertyFriendlyName "random parent particle distribution"
|
|
// MDefaultString
|
|
bool m_bRandomDistribution; // 0x18c
|
|
// MPropertyFriendlyName "random seed"
|
|
// MDefaultString
|
|
int32_t m_nRandomSeed; // 0x190
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 656
|
|
class C_OP_LerpToOtherAttribute : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Interpolation"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInterpolation; // 0x180
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x268
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x26c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 432
|
|
class C_INIT_PointList : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "point list"
|
|
CUtlVector< PointDefinition_t > m_pointList; // 0x188
|
|
// MPropertyFriendlyName "space points along path"
|
|
// MDefaultString
|
|
bool m_bPlaceAlongPath; // 0x1a0
|
|
// MPropertyFriendlyName "Treat path as a loop"
|
|
// MDefaultString
|
|
bool m_bClosedLoop; // 0x1a1
|
|
// MPropertyFriendlyName "Numer of points along path"
|
|
// MDefaultString
|
|
int32_t m_nNumPointsAlongPath; // 0x1a4
|
|
};
|
|
|
|
// Aligment: 36
|
|
// Size: 232
|
|
class CParticleFloatInput
|
|
{
|
|
public:
|
|
// MDefaultString
|
|
ParticleFloatType_t m_nType; // 0x0
|
|
// MDefaultString
|
|
ParticleFloatMapType_t m_nMapType; // 0x4
|
|
// MDefaultString
|
|
float m_flLiteralValue; // 0x8
|
|
// MDefaultString
|
|
int32_t m_nControlPoint; // 0xc
|
|
// MDefaultString
|
|
ParticleAttributeIndex_t m_nScalarAttribute; // 0x10
|
|
// MDefaultString
|
|
ParticleAttributeIndex_t m_nVectorAttribute; // 0x14
|
|
// MDefaultString
|
|
int32_t m_nVectorComponent; // 0x18
|
|
// MDefaultString
|
|
float m_flRandomMin; // 0x1c
|
|
// MDefaultString
|
|
float m_flRandomMax; // 0x20
|
|
// MDefaultString
|
|
ParticleFloatRandomMode_t m_nRandomMode; // 0x24
|
|
// MDefaultString
|
|
float m_flLOD0; // 0x2c
|
|
// MDefaultString
|
|
float m_flLOD1; // 0x30
|
|
// MDefaultString
|
|
float m_flLOD2; // 0x34
|
|
// MDefaultString
|
|
float m_flLOD3; // 0x38
|
|
// MDefaultString
|
|
float m_flNoiseOutputMin; // 0x3c
|
|
// MDefaultString
|
|
float m_flNoiseOutputMax; // 0x40
|
|
// MDefaultString
|
|
float m_flNoiseScale; // 0x44
|
|
// MDefaultString
|
|
Vector m_vecNoiseOffsetRate; // 0x48
|
|
// MDefaultString
|
|
float m_flNoiseOffset; // 0x54
|
|
// MDefaultString
|
|
int32_t m_nNoiseOctaves; // 0x58
|
|
// MDefaultString
|
|
PFNoiseTurbulence_t m_nNoiseTurbulence; // 0x5c
|
|
// MDefaultString
|
|
PFNoiseType_t m_nNoiseType; // 0x60
|
|
// MDefaultString
|
|
PFNoiseModifier_t m_nNoiseModifier; // 0x64
|
|
// MDefaultString
|
|
float m_flNoiseTurbulenceScale; // 0x68
|
|
// MDefaultString
|
|
float m_flNoiseTurbulenceMix; // 0x6c
|
|
// MDefaultString
|
|
float m_flNoiseImgPreviewScale; // 0x70
|
|
// MDefaultString
|
|
bool m_bNoiseImgPreviewLive; // 0x74
|
|
// MDefaultString
|
|
ParticleFloatInputMode_t m_nInputMode; // 0x7c
|
|
// MDefaultString
|
|
float m_flMultFactor; // 0x80
|
|
// MDefaultString
|
|
float m_flInput0; // 0x84
|
|
// MDefaultString
|
|
float m_flInput1; // 0x88
|
|
// MDefaultString
|
|
float m_flOutput0; // 0x8c
|
|
// MDefaultString
|
|
float m_flOutput1; // 0x90
|
|
// MDefaultString
|
|
ParticleFloatBiasType_t m_nBiasType; // 0x94
|
|
// MDefaultString
|
|
float m_flBiasParameter; // 0x98
|
|
CPiecewiseCurveSchemaWrapper m_Curve; // 0xa0
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 784
|
|
class C_OP_MoveToHitbox : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "lifetime lerp start"
|
|
// MDefaultString
|
|
float m_flLifeTimeLerpStart; // 0x188
|
|
// MPropertyFriendlyName "lifetime lerp end"
|
|
// MDefaultString
|
|
float m_flLifeTimeLerpEnd; // 0x18c
|
|
// MPropertyFriendlyName "previous position scale"
|
|
// MDefaultString
|
|
float m_flPrevPosScale; // 0x190
|
|
// MPropertyFriendlyName "hitbox set"
|
|
// MDefaultString
|
|
char[128] m_HitboxSetName; // 0x194
|
|
// MPropertyFriendlyName "use bones instead of hitboxes"
|
|
// MDefaultString
|
|
bool m_bUseBones; // 0x214
|
|
// MPropertyFriendlyName "lerp type"
|
|
// MDefaultString
|
|
HitboxLerpType_t m_nLerpType; // 0x218
|
|
// MPropertyFriendlyName "Constant Interpolation"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInterpolation; // 0x220
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 480
|
|
class C_OP_RemapNamedModelElementEndCap : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "model"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "AssetBrowse( vmdl )"
|
|
CStrongHandle< InfoForResourceTypeCModel > m_hModel; // 0x180
|
|
// MPropertyFriendlyName "input names"
|
|
CUtlVector< CUtlString > m_inNames; // 0x188
|
|
// MPropertyFriendlyName "output names"
|
|
CUtlVector< CUtlString > m_outNames; // 0x1a0
|
|
// MPropertyFriendlyName "fallback names when the input doesn't match"
|
|
CUtlVector< CUtlString > m_fallbackNames; // 0x1b8
|
|
// MPropertyFriendlyName "model from renderer"
|
|
// MDefaultString
|
|
bool m_bModelFromRenderer; // 0x1d0
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x1d4
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x1d8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 624
|
|
class C_OP_CPVelocityForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "velocity scale"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flScale; // 0x188
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_OP_LockPoints : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "min column/particle index to affect"
|
|
// MDefaultString
|
|
int32_t m_nMinCol; // 0x180
|
|
// MPropertyFriendlyName "max column/particle index to affect"
|
|
// MDefaultString
|
|
int32_t m_nMaxCol; // 0x184
|
|
// MPropertyFriendlyName "min row/particle index to affect"
|
|
// MDefaultString
|
|
int32_t m_nMinRow; // 0x188
|
|
// MPropertyFriendlyName "max row/particle index to affect"
|
|
// MDefaultString
|
|
int32_t m_nMaxRow; // 0x18c
|
|
// MPropertyFriendlyName "control point to lock to"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint; // 0x190
|
|
// MPropertyFriendlyName "amount of current position to preserve"
|
|
// MDefaultString
|
|
float m_flBlendValue; // 0x194
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 640
|
|
class C_INIT_CreateFromCPs : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point increment amount"
|
|
// MDefaultString
|
|
int32_t m_nIncrement; // 0x180
|
|
// MPropertyFriendlyName "starting control point"
|
|
// MDefaultString
|
|
int32_t m_nMinCP; // 0x184
|
|
// MPropertyFriendlyName "ending control point"
|
|
// MDefaultString
|
|
// MParticleMinVersion
|
|
int32_t m_nMaxCP; // 0x188
|
|
// MPropertyFriendlyName "dynamic control point count"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nDynamicCPCount; // 0x190
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 880
|
|
class C_OP_PlanarConstraint : public CParticleFunctionConstraint, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "plane point"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_PointOnPlane; // 0x180
|
|
// MPropertyFriendlyName "plane normal"
|
|
// MDefaultString
|
|
Vector m_PlaneNormal; // 0x18c
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x198
|
|
// MPropertyFriendlyName "global origin"
|
|
// MDefaultString
|
|
bool m_bGlobalOrigin; // 0x19c
|
|
// MPropertyFriendlyName "global normal"
|
|
// MDefaultString
|
|
bool m_bGlobalNormal; // 0x19d
|
|
// MPropertyFriendlyName "radius scale"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flRadiusScale; // 0x1a0
|
|
// MPropertyFriendlyName "falloff distance from control point"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flMaximumDistanceToCP; // 0x288
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
struct ModelReference_t
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "model"
|
|
// MPropertyAttributeEditor "AssetBrowse( vmdl )"
|
|
CStrongHandle< InfoForResourceTypeCModel > m_model; // 0x0
|
|
// MPropertyFriendlyName "Relative probability"
|
|
// MDefaultString
|
|
float m_flRelativeProbabilityOfSpawn; // 0x8
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 1088
|
|
class C_OP_SelectivelyEnableChildren : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "group ID to affect"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nChildGroupID; // 0x180
|
|
// MPropertyFriendlyName "first child to enable"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nFirstChild; // 0x268
|
|
// MPropertyFriendlyName "# of children to enable"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nNumChildrenToEnable; // 0x350
|
|
// MPropertyFriendlyName "play endcap when children are removed"
|
|
// MDefaultString
|
|
bool m_bPlayEndcapOnStop; // 0x438
|
|
// MPropertyFriendlyName "destroy particles immediately when child is removed"
|
|
// MDefaultString
|
|
bool m_bDestroyImmediately; // 0x439
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 384
|
|
class CParticleFunctionInitializer : public CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 416
|
|
class C_INIT_InitialSequenceFromModel : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "current anim time output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutputAnim; // 0x188
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x18c
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x190
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x194
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x198
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x19c
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 432
|
|
class C_OP_PercentageBetweenCPs : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "percentage minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x184
|
|
// MPropertyFriendlyName "percentage maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x188
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x18c
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x190
|
|
// MPropertyFriendlyName "starting control point"
|
|
// MDefaultString
|
|
int32_t m_nStartCP; // 0x194
|
|
// MPropertyFriendlyName "ending control point"
|
|
// MDefaultString
|
|
int32_t m_nEndCP; // 0x198
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x19c
|
|
// MPropertyFriendlyName "only active within input range"
|
|
// MDefaultString
|
|
bool m_bActiveRange; // 0x1a0
|
|
// MPropertyFriendlyName "treat distance between points as radius"
|
|
// MDefaultString
|
|
bool m_bRadialCheck; // 0x1a1
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_OP_RadiusDecay : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "minimum radius"
|
|
// MDefaultString
|
|
float m_flMinRadius; // 0x180
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_OP_SnapshotSkinToBones : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "rotate normals"
|
|
// MDefaultString
|
|
bool m_bTransformNormals; // 0x180
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x184
|
|
// MPropertyFriendlyName "lifetime fade start"
|
|
// MDefaultString
|
|
float m_flLifeTimeFadeStart; // 0x188
|
|
// MPropertyFriendlyName "lifetime fade end"
|
|
// MDefaultString
|
|
float m_flLifeTimeFadeEnd; // 0x18c
|
|
// MPropertyFriendlyName "instant jump threshold"
|
|
// MDefaultString
|
|
float m_flJumpThreshold; // 0x190
|
|
// MPropertyFriendlyName "previous position scale"
|
|
// MDefaultString
|
|
float m_flPrevPosScale; // 0x194
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 544
|
|
class C_OP_SetCPOrientationToGroundNormal : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "interpolation rate"
|
|
// MDefaultString
|
|
float m_flInterpRate; // 0x180
|
|
// MPropertyFriendlyName "max trace length"
|
|
// MDefaultString
|
|
float m_flMaxTraceLength; // 0x184
|
|
// MPropertyFriendlyName "CP movement tolerance"
|
|
// MDefaultString
|
|
float m_flTolerance; // 0x188
|
|
// MPropertyFriendlyName "trace offset"
|
|
// MDefaultString
|
|
float m_flTraceOffset; // 0x18c
|
|
// MPropertyFriendlyName "collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x190
|
|
// MPropertyFriendlyName "CP to trace from"
|
|
// MDefaultString
|
|
int32_t m_nInputCP; // 0x210
|
|
// MPropertyFriendlyName "CP to set"
|
|
// MDefaultString
|
|
int32_t m_nOutputCP; // 0x214
|
|
// MPropertyFriendlyName "include water"
|
|
// MDefaultString
|
|
bool m_bIncludeWater; // 0x21c
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 416
|
|
class C_OP_TimeVaryingForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "time to start transition"
|
|
// MDefaultString
|
|
float m_flStartLerpTime; // 0x180
|
|
// MPropertyFriendlyName "starting force"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_StartingForce; // 0x184
|
|
// MPropertyFriendlyName "time to end transition"
|
|
// MDefaultString
|
|
float m_flEndLerpTime; // 0x190
|
|
// MPropertyFriendlyName "ending force"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_EndingForce; // 0x194
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_SetControlPointFieldToWater : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "source CP"
|
|
// MDefaultString
|
|
int32_t m_nSourceCP; // 0x180
|
|
// MPropertyFriendlyName "dest CP"
|
|
// MDefaultString
|
|
int32_t m_nDestCP; // 0x184
|
|
// MPropertyFriendlyName "dest control point component"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nCPField; // 0x188
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_OP_LerpVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "value to lerp to"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vecOutput; // 0x184
|
|
// MPropertyFriendlyName "start time"
|
|
// MDefaultString
|
|
float m_flStartTime; // 0x190
|
|
// MPropertyFriendlyName "end time"
|
|
// MDefaultString
|
|
float m_flEndTime; // 0x194
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x198
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 528
|
|
class C_INIT_InitialVelocityFromHitbox : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "velocity minimum"
|
|
// MDefaultString
|
|
float m_flVelocityMin; // 0x180
|
|
// MPropertyFriendlyName "velocity maximum"
|
|
// MDefaultString
|
|
float m_flVelocityMax; // 0x184
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x188
|
|
// MPropertyFriendlyName "hitbox set"
|
|
// MDefaultString
|
|
char[128] m_HitboxSetName; // 0x18c
|
|
// MPropertyFriendlyName "use bones instead of hitboxes"
|
|
// MDefaultString
|
|
bool m_bUseBones; // 0x20c
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 416
|
|
class C_OP_HSVShiftToCP : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Target color control point number"
|
|
// MDefaultString
|
|
int32_t m_nColorCP; // 0x180
|
|
// MPropertyFriendlyName "Color Gem Enable control point number"
|
|
// MDefaultString
|
|
int32_t m_nColorGemEnableCP; // 0x184
|
|
// MPropertyFriendlyName "output control point number"
|
|
// MDefaultString
|
|
int32_t m_nOutputCP; // 0x188
|
|
// MPropertyFriendlyName "Default HSV Color"
|
|
// MDefaultString
|
|
Color m_DefaultHSVColor; // 0x18c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_OP_RemapBoundingVolumetoCP : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "input volume minimum in cubic units"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x184
|
|
// MPropertyFriendlyName "input volume maximum in cubic units"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x188
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x18c
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x190
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 512
|
|
class C_OP_RenderScreenShake : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "duration scale"
|
|
// MDefaultString
|
|
float m_flDurationScale; // 0x1d0
|
|
// MPropertyFriendlyName "radius scale"
|
|
// MDefaultString
|
|
float m_flRadiusScale; // 0x1d4
|
|
// MPropertyFriendlyName "frequence scale"
|
|
// MDefaultString
|
|
float m_flFrequencyScale; // 0x1d8
|
|
// MPropertyFriendlyName "amplitude scale"
|
|
// MDefaultString
|
|
float m_flAmplitudeScale; // 0x1dc
|
|
// MPropertyFriendlyName "radius field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nRadiusField; // 0x1e0
|
|
// MPropertyFriendlyName "duration field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nDurationField; // 0x1e4
|
|
// MPropertyFriendlyName "frequency field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFrequencyField; // 0x1e8
|
|
// MPropertyFriendlyName "amplitude field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nAmplitudeField; // 0x1ec
|
|
// MPropertyFriendlyName "control point of shake recipient (-1 = global)"
|
|
// MDefaultString
|
|
int32_t m_nFilterCP; // 0x1f0
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_OP_FadeIn : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "fade in time min"
|
|
// MDefaultString
|
|
float m_flFadeInTimeMin; // 0x180
|
|
// MPropertyFriendlyName "fade in time max"
|
|
// MDefaultString
|
|
float m_flFadeInTimeMax; // 0x184
|
|
// MPropertyFriendlyName "fade in time exponent"
|
|
// MDefaultString
|
|
float m_flFadeInTimeExp; // 0x188
|
|
// MPropertyFriendlyName "proportional 0/1"
|
|
// MDefaultString
|
|
bool m_bProportional; // 0x18c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 624
|
|
class C_OP_SetSimulationRate : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "simulation timescale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flSimulationScale; // 0x180
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_INIT_Orient2DRelToCP : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "rotation field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_rotation"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "rotation offset"
|
|
// MDefaultString
|
|
float m_flRotOffset; // 0x188
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 4080
|
|
class C_OP_CurlNoiseForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "noise type"
|
|
// MDefaultString
|
|
ParticleDirectionNoiseType_t m_nNoiseType; // 0x180
|
|
// MPropertyFriendlyName "noise frequency"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CPerParticleVecInput m_vecNoiseFreq; // 0x188
|
|
// MPropertyFriendlyName "noise amplitude"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CPerParticleVecInput m_vecNoiseScale; // 0x5b8
|
|
// MPropertyFriendlyName "offset rate"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CPerParticleVecInput m_vecOffsetRate; // 0x9e8
|
|
// MPropertyFriendlyName "worley seed"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flWorleySeed; // 0xe18
|
|
// MPropertyFriendlyName "worley jitter"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flWorleyJitter; // 0xf00
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 8
|
|
class IControlPointEditorData
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 416
|
|
class C_OP_RemapCPOrientationToRotations : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "offset pitch/yaw/roll"
|
|
// MDefaultString
|
|
Vector m_vecRotation; // 0x184
|
|
// MPropertyFriendlyName "Use Quaternians Internally"
|
|
// MDefaultString
|
|
bool m_bUseQuat; // 0x190
|
|
// MPropertyFriendlyName "Write normal instead of rotation"
|
|
// MDefaultString
|
|
bool m_bWriteNormal; // 0x191
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 1696
|
|
class C_OP_SetControlPointRotation : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "rotation axis"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CParticleCollectionVecInput m_vecRotAxis; // 0x180
|
|
// MPropertyFriendlyName "rotation rate"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flRotRate; // 0x5b0
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x698
|
|
// MPropertyFriendlyName "local space control point"
|
|
// MDefaultString
|
|
int32_t m_nLocalCP; // 0x69c
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 432
|
|
class C_OP_RemapCPtoCP : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point number"
|
|
// MDefaultString
|
|
int32_t m_nInputControlPoint; // 0x180
|
|
// MPropertyFriendlyName "output control point number"
|
|
// MDefaultString
|
|
int32_t m_nOutputControlPoint; // 0x184
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nInputField; // 0x188
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nOutputField; // 0x18c
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x190
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x194
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x198
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x19c
|
|
// MPropertyFriendlyName "use the derivative"
|
|
// MDefaultString
|
|
bool m_bDerivative; // 0x1a0
|
|
// MPropertyFriendlyName "interpolation"
|
|
// MDefaultString
|
|
float m_flInterpRate; // 0x1a4
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 432
|
|
class C_OP_RemapDotProductToScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "first input control point"
|
|
// MDefaultString
|
|
int32_t m_nInputCP1; // 0x180
|
|
// MPropertyFriendlyName "second input control point"
|
|
// MDefaultString
|
|
int32_t m_nInputCP2; // 0x184
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x188
|
|
// MPropertyFriendlyName "input minimum (-1 to 1)"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x18c
|
|
// MPropertyFriendlyName "input maximum (-1 to 1)"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x190
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x194
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x198
|
|
// MPropertyFriendlyName "use particle velocity for first input"
|
|
// MDefaultString
|
|
bool m_bUseParticleVelocity; // 0x19c
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x1a0
|
|
// MPropertyFriendlyName "only active within specified input range"
|
|
// MDefaultString
|
|
bool m_bActiveRange; // 0x1a4
|
|
// MPropertyFriendlyName "use particle normal for first input"
|
|
// MDefaultString
|
|
bool m_bUseParticleNormal; // 0x1a5
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 416
|
|
class C_OP_RemapAverageScalarValuetoCP : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nOutVectorField; // 0x184
|
|
// MPropertyFriendlyName "scalar field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nField; // 0x188
|
|
// MPropertyFriendlyName "input volume minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x18c
|
|
// MPropertyFriendlyName "input volume maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x190
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x194
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x198
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_SetControlPointToCenter : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number to set"
|
|
// MDefaultString
|
|
int32_t m_nCP1; // 0x180
|
|
// MPropertyFriendlyName "center offset"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecCP1Pos; // 0x184
|
|
};
|
|
|
|
// Aligment: 15
|
|
// Size: 4576
|
|
class C_INIT_CreateWithinSphere : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "distance min"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_fRadiusMin; // 0x180
|
|
// MPropertyFriendlyName "distance max"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_fRadiusMax; // 0x268
|
|
// MPropertyFriendlyName "distance bias"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CPerParticleVecInput m_vecDistanceBias; // 0x350
|
|
// MPropertyFriendlyName "distance bias absolute value"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecDistanceBiasAbs; // 0x780
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x78c
|
|
// MPropertyFriendlyName "speed min"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_fSpeedMin; // 0x790
|
|
// MPropertyFriendlyName "speed max"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_fSpeedMax; // 0x878
|
|
// MPropertyFriendlyName "speed random exponent"
|
|
// MDefaultString
|
|
float m_fSpeedRandExp; // 0x960
|
|
// MPropertyFriendlyName "bias in local system"
|
|
// MDefaultString
|
|
bool m_bLocalCoords; // 0x964
|
|
// MPropertyFriendlyName "randomly distribute to highest supplied control point"
|
|
// MDefaultString
|
|
// MParticleMaxVersion
|
|
bool m_bUseHighestEndCP; // 0x966
|
|
// MPropertyFriendlyName "randomly distribution growth time"
|
|
// MDefaultString
|
|
float m_flEndCPGrowthTime; // 0x968
|
|
// MPropertyFriendlyName "speed in local coordinate system min"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CPerParticleVecInput m_LocalCoordinateSystemSpeedMin; // 0x970
|
|
// MPropertyFriendlyName "speed in local coordinate system max"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CPerParticleVecInput m_LocalCoordinateSystemSpeedMax; // 0xda0
|
|
// MPropertyFriendlyName "Output vector"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x11d0
|
|
// MPropertyFriendlyName "Velocity vector"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldVelocity; // 0x11d4
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_OP_RemapControlPointOrientationToRotation : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "rotation field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_rotation"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "offset rotation"
|
|
// MDefaultString
|
|
float m_flOffsetRot; // 0x188
|
|
// MPropertyFriendlyName "control point axis"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
// MVectorIsSometimesCoordinate
|
|
int32_t m_nComponent; // 0x18c
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 2064
|
|
class C_OP_RenderStandardLight : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "light type"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceEnumName
|
|
int32_t m_nLightType; // 0x1d0
|
|
// MPropertyFriendlyName "color blend"
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecColorScale; // 0x1d8
|
|
// MPropertyFriendlyName "color blend type"
|
|
// MDefaultString
|
|
ParticleColorBlendType_t m_nColorBlendType; // 0x608
|
|
// MPropertyFriendlyName "intensity"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flIntensity; // 0x610
|
|
// MPropertyFriendlyName "cast shadows"
|
|
// MDefaultString
|
|
bool m_bCastShadows; // 0x6f8
|
|
// MPropertyFriendlyName "inner cone angle"
|
|
// MDefaultString
|
|
float m_flTheta; // 0x6fc
|
|
// MPropertyFriendlyName "outer cone angle"
|
|
// MDefaultString
|
|
float m_flPhi; // 0x700
|
|
// MPropertyFriendlyName "light radius multiplier"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flRadiusMultiplier; // 0x708
|
|
// MPropertyFriendlyName "falloff linearity"
|
|
// MDefaultString
|
|
float m_flFalloffLinearity; // 0x7f0
|
|
// MPropertyFriendlyName "render diffuse"
|
|
// MDefaultString
|
|
bool m_bRenderDiffuse; // 0x7f4
|
|
// MPropertyFriendlyName "render specular"
|
|
// MDefaultString
|
|
bool m_bRenderSpecular; // 0x7f5
|
|
// MPropertyFriendlyName "light cookie string"
|
|
CUtlString m_lightCookie; // 0x7f8
|
|
// MPropertyFriendlyName "light priority"
|
|
// MDefaultString
|
|
int32_t m_nPriority; // 0x800
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_OP_WindForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "force to apply"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vForce; // 0x180
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 232
|
|
class CParticleCollectionFloatInput : public CParticleFloatInput
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 8
|
|
class IParticleSystemDefinition
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 432
|
|
class C_INIT_RemapCPtoScalar : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point number"
|
|
// MDefaultString
|
|
int32_t m_nCPInput; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "input field 0-2 X/Y/Z"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nField; // 0x188
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x18c
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x190
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x194
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x198
|
|
// MPropertyFriendlyName "emitter lifetime start time (seconds)"
|
|
// MDefaultString
|
|
float m_flStartTime; // 0x19c
|
|
// MPropertyFriendlyName "emitter lifetime end time (seconds)"
|
|
// MDefaultString
|
|
float m_flEndTime; // 0x1a0
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x1a4
|
|
// MPropertyFriendlyName "remap bias"
|
|
// MDefaultString
|
|
float m_flRemapBias; // 0x1a8
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_OP_ClampVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vecOutputMin; // 0x184
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vecOutputMax; // 0x190
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 464
|
|
class C_OP_LockToSavedSequentialPath : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "start fade time"
|
|
// MDefaultString
|
|
float m_flFadeStart; // 0x184
|
|
// MPropertyFriendlyName "end fade time"
|
|
// MDefaultString
|
|
float m_flFadeEnd; // 0x188
|
|
// MPropertyFriendlyName "Use sequential CP pairs between start and end point"
|
|
// MDefaultString
|
|
bool m_bCPPairs; // 0x18c
|
|
CPathParameters m_PathParams; // 0x190
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class CGeneralSpin : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "spin rate degrees"
|
|
// MDefaultString
|
|
int32_t m_nSpinRateDegrees; // 0x180
|
|
// MPropertyFriendlyName "spin rate min"
|
|
// MDefaultString
|
|
int32_t m_nSpinRateMinDegrees; // 0x184
|
|
// MPropertyFriendlyName "spin stop time"
|
|
// MDefaultString
|
|
float m_fSpinRateStopTime; // 0x18c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 624
|
|
class C_OP_StopAfterCPDuration : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "duration at which to stop"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flDuration; // 0x180
|
|
// MPropertyFriendlyName "destroy all particles immediately"
|
|
// MDefaultString
|
|
bool m_bDestroyImmediately; // 0x268
|
|
// MPropertyFriendlyName "play end cap effect"
|
|
// MDefaultString
|
|
bool m_bPlayEndCap; // 0x269
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 480
|
|
class C_OP_RemapNamedModelBodyPartEndCap : public C_OP_RemapNamedModelElementEndCap, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 480
|
|
class C_OP_MaintainSequentialPath : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "maximum distance"
|
|
// MDefaultString
|
|
float m_fMaxDistance; // 0x180
|
|
// MPropertyFriendlyName "particles to map from start to end"
|
|
// MDefaultString
|
|
float m_flNumToAssign; // 0x184
|
|
// MPropertyFriendlyName "cohesion strength"
|
|
// MDefaultString
|
|
float m_flCohesionStrength; // 0x188
|
|
// MPropertyFriendlyName "control point movement tolerance"
|
|
// MDefaultString
|
|
float m_flTolerance; // 0x18c
|
|
// MPropertyFriendlyName "restart behavior (0 = bounce, 1 = loop )"
|
|
// MDefaultString
|
|
bool m_bLoop; // 0x190
|
|
// MPropertyFriendlyName "use existing particle count"
|
|
// MDefaultString
|
|
bool m_bUseParticleCount; // 0x191
|
|
CPathParameters m_PathParams; // 0x1a0
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_SetControlPointFromObjectScale : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point number"
|
|
// MDefaultString
|
|
int32_t m_nCPInput; // 0x180
|
|
// MPropertyFriendlyName "output control point number"
|
|
// MDefaultString
|
|
int32_t m_nCPOutput; // 0x184
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_OP_ExternalGenericForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "strength"
|
|
// MDefaultString
|
|
float m_flStrength; // 0x180
|
|
// MPropertyFriendlyName "curl strength"
|
|
// MDefaultString
|
|
float m_flCurlStrength; // 0x184
|
|
// MPropertyFriendlyName "linear strength"
|
|
// MDefaultString
|
|
float m_flLinearStrength; // 0x188
|
|
// MPropertyFriendlyName "radial strength"
|
|
// MDefaultString
|
|
float m_flRadialStrength; // 0x18c
|
|
// MPropertyFriendlyName "rotation strength"
|
|
// MDefaultString
|
|
float m_flRotationStrength; // 0x190
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 480
|
|
class C_OP_RemapNamedModelSequenceOnceTimed : public C_OP_RemapNamedModelElementOnceTimed, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_OP_ScreenForceFromPlayerView : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Acceleration"
|
|
// MDefaultString
|
|
float m_flAccel; // 0x180
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 464
|
|
class C_OP_RampScalarSpline : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "ramp rate min"
|
|
// MDefaultString
|
|
float m_RateMin; // 0x180
|
|
// MPropertyFriendlyName "ramp rate max"
|
|
// MDefaultString
|
|
float m_RateMax; // 0x184
|
|
// MPropertyFriendlyName "start time min"
|
|
// MDefaultString
|
|
float m_flStartTime_min; // 0x188
|
|
// MPropertyFriendlyName "start time max"
|
|
// MDefaultString
|
|
float m_flStartTime_max; // 0x18c
|
|
// MPropertyFriendlyName "end time min"
|
|
// MDefaultString
|
|
float m_flEndTime_min; // 0x190
|
|
// MPropertyFriendlyName "end time max"
|
|
// MDefaultString
|
|
float m_flEndTime_max; // 0x194
|
|
// MPropertyFriendlyName "bias"
|
|
// MDefaultString
|
|
float m_flBias; // 0x198
|
|
// MPropertyFriendlyName "ramp field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nField; // 0x1c0
|
|
// MPropertyFriendlyName "start/end proportional"
|
|
// MDefaultString
|
|
bool m_bProportionalOp; // 0x1c4
|
|
// MPropertyFriendlyName "ease out"
|
|
// MDefaultString
|
|
bool m_bEaseOut; // 0x1c5
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_OP_ColorInterpolate : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "color fade"
|
|
// MDefaultString
|
|
Color m_ColorFade; // 0x180
|
|
// MPropertyFriendlyName "fade start time"
|
|
// MDefaultString
|
|
float m_flFadeStartTime; // 0x190
|
|
// MPropertyFriendlyName "fade end time"
|
|
// MDefaultString
|
|
float m_flFadeEndTime; // 0x194
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x198
|
|
// MPropertyFriendlyName "ease in and out"
|
|
// MDefaultString
|
|
bool m_bEaseInOut; // 0x19c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
class PARTICLE_WORLD_HANDLE__
|
|
{
|
|
public:
|
|
int32_t unused; // 0x0
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 416
|
|
class C_OP_FadeAndKill : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "start fade in time"
|
|
// MDefaultString
|
|
float m_flStartFadeInTime; // 0x180
|
|
// MPropertyFriendlyName "end fade in time"
|
|
// MDefaultString
|
|
float m_flEndFadeInTime; // 0x184
|
|
// MPropertyFriendlyName "start fade out time"
|
|
// MDefaultString
|
|
float m_flStartFadeOutTime; // 0x188
|
|
// MPropertyFriendlyName "end fade out time"
|
|
// MDefaultString
|
|
float m_flEndFadeOutTime; // 0x18c
|
|
// MPropertyFriendlyName "start alpha"
|
|
// MDefaultString
|
|
float m_flStartAlpha; // 0x190
|
|
// MPropertyFriendlyName "end alpha"
|
|
// MDefaultString
|
|
float m_flEndAlpha; // 0x194
|
|
// MPropertyFriendlyName "force preserving particle order"
|
|
// MDefaultString
|
|
bool m_bForcePreserveParticleOrder; // 0x198
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 416
|
|
class C_OP_MaintainEmitter : public CParticleFunctionEmitter, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Max Particles"
|
|
// MDefaultString
|
|
int32_t m_nParticlesToMaintain; // 0x180
|
|
// MPropertyFriendlyName "Emit Rate"
|
|
// MDefaultString
|
|
float m_flEmissionRate; // 0x184
|
|
// MPropertyFriendlyName "Start Time Offset"
|
|
// MDefaultString
|
|
float m_flStartTime; // 0x188
|
|
// MPropertyFriendlyName "maintain count scale control point"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Advanced"
|
|
int32_t m_nScaleControlPoint; // 0x18c
|
|
// MPropertyFriendlyName "maintain count scale control point field"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Advanced"
|
|
int32_t m_nScaleControlPointField; // 0x190
|
|
// MPropertyFriendlyName "control point with snapshot data"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Advanced"
|
|
int32_t m_nSnapshotControlPoint; // 0x194
|
|
// MPropertyFriendlyName "group emission times for new particles"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Advanced"
|
|
bool m_bEmitInstantaneously; // 0x198
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_INIT_VelocityFromNormal : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "random speed min"
|
|
// MDefaultString
|
|
float m_fSpeedMin; // 0x180
|
|
// MPropertyFriendlyName "random speed max"
|
|
// MDefaultString
|
|
float m_fSpeedMax; // 0x184
|
|
// MPropertyFriendlyName "ignore delta time"
|
|
// MDefaultString
|
|
bool m_bIgnoreDt; // 0x188
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_MaxVelocity : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "maximum velocity"
|
|
// MDefaultString
|
|
float m_flMaxVelocity; // 0x180
|
|
// MPropertyFriendlyName "override max velocity from this CP"
|
|
// MDefaultString
|
|
int32_t m_nOverrideCP; // 0x184
|
|
// MPropertyFriendlyName "override CP field"
|
|
// MDefaultString
|
|
int32_t m_nOverrideCPField; // 0x188
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 544
|
|
class C_OP_RenderProjected : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "project on characters"
|
|
// MDefaultString
|
|
bool m_bProjectCharacter; // 0x1d0
|
|
// MPropertyFriendlyName "project on world"
|
|
// MDefaultString
|
|
bool m_bProjectWorld; // 0x1d1
|
|
// MPropertyFriendlyName "project on water"
|
|
// MDefaultString
|
|
bool m_bProjectWater; // 0x1d2
|
|
// MPropertyFriendlyName "flip horizontal"
|
|
// MDefaultString
|
|
bool m_bFlipHorizontal; // 0x1d3
|
|
// MPropertyFriendlyName "enable projected depth controls"
|
|
// MDefaultString
|
|
bool m_bEnableProjectedDepthControls; // 0x1d4
|
|
// MPropertyFriendlyName "min projection depth"
|
|
// MDefaultString
|
|
float m_flMinProjectionDepth; // 0x1d8
|
|
// MPropertyFriendlyName "max projection depth"
|
|
// MDefaultString
|
|
float m_flMaxProjectionDepth; // 0x1dc
|
|
// MPropertyFriendlyName "material"
|
|
// MPropertyAttributeEditor "AssetBrowse( vmat )"
|
|
// MDefaultString
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_hProjectedMaterial; // 0x1e0
|
|
// MPropertyFriendlyName "sheet animation time scale"
|
|
// MDefaultString
|
|
float m_flAnimationTimeScale; // 0x1e8
|
|
// MPropertyFriendlyName "orient to normal"
|
|
// MDefaultString
|
|
bool m_bOrientToNormal; // 0x1ec
|
|
// MPropertyFriendlyName "material variables"
|
|
CUtlVector< MaterialVariable_t > m_MaterialVars; // 0x1f0
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 1696
|
|
class C_OP_PerParticleForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "force scale"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flForceScale; // 0x180
|
|
// MPropertyFriendlyName "force to apply"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CPerParticleVecInput m_vForce; // 0x268
|
|
// MPropertyFriendlyName "local space control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x698
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_OP_InheritFromPeerSystem : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "read field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "written field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x184
|
|
// MPropertyFriendlyName "particle neighbor increment amount"
|
|
// MDefaultString
|
|
int32_t m_nIncrement; // 0x188
|
|
// MPropertyFriendlyName "group id"
|
|
// MDefaultString
|
|
int32_t m_nGroupID; // 0x18c
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 560
|
|
class C_INIT_CreateOnModel : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "force to be inside model"
|
|
// MDefaultString
|
|
int32_t m_nForceInModel; // 0x184
|
|
// MPropertyFriendlyName "desired hitbox"
|
|
// MDefaultString
|
|
int32_t m_nDesiredHitbox; // 0x188
|
|
// MPropertyFriendlyName "Control Point Providing Hitbox index"
|
|
// MDefaultString
|
|
int32_t m_nHitboxValueFromControlPointIndex; // 0x18c
|
|
// MPropertyFriendlyName "hitbox scale"
|
|
// MDefaultString
|
|
float m_flHitBoxScale; // 0x190
|
|
// MPropertyFriendlyName "inherited velocity scale"
|
|
// MDefaultString
|
|
float m_flBoneVelocity; // 0x194
|
|
// MPropertyFriendlyName "maximum inherited velocity"
|
|
// MDefaultString
|
|
float m_flMaxBoneVelocity; // 0x198
|
|
// MPropertyFriendlyName "direction bias"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecDirectionBias; // 0x19c
|
|
// MPropertyFriendlyName "hitbox set"
|
|
// MDefaultString
|
|
char[128] m_HitboxSetName; // 0x1a8
|
|
// MPropertyFriendlyName "bias in local space"
|
|
// MDefaultString
|
|
bool m_bLocalCoords; // 0x228
|
|
// MPropertyFriendlyName "use bones instead of hitboxes"
|
|
// MDefaultString
|
|
bool m_bUseBones; // 0x229
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 624
|
|
class C_INIT_InitFloat : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Value"
|
|
CPerParticleFloatInput m_InputValue; // 0x180
|
|
// MPropertyFriendlyName "Target"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nOutputField; // 0x268
|
|
// MPropertyFriendlyName "Set Method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x26c
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 1696
|
|
class C_OP_MovementRotateParticleAroundAxis : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "rotation axis"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CParticleCollectionVecInput m_vecRotAxis; // 0x180
|
|
// MPropertyFriendlyName "rotation rate"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flRotRate; // 0x5b0
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x698
|
|
// MPropertyFriendlyName "use local space"
|
|
// MDefaultString
|
|
bool m_bLocalSpace; // 0x69c
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 560
|
|
class C_OP_DistanceToCP : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "distance minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x184
|
|
// MPropertyFriendlyName "distance maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x188
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x18c
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x190
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nStartCP; // 0x194
|
|
// MPropertyFriendlyName "ensure line of sight"
|
|
// MDefaultString
|
|
bool m_bLOS; // 0x198
|
|
// MPropertyFriendlyName "LOS collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x199
|
|
// MPropertyFriendlyName "maximum trace length"
|
|
// MDefaultString
|
|
float m_flMaxTraceLength; // 0x21c
|
|
// MPropertyFriendlyName "LOS Failure Scalar"
|
|
// MDefaultString
|
|
float m_flLOSScale; // 0x220
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x224
|
|
// MPropertyFriendlyName "only active within specified distance"
|
|
// MDefaultString
|
|
bool m_bActiveRange; // 0x228
|
|
// MPropertyFriendlyName "output is additive"
|
|
// MDefaultString
|
|
bool m_bAdditive; // 0x229
|
|
};
|
|
|
|
// Aligment: 12
|
|
// Size: 464
|
|
class C_OP_SetControlPointPositions : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "set positions in world space"
|
|
// MDefaultString
|
|
bool m_bUseWorldLocation; // 0x180
|
|
// MPropertyFriendlyName "inherit CP orientation"
|
|
// MDefaultString
|
|
bool m_bOrient; // 0x181
|
|
// MPropertyFriendlyName "only set position once"
|
|
// MDefaultString
|
|
bool m_bSetOnce; // 0x182
|
|
// MPropertyFriendlyName "first control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP1; // 0x184
|
|
// MPropertyFriendlyName "second control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP2; // 0x188
|
|
// MPropertyFriendlyName "third control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP3; // 0x18c
|
|
// MPropertyFriendlyName "fourth control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP4; // 0x190
|
|
// MPropertyFriendlyName "first control point location"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecCP1Pos; // 0x194
|
|
// MPropertyFriendlyName "second control point location"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecCP2Pos; // 0x1a0
|
|
// MPropertyFriendlyName "third control point location"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecCP3Pos; // 0x1ac
|
|
// MPropertyFriendlyName "fourth control point location"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecCP4Pos; // 0x1b8
|
|
// MPropertyFriendlyName "control point to offset positions from"
|
|
// MDefaultString
|
|
int32_t m_nHeadLocation; // 0x1c4
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 432
|
|
class C_OP_ConstrainDistanceToUserSpecifiedPath : public CParticleFunctionConstraint, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "minimum distance"
|
|
// MDefaultString
|
|
float m_fMinDistance; // 0x180
|
|
// MPropertyFriendlyName "maximum distance"
|
|
// MDefaultString
|
|
float m_flMaxDistance; // 0x184
|
|
// MPropertyFriendlyName "Time scale"
|
|
// MDefaultString
|
|
float m_flTimeScale; // 0x188
|
|
// MPropertyFriendlyName "Treat path as a loop"
|
|
// MDefaultString
|
|
bool m_bLoopedPath; // 0x18c
|
|
// MPropertyFriendlyName "path points"
|
|
CUtlVector< PointDefinitionWithTimeValues_t > m_pointList; // 0x190
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 432
|
|
class C_INIT_CreateInEpitrochoid : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "first dimension 0-2 (-1 disables)"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nComponent1; // 0x180
|
|
// MPropertyFriendlyName "second dimension 0-2 (-1 disables)"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nComponent2; // 0x184
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x188
|
|
// MPropertyFriendlyName "scale from conrol point (radius 1/radius 2/offset)"
|
|
// MDefaultString
|
|
int32_t m_nScaleCP; // 0x18c
|
|
// MPropertyFriendlyName "particle density"
|
|
// MDefaultString
|
|
float m_flParticleDensity; // 0x190
|
|
// MPropertyFriendlyName "point offset"
|
|
// MDefaultString
|
|
float m_flOffset; // 0x194
|
|
// MPropertyFriendlyName "radius 1"
|
|
// MDefaultString
|
|
float m_flRadius1; // 0x198
|
|
// MPropertyFriendlyName "radius 2"
|
|
// MDefaultString
|
|
float m_flRadius2; // 0x19c
|
|
// MPropertyFriendlyName "use particle count instead of creation time"
|
|
// MDefaultString
|
|
bool m_bUseCount; // 0x1a0
|
|
// MPropertyFriendlyName "local space"
|
|
// MDefaultString
|
|
bool m_bUseLocalCoords; // 0x1a1
|
|
// MPropertyFriendlyName "offset from existing position"
|
|
// MDefaultString
|
|
bool m_bOffsetExistingPos; // 0x1a2
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 1104
|
|
class C_INIT_CreateParticleImpulse : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "radius"
|
|
CPerParticleFloatInput m_InputRadius; // 0x180
|
|
// MPropertyFriendlyName "magnitude"
|
|
CPerParticleFloatInput m_InputMagnitude; // 0x268
|
|
// MPropertyFriendlyName "force falloff function"
|
|
// MDefaultString
|
|
ParticleFalloffFunction_t m_nFalloffFunction; // 0x350
|
|
// MPropertyFriendlyName "exponential falloff exponent"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_InputFalloffExp; // 0x358
|
|
// MPropertyFriendlyName "impulse type"
|
|
// MDefaultString
|
|
ParticleImpulseType_t m_nImpulseType; // 0x440
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 464
|
|
class C_OP_RemapCPtoVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point number"
|
|
// MDefaultString
|
|
int32_t m_nCPInput; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "local space CP"
|
|
// MDefaultString
|
|
int32_t m_nLocalSpaceCP; // 0x188
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vInputMin; // 0x18c
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vInputMax; // 0x198
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vOutputMin; // 0x1a4
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vOutputMax; // 0x1b0
|
|
// MPropertyFriendlyName "emitter lifetime start time (seconds)"
|
|
// MDefaultString
|
|
float m_flStartTime; // 0x1bc
|
|
// MPropertyFriendlyName "emitter lifetime end time (seconds)"
|
|
// MDefaultString
|
|
float m_flEndTime; // 0x1c0
|
|
// MPropertyFriendlyName "interpolation scale"
|
|
// MDefaultString
|
|
float m_flInterpRate; // 0x1c4
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x1c8
|
|
// MPropertyFriendlyName "offset position"
|
|
// MDefaultString
|
|
bool m_bOffset; // 0x1cc
|
|
// MPropertyFriendlyName "accelerate position"
|
|
// MDefaultString
|
|
bool m_bAccelerate; // 0x1cd
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 2416
|
|
class C_OP_PinParticleToCP : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "offset"
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecOffset; // 0x188
|
|
// MPropertyFriendlyName "offset in local space"
|
|
// MDefaultString
|
|
bool m_bOffsetLocal; // 0x5b8
|
|
// MPropertyFriendlyName "particle to use"
|
|
// MDefaultString
|
|
ParticleSelection_t m_nParticleSelection; // 0x5bc
|
|
// MPropertyFriendlyName "particle number"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nParticleNumber; // 0x5c0
|
|
// MPropertyFriendlyName "pin break type"
|
|
// MDefaultString
|
|
ParticlePinDistance_t m_nPinBreakType; // 0x6a8
|
|
// MPropertyFriendlyName "break length %"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flBreakDistance; // 0x6b0
|
|
// MPropertyFriendlyName "break speed"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flBreakSpeed; // 0x798
|
|
// MPropertyFriendlyName "break age"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flAge; // 0x880
|
|
// MPropertyFriendlyName "break comparison control point 1"
|
|
// MDefaultString
|
|
int32_t m_nBreakControlPointNumber; // 0x968
|
|
// MPropertyFriendlyName "break comparison control point 2"
|
|
// MDefaultString
|
|
int32_t m_nBreakControlPointNumber2; // 0x96c
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 448
|
|
class C_OP_DriveCPFromGlobalSoundFloat : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutputControlPoint; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nOutputField; // 0x184
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x188
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x18c
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x190
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x194
|
|
// MPropertyFriendlyName "sound stack name"
|
|
CUtlString m_StackName; // 0x198
|
|
// MPropertyFriendlyName "sound operator name"
|
|
CUtlString m_OperatorName; // 0x1a0
|
|
// MPropertyFriendlyName "sound field name"
|
|
CUtlString m_FieldName; // 0x1a8
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 432
|
|
class C_OP_RemapDirectionToCPToVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "scale factor"
|
|
// MDefaultString
|
|
float m_flScale; // 0x188
|
|
// MPropertyFriendlyName "offset rotation"
|
|
// MDefaultString
|
|
float m_flOffsetRot; // 0x18c
|
|
// MPropertyFriendlyName "offset axis"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecOffsetAxis; // 0x190
|
|
// MPropertyFriendlyName "normalize"
|
|
// MDefaultString
|
|
bool m_bNormalize; // 0x19c
|
|
// MPropertyFriendlyName "strength field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldStrength; // 0x1a0
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 640
|
|
class C_OP_SetChildControlPoints : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "group ID to affect"
|
|
// MDefaultString
|
|
int32_t m_nChildGroupID; // 0x180
|
|
// MPropertyFriendlyName "first control point to set"
|
|
// MDefaultString
|
|
int32_t m_nFirstControlPoint; // 0x184
|
|
// MPropertyFriendlyName "# of control points to set"
|
|
// MDefaultString
|
|
int32_t m_nNumControlPoints; // 0x188
|
|
// MPropertyFriendlyName "first particle to copy"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nFirstSourcePoint; // 0x190
|
|
// MPropertyFriendlyName "set orientation"
|
|
// MDefaultString
|
|
bool m_bSetOrientation; // 0x278
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_INIT_NormalAlignToCP : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_INIT_PositionOffset : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "offset min"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_OffsetMin; // 0x180
|
|
// MPropertyFriendlyName "offset max"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_OffsetMax; // 0x18c
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x198
|
|
// MPropertyFriendlyName "offset in local space 0/1"
|
|
// MDefaultString
|
|
bool m_bLocalCoords; // 0x19c
|
|
// MPropertyFriendlyName "offset proportional to radius 0/1"
|
|
// MDefaultString
|
|
bool m_bProportional; // 0x19d
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_INIT_InheritVelocity : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "velocity scale"
|
|
// MDefaultString
|
|
float m_flVelocityScale; // 0x184
|
|
};
|
|
|
|
// Aligment: 17
|
|
// Size: 2000
|
|
class C_OP_RenderCables : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "material"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "AssetBrowse( vmat )"
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_hMaterial; // 0x1d0
|
|
// MPropertyFriendlyName "texture repetition mode"
|
|
// MDefaultString
|
|
TextureRepetitionMode_t m_nTextureRepetitionMode; // 0x1d8
|
|
// MPropertyFriendlyName "texture repetitions"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flTextureRepeatsPerSegment; // 0x1e0
|
|
// MPropertyFriendlyName "texture repetitions around cable"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flTextureRepeatsCircumference; // 0x2c8
|
|
// MPropertyFriendlyName "color map offset along path"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flColorMapOffsetV; // 0x3b0
|
|
// MPropertyFriendlyName "color map offset around cable"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flColorMapOffsetU; // 0x498
|
|
// MPropertyFriendlyName "normal map offset along path"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flNormalMapOffsetV; // 0x580
|
|
// MPropertyFriendlyName "normal map offset around cable"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flNormalMapOffsetU; // 0x668
|
|
// MPropertyFriendlyName "draw caps at each end of the cable"
|
|
// MDefaultString
|
|
bool m_bDrawCableCaps; // 0x750
|
|
// MPropertyFriendlyName "cable end cap shape factor"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 2"
|
|
float m_flCapRoundness; // 0x754
|
|
// MPropertyFriendlyName "cable end cap offset amount"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 2"
|
|
float m_flCapOffsetAmount; // 0x758
|
|
// MPropertyFriendlyName "tessellation scale factor"
|
|
// MDefaultString
|
|
float m_flTessScale; // 0x75c
|
|
// MPropertyFriendlyName "minimum steps between particles"
|
|
// MDefaultString
|
|
int32_t m_nMinTesselation; // 0x760
|
|
// MPropertyFriendlyName "maximum steps between particles"
|
|
// MDefaultString
|
|
int32_t m_nMaxTesselation; // 0x764
|
|
// MPropertyFriendlyName "roundness factor"
|
|
// MDefaultString
|
|
int32_t m_nRoundness; // 0x768
|
|
// MPropertyFriendlyName "material float variables"
|
|
CUtlVector< FloatInputMaterialVariable_t > m_MaterialFloatVars; // 0x770
|
|
// MPropertyFriendlyName "material vector variables"
|
|
CUtlVector< VecInputMaterialVariable_t > m_MaterialVecVars; // 0x7a0
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 416
|
|
class C_INIT_InitFromCPSnapshot : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "snapshot control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "field to read"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nAttributeToRead; // 0x184
|
|
// MPropertyFriendlyName "field to write"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nAttributeToWrite; // 0x188
|
|
// MPropertyFriendlyName "local space control point number"
|
|
// MDefaultString
|
|
int32_t m_nLocalSpaceCP; // 0x18c
|
|
// MPropertyFriendlyName "random order"
|
|
// MDefaultString
|
|
bool m_bRandom; // 0x190
|
|
// MPropertyFriendlyName "reverse order"
|
|
// MDefaultString
|
|
bool m_bReverse; // 0x191
|
|
// MPropertyFriendlyName "random seed"
|
|
// MDefaultString
|
|
int32_t m_nRandomSeed; // 0x194
|
|
// MPropertyFriendlyName "local space angles"
|
|
// MDefaultString
|
|
bool m_bLocalSpaceAngles; // 0x198
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 480
|
|
class C_OP_RemapNamedModelSequenceEndCap : public C_OP_RemapNamedModelElementEndCap, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 416
|
|
class C_OP_DifferencePreviousParticle : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "difference minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x188
|
|
// MPropertyFriendlyName "difference maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x18c
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x190
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x194
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x198
|
|
// MPropertyFriendlyName "only active within specified difference"
|
|
// MDefaultString
|
|
bool m_bActiveRange; // 0x19c
|
|
// MPropertyFriendlyName "also set ouput to previous particle"
|
|
// MDefaultString
|
|
bool m_bSetPreviousParticle; // 0x19d
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_OP_SetControlPointToHMD : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP1; // 0x180
|
|
// MPropertyFriendlyName "control point offset"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecCP1Pos; // 0x184
|
|
// MPropertyFriendlyName "use hmd orientation"
|
|
// MDefaultString
|
|
bool m_bOrientToHMD; // 0x190
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_ClampScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x184
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x188
|
|
};
|
|
|
|
// Aligment: 12
|
|
// Size: 560
|
|
class C_INIT_InitialRepulsionVelocity : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x180
|
|
// MPropertyFriendlyName "minimum velocity"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecOutputMin; // 0x200
|
|
// MPropertyFriendlyName "maximum velocity"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecOutputMax; // 0x20c
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x218
|
|
// MPropertyFriendlyName "per particle world collision tests"
|
|
// MDefaultString
|
|
bool m_bPerParticle; // 0x21c
|
|
// MPropertyFriendlyName "offset instead of accelerate"
|
|
// MDefaultString
|
|
bool m_bTranslate; // 0x21d
|
|
// MPropertyFriendlyName "offset proportional to radius 0/1"
|
|
// MDefaultString
|
|
bool m_bProportional; // 0x21e
|
|
// MPropertyFriendlyName "trace length"
|
|
// MDefaultString
|
|
float m_flTraceLength; // 0x220
|
|
// MPropertyFriendlyName "use radius for per particle trace length"
|
|
// MDefaultString
|
|
bool m_bPerParticleTR; // 0x224
|
|
// MPropertyFriendlyName "inherit from parent"
|
|
// MDefaultString
|
|
bool m_bInherit; // 0x225
|
|
// MPropertyFriendlyName "control points to broadcast to children (n + 1)"
|
|
// MDefaultString
|
|
int32_t m_nChildCP; // 0x228
|
|
// MPropertyFriendlyName "child group ID to affect"
|
|
// MDefaultString
|
|
int32_t m_nChildGroupID; // 0x22c
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 640
|
|
class C_OP_LerpScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "value to lerp to"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flOutput; // 0x188
|
|
// MPropertyFriendlyName "start time"
|
|
// MDefaultString
|
|
float m_flStartTime; // 0x270
|
|
// MPropertyFriendlyName "end time"
|
|
// MDefaultString
|
|
float m_flEndTime; // 0x274
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 864
|
|
class C_OP_MovementMoveAlongSkinnedCPSnapshot : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "snapshot control point number"
|
|
// MDefaultString
|
|
int32_t m_nSnapshotControlPointNumber; // 0x184
|
|
// MPropertyFriendlyName "set normal"
|
|
// MDefaultString
|
|
bool m_bSetNormal; // 0x188
|
|
// MPropertyFriendlyName "Interpolation"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInterpolation; // 0x190
|
|
// MPropertyFriendlyName "Snapshot Index T Value"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flTValue; // 0x278
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 544
|
|
class C_INIT_SetHitboxToModel : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "force to be inside model"
|
|
// MDefaultString
|
|
int32_t m_nForceInModel; // 0x184
|
|
// MPropertyFriendlyName "desired hitbox"
|
|
// MDefaultString
|
|
int32_t m_nDesiredHitbox; // 0x188
|
|
// MPropertyFriendlyName "model hitbox scale"
|
|
// MDefaultString
|
|
float m_flHitBoxScale; // 0x18c
|
|
// MPropertyFriendlyName "direction bias"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecDirectionBias; // 0x190
|
|
// MPropertyFriendlyName "maintain existing hitbox"
|
|
// MDefaultString
|
|
bool m_bMaintainHitbox; // 0x19c
|
|
// MPropertyFriendlyName "use bones instead of hitboxes"
|
|
// MDefaultString
|
|
bool m_bUseBones; // 0x19d
|
|
// MPropertyFriendlyName "hitbox set"
|
|
// MDefaultString
|
|
char[128] m_HitboxSetName; // 0x19e
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 1472
|
|
class C_INIT_InitVec : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Value"
|
|
CPerParticleVecInput m_InputValue; // 0x180
|
|
// MPropertyFriendlyName "Target"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nOutputField; // 0x5b0
|
|
// MPropertyFriendlyName "Set Method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x5b4
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_OP_AlphaDecay : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "minimum alpha"
|
|
// MDefaultString
|
|
float m_flMinAlpha; // 0x180
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 416
|
|
class C_OP_SequenceFromModel : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "current anim time output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutputAnim; // 0x188
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x18c
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x190
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x194
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x198
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x19c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 1088
|
|
class C_OP_ColorAdjustHSL : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "hue adjust"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flHueAdjust; // 0x180
|
|
// MPropertyFriendlyName "saturation adjust"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flSaturationAdjust; // 0x268
|
|
// MPropertyFriendlyName "lightness adjust"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flLightnessAdjust; // 0x350
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_OP_FadeAndKillForTracers : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "start fade in time"
|
|
// MDefaultString
|
|
float m_flStartFadeInTime; // 0x180
|
|
// MPropertyFriendlyName "end fade in time"
|
|
// MDefaultString
|
|
float m_flEndFadeInTime; // 0x184
|
|
// MPropertyFriendlyName "start fade out time"
|
|
// MDefaultString
|
|
float m_flStartFadeOutTime; // 0x188
|
|
// MPropertyFriendlyName "end fade out time"
|
|
// MDefaultString
|
|
float m_flEndFadeOutTime; // 0x18c
|
|
// MPropertyFriendlyName "start alpha"
|
|
// MDefaultString
|
|
float m_flStartAlpha; // 0x190
|
|
// MPropertyFriendlyName "end alpha"
|
|
// MDefaultString
|
|
float m_flEndAlpha; // 0x194
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 432
|
|
class C_OP_Noise : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x184
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x188
|
|
// MPropertyFriendlyName "noise coordinate scale"
|
|
// MDefaultString
|
|
fltx4 m_fl4NoiseScale; // 0x190
|
|
// MPropertyFriendlyName "additive"
|
|
// MDefaultString
|
|
bool m_bAdditive; // 0x1a0
|
|
// MPropertyFriendlyName "Noise animation time scale"
|
|
// MDefaultString
|
|
float m_flNoiseAnimationTimeScale; // 0x1a4
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_OP_LagCompensation : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "desired velocity CP"
|
|
// MDefaultString
|
|
int32_t m_nDesiredVelocityCP; // 0x180
|
|
// MPropertyFriendlyName "latency CP"
|
|
// MDefaultString
|
|
int32_t m_nLatencyCP; // 0x184
|
|
// MPropertyFriendlyName "latency CP field"
|
|
// MDefaultString
|
|
int32_t m_nLatencyCPField; // 0x188
|
|
// MPropertyFriendlyName "desired velocity CP field override(for speed only)"
|
|
// MDefaultString
|
|
int32_t m_nDesiredVelocityCPField; // 0x18c
|
|
};
|
|
|
|
// Aligment: 17
|
|
// Size: 448
|
|
class C_INIT_InitSkinnedPositionFromCPSnapshot : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "snapshot control point number"
|
|
// MDefaultString
|
|
int32_t m_nSnapshotControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x184
|
|
// MPropertyFriendlyName "random order"
|
|
// MDefaultString
|
|
bool m_bRandom; // 0x188
|
|
// MPropertyFriendlyName "random seed"
|
|
// MDefaultString
|
|
int32_t m_nRandomSeed; // 0x18c
|
|
// MPropertyFriendlyName "prepare for rigid lock"
|
|
// MDefaultString
|
|
bool m_bRigid; // 0x190
|
|
// MPropertyFriendlyName "set normal"
|
|
// MDefaultString
|
|
bool m_bSetNormal; // 0x191
|
|
// MPropertyFriendlyName "normal velocity ignore delta time"
|
|
// MDefaultString
|
|
bool m_bIgnoreDt; // 0x192
|
|
// MPropertyFriendlyName "normal velocity min"
|
|
// MDefaultString
|
|
float m_flMinNormalVelocity; // 0x194
|
|
// MPropertyFriendlyName "normal velocity max"
|
|
// MDefaultString
|
|
float m_flMaxNormalVelocity; // 0x198
|
|
// MPropertyFriendlyName "particle increment amount"
|
|
// MDefaultString
|
|
float m_flIncrement; // 0x19c
|
|
// MPropertyFriendlyName "Full Loop Increment Amount"
|
|
// MDefaultString
|
|
int32_t m_nFullLoopIncrement; // 0x1a0
|
|
// MPropertyFriendlyName "Snapshot start point"
|
|
// MDefaultString
|
|
int32_t m_nSnapShotStartPoint; // 0x1a4
|
|
// MPropertyFriendlyName "inherited bone velocity"
|
|
// MDefaultString
|
|
float m_flBoneVelocity; // 0x1a8
|
|
// MPropertyFriendlyName "max inherited bone velocity"
|
|
// MDefaultString
|
|
float m_flBoneVelocityMax; // 0x1ac
|
|
// MPropertyFriendlyName "Set Color"
|
|
// MDefaultString
|
|
bool m_bCopyColor; // 0x1b0
|
|
// MPropertyFriendlyName "Set Alpha"
|
|
// MDefaultString
|
|
bool m_bCopyAlpha; // 0x1b1
|
|
// MPropertyFriendlyName "Set Radius"
|
|
// MDefaultString
|
|
bool m_bCopyRadius; // 0x1b2
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 232
|
|
class CPerParticleFloatInput : public CParticleFloatInput
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_ConnectParentParticleToNearest : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point to set"
|
|
// MDefaultString
|
|
int32_t m_nFirstControlPoint; // 0x180
|
|
// MPropertyFriendlyName "Second Control point to set"
|
|
// MDefaultString
|
|
int32_t m_nSecondControlPoint; // 0x184
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
class PARTICLE_EHANDLE__
|
|
{
|
|
public:
|
|
int32_t unused; // 0x0
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 8
|
|
class IParticleEffect
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_INIT_CreateFromParentParticles : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "inherited velocity scale"
|
|
// MDefaultString
|
|
float m_flVelocityScale; // 0x180
|
|
// MPropertyFriendlyName "particle increment amount"
|
|
// MDefaultString
|
|
float m_flIncrement; // 0x184
|
|
// MPropertyFriendlyName "random parent particle distribution"
|
|
// MDefaultString
|
|
bool m_bRandomDistribution; // 0x188
|
|
// MPropertyFriendlyName "random seed"
|
|
// MDefaultString
|
|
int32_t m_nRandomSeed; // 0x18c
|
|
// MPropertyFriendlyName "sub frame interpolation"
|
|
// MDefaultString
|
|
bool m_bSubFrame; // 0x190
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 1696
|
|
class C_OP_SetVec : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "value"
|
|
CPerParticleVecInput m_InputValue; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nOutputField; // 0x5b0
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x5b4
|
|
// MPropertyFriendlyName "interpolation"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_Lerp; // 0x5b8
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_OP_MovementMaintainOffset : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "desired offset"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecOffset; // 0x180
|
|
// MPropertyFriendlyName "local space CP"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x18c
|
|
// MPropertyFriendlyName "scale by radius"
|
|
// MDefaultString
|
|
bool m_bRadiusScale; // 0x190
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 480
|
|
class C_OP_RemapNamedModelBodyPartOnceTimed : public C_OP_RemapNamedModelElementOnceTimed, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 544
|
|
class C_OP_LockToBone : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control_point_number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "lifetime fade start"
|
|
// MDefaultString
|
|
float m_flLifeTimeFadeStart; // 0x184
|
|
// MPropertyFriendlyName "lifetime fade end"
|
|
// MDefaultString
|
|
float m_flLifeTimeFadeEnd; // 0x188
|
|
// MPropertyFriendlyName "instant jump threshold"
|
|
// MDefaultString
|
|
float m_flJumpThreshold; // 0x18c
|
|
// MPropertyFriendlyName "previous position scale"
|
|
// MDefaultString
|
|
float m_flPrevPosScale; // 0x190
|
|
// MPropertyFriendlyName "hitbox set"
|
|
// MDefaultString
|
|
char[128] m_HitboxSetName; // 0x194
|
|
// MPropertyFriendlyName "rigid lock"
|
|
// MDefaultString
|
|
bool m_bRigid; // 0x214
|
|
// MPropertyFriendlyName "use bones instead of hitboxes"
|
|
// MDefaultString
|
|
bool m_bUseBones; // 0x215
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 480
|
|
class C_OP_CalculateVectorAttribute : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "start value"
|
|
// MDefaultString
|
|
Vector m_vStartValue; // 0x180
|
|
// MPropertyFriendlyName "input field 1"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldInput1; // 0x18c
|
|
// MPropertyFriendlyName "input scale 1"
|
|
// MDefaultString
|
|
float m_flInputScale1; // 0x190
|
|
// MPropertyFriendlyName "input field 2"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldInput2; // 0x194
|
|
// MPropertyFriendlyName "input scale 2"
|
|
// MDefaultString
|
|
float m_flInputScale2; // 0x198
|
|
// MPropertyFriendlyName "control point input 1"
|
|
ControlPointReference_t m_nControlPointInput1; // 0x19c
|
|
// MPropertyFriendlyName "control point scale 1"
|
|
// MDefaultString
|
|
float m_flControlPointScale1; // 0x1b0
|
|
// MPropertyFriendlyName "control point input 2"
|
|
ControlPointReference_t m_nControlPointInput2; // 0x1b4
|
|
// MPropertyFriendlyName "control point scale 2"
|
|
// MDefaultString
|
|
float m_flControlPointScale2; // 0x1c8
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x1cc
|
|
// MPropertyFriendlyName "final per component scale"
|
|
// MDefaultString
|
|
Vector m_vFinalOutputScale; // 0x1d0
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_OP_RemapCPOrientationToYaw : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "rotation field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_rotation"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "rotation offset"
|
|
// MDefaultString
|
|
float m_flRotOffset; // 0x188
|
|
// MPropertyFriendlyName "spin strength"
|
|
// MDefaultString
|
|
float m_flSpinStrength; // 0x18c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_DampenToCP : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "falloff range"
|
|
// MDefaultString
|
|
float m_flRange; // 0x184
|
|
// MPropertyFriendlyName "dampen scale"
|
|
// MDefaultString
|
|
float m_flScale; // 0x188
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_RemapVectorComponentToScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Input Vector"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x180
|
|
// MPropertyFriendlyName "Output Scalar"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "Vector Component"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nComponent; // 0x188
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 20
|
|
struct PointDefinition_t
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Control point"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint; // 0x0
|
|
// MPropertyFriendlyName "Use local coordinates for offset"
|
|
// MDefaultString
|
|
bool m_bLocalCoords; // 0x4
|
|
// MPropertyFriendlyName "Offset from control point"
|
|
// MDefaultString
|
|
Vector m_vOffset; // 0x8
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 896
|
|
class C_OP_SetFloatCollection : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "value"
|
|
CParticleCollectionFloatInput m_InputValue; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nOutputField; // 0x268
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x26c
|
|
// MPropertyFriendlyName "interpolation"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_Lerp; // 0x270
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_OP_InheritFromParentParticlesV2 : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "scale"
|
|
// MDefaultString
|
|
float m_flScale; // 0x180
|
|
// MPropertyFriendlyName "inherited field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "particle increment amount"
|
|
// MDefaultString
|
|
int32_t m_nIncrement; // 0x188
|
|
// MPropertyFriendlyName "random parent particle distribution"
|
|
// MDefaultString
|
|
bool m_bRandomDistribution; // 0x18c
|
|
// MPropertyFriendlyName "behavior if parent particle dies"
|
|
// MDefaultString
|
|
MissingParentInheritBehavior_t m_nMissingParentBehavior; // 0x190
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2544
|
|
class C_OP_RemapCrossProductOfTwoVectorsToVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input vector 1"
|
|
CPerParticleVecInput m_InputVec1; // 0x180
|
|
// MPropertyFriendlyName "input vector 2"
|
|
CPerParticleVecInput m_InputVec2; // 0x5b0
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x9e0
|
|
// MPropertyFriendlyName "normalize output"
|
|
// MDefaultString
|
|
bool m_bNormalize; // 0x9e4
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_SetCPOrientationToDirection : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point"
|
|
// MDefaultString
|
|
int32_t m_nInputControlPoint; // 0x180
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutputControlPoint; // 0x184
|
|
};
|
|
|
|
// Aligment: 15
|
|
// Size: 800
|
|
class C_OP_MovementPlaceOnGround : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "offset"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flOffset; // 0x180
|
|
// MPropertyFriendlyName "max trace length"
|
|
// MDefaultString
|
|
float m_flMaxTraceLength; // 0x268
|
|
// MPropertyFriendlyName "CP movement tolerance"
|
|
// MDefaultString
|
|
float m_flTolerance; // 0x26c
|
|
// MPropertyFriendlyName "trace offset"
|
|
// MDefaultString
|
|
float m_flTraceOffset; // 0x270
|
|
// MPropertyFriendlyName "interpolation rate"
|
|
// MDefaultString
|
|
float m_flLerpRate; // 0x274
|
|
// MPropertyFriendlyName "collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x278
|
|
// MPropertyFriendlyName "reference CP 1"
|
|
// MDefaultString
|
|
int32_t m_nRefCP1; // 0x2f8
|
|
// MPropertyFriendlyName "reference CP 2"
|
|
// MDefaultString
|
|
int32_t m_nRefCP2; // 0x2fc
|
|
// MPropertyFriendlyName "interploation distance tolerance cp"
|
|
// MDefaultString
|
|
int32_t m_nLerpCP; // 0x300
|
|
// MPropertyFriendlyName "kill on no collision"
|
|
// MDefaultString
|
|
bool m_bKill; // 0x308
|
|
// MPropertyFriendlyName "include water"
|
|
// MDefaultString
|
|
bool m_bIncludeWater; // 0x309
|
|
// MPropertyFriendlyName "set normal"
|
|
// MDefaultString
|
|
bool m_bSetNormal; // 0x30c
|
|
// MPropertyFriendlyName "treat offset as scalar of particle radius"
|
|
// MDefaultString
|
|
bool m_bScaleOffset; // 0x30d
|
|
// MPropertyFriendlyName "preserve initial Z-offset relative to cp"
|
|
// MDefaultString
|
|
int32_t m_nPreserveOffsetCP; // 0x310
|
|
// MPropertyFriendlyName "CP Entity to Ignore for Collisions"
|
|
// MDefaultString
|
|
int32_t m_nIgnoreCP; // 0x314
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 432
|
|
class C_OP_LockToPointList : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "point list"
|
|
CUtlVector< PointDefinition_t > m_pointList; // 0x188
|
|
// MPropertyFriendlyName "space points along path"
|
|
// MDefaultString
|
|
bool m_bPlaceAlongPath; // 0x1a0
|
|
// MPropertyFriendlyName "Treat path as a loop"
|
|
// MDefaultString
|
|
bool m_bClosedLoop; // 0x1a1
|
|
// MPropertyFriendlyName "Numer of points along path"
|
|
// MDefaultString
|
|
int32_t m_nNumPointsAlongPath; // 0x1a4
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_SetCPOrientationToPointAtCP : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "CP to point towards"
|
|
// MDefaultString
|
|
int32_t m_nInputCP; // 0x180
|
|
// MPropertyFriendlyName "CP to set"
|
|
// MDefaultString
|
|
int32_t m_nOutputCP; // 0x184
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_OP_VelocityDecay : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "minimum velocity"
|
|
// MDefaultString
|
|
float m_flMinVelocity; // 0x180
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_OP_LerpEndCapVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "value to lerp to"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vecOutput; // 0x184
|
|
// MPropertyFriendlyName "lerp time"
|
|
// MDefaultString
|
|
float m_flLerpTime; // 0x190
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 864
|
|
class C_OP_LerpToInitialPosition : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "Interpolation"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInterpolation; // 0x188
|
|
// MPropertyFriendlyName "position cache attribute"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nCacheField; // 0x270
|
|
// MPropertyFriendlyName "scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flScale; // 0x278
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 480
|
|
class C_OP_RenderText : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "outline color"
|
|
// MDefaultString
|
|
Color m_OutlineColor; // 0x1d0
|
|
// MPropertyFriendlyName "default text"
|
|
CUtlString m_DefaultText; // 0x1d8
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 416
|
|
class C_INIT_RemapCPOrientationToRotations : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "offset pitch/yaw/roll"
|
|
// MDefaultString
|
|
Vector m_vecRotation; // 0x184
|
|
// MPropertyFriendlyName "Use Quaternians Internally"
|
|
// MDefaultString
|
|
bool m_bUseQuat; // 0x190
|
|
// MPropertyFriendlyName "Write normal instead of rotation"
|
|
// MDefaultString
|
|
bool m_bWriteNormal; // 0x191
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 864
|
|
class C_OP_ReadFromNeighboringParticle : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "read field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x180
|
|
// MPropertyFriendlyName "written field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "particle increment amount"
|
|
// MDefaultString
|
|
int32_t m_nIncrement; // 0x188
|
|
// MPropertyFriendlyName "maximum distance"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_DistanceCheck; // 0x190
|
|
// MPropertyFriendlyName "Interpolation"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInterpolation; // 0x278
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_OP_Cull : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "cull percentage"
|
|
// MDefaultString
|
|
float m_flCullPerc; // 0x180
|
|
// MPropertyFriendlyName "cull start time"
|
|
// MDefaultString
|
|
float m_flCullStart; // 0x184
|
|
// MPropertyFriendlyName "cull end time"
|
|
// MDefaultString
|
|
float m_flCullEnd; // 0x188
|
|
// MPropertyFriendlyName "cull time exponent"
|
|
// MDefaultString
|
|
float m_flCullExp; // 0x18c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_OP_NormalLock : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 464
|
|
class C_OP_LockToSavedSequentialPathV2 : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "start fade time"
|
|
// MDefaultString
|
|
float m_flFadeStart; // 0x180
|
|
// MPropertyFriendlyName "end fade time"
|
|
// MDefaultString
|
|
float m_flFadeEnd; // 0x184
|
|
// MPropertyFriendlyName "Use sequential CP pairs between start and end point"
|
|
// MDefaultString
|
|
bool m_bCPPairs; // 0x188
|
|
CPathParameters m_PathParams; // 0x190
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 1080
|
|
struct VecInputMaterialVariable_t
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "material variable"
|
|
// MDefaultString
|
|
CUtlString m_strVariable; // 0x0
|
|
// MPropertyFriendlyName "input"
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecInput; // 0x8
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 480
|
|
class C_INIT_CreateSequentialPathV2 : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Max Distance From Path"
|
|
// MDefaultString
|
|
float m_fMaxDistance; // 0x180
|
|
// MPropertyFriendlyName "Paticles Along Path"
|
|
// MDefaultString
|
|
float m_flNumToAssign; // 0x184
|
|
// MPropertyFriendlyName "Loop"
|
|
// MDefaultString
|
|
bool m_bLoop; // 0x188
|
|
// MPropertyFriendlyName "use sequential CP pairs between start and end point"
|
|
// MDefaultString
|
|
bool m_bCPPairs; // 0x189
|
|
// MPropertyFriendlyName "save offset"
|
|
// MDefaultString
|
|
bool m_bSaveOffset; // 0x18a
|
|
CPathParameters m_PathParams; // 0x190
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 416
|
|
class C_OP_RemapVisibilityScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "visibility minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x188
|
|
// MPropertyFriendlyName "visibility maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x18c
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x190
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x194
|
|
// MPropertyFriendlyName "radius scale"
|
|
// MDefaultString
|
|
float m_flRadiusScale; // 0x198
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 464
|
|
class C_OP_RenderClothForce : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_OP_RestartAfterDuration : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "minimum restart time"
|
|
// MDefaultString
|
|
float m_flDurationMin; // 0x180
|
|
// MPropertyFriendlyName "maximum restart time"
|
|
// MDefaultString
|
|
float m_flDurationMax; // 0x184
|
|
// MPropertyFriendlyName "control point to scale duration"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x188
|
|
// MPropertyFriendlyName "control point field X/Y/Z"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nCPField; // 0x18c
|
|
// MPropertyFriendlyName "child group ID"
|
|
// MDefaultString
|
|
int32_t m_nChildGroupID; // 0x190
|
|
// MPropertyFriendlyName "only restart children"
|
|
// MDefaultString
|
|
bool m_bOnlyChildren; // 0x194
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 544
|
|
class C_INIT_CreateOnModelAtHeight : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "use bones instead of hitboxes"
|
|
// MDefaultString
|
|
bool m_bUseBones; // 0x180
|
|
// MPropertyFriendlyName "force creation height to desired height"
|
|
// MDefaultString
|
|
bool m_bForceZ; // 0x181
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x184
|
|
// MPropertyFriendlyName "height override control point number"
|
|
// MDefaultString
|
|
int32_t m_nHeightCP; // 0x188
|
|
// MPropertyFriendlyName "desired height is relative to water"
|
|
// MDefaultString
|
|
bool m_bUseWaterHeight; // 0x18c
|
|
// MPropertyFriendlyName "relative desired height"
|
|
// MDefaultString
|
|
float m_flDesiredHeight; // 0x190
|
|
// MPropertyFriendlyName "model hitbox scale"
|
|
// MDefaultString
|
|
float m_flHitBoxScale; // 0x194
|
|
// MPropertyFriendlyName "hitbox set"
|
|
// MDefaultString
|
|
char[128] m_HitboxSetName; // 0x198
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_VelocityMatchingForce : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "direction matching strength"
|
|
// MDefaultString
|
|
float m_flDirScale; // 0x180
|
|
// MPropertyFriendlyName "speed matching strength"
|
|
// MDefaultString
|
|
float m_flSpdScale; // 0x184
|
|
// MPropertyFriendlyName "control point to broadcast speed and direction to"
|
|
// MDefaultString
|
|
int32_t m_nCPBroadcast; // 0x188
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_OP_RampCPLinearRandom : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "ramp rate min"
|
|
// MDefaultString
|
|
Vector m_vecRateMin; // 0x184
|
|
// MPropertyFriendlyName "ramp rate max"
|
|
// MDefaultString
|
|
Vector m_vecRateMax; // 0x190
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 1792
|
|
class C_INIT_CreateOnGrid : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "X Dimension Count"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nXCount; // 0x180
|
|
// MPropertyFriendlyName "Y Dimension Count"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nYCount; // 0x268
|
|
// MPropertyFriendlyName "Z Dimension Count"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nZCount; // 0x350
|
|
// MPropertyFriendlyName "X Dimension Spacing"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nXSpacing; // 0x438
|
|
// MPropertyFriendlyName "Y Dimension Spacing"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nYSpacing; // 0x520
|
|
// MPropertyFriendlyName "Z Dimension Spacing"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nZSpacing; // 0x608
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x6f0
|
|
// MPropertyFriendlyName "use local space"
|
|
// MDefaultString
|
|
bool m_bLocalSpace; // 0x6f4
|
|
// MPropertyFriendlyName "center around control point"
|
|
// MDefaultString
|
|
bool m_bCenter; // 0x6f5
|
|
// MPropertyFriendlyName "hollow"
|
|
// MDefaultString
|
|
bool m_bHollow; // 0x6f6
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 480
|
|
class C_OP_RenderPoints : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "material"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "AssetBrowse( vmat )"
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_hMaterial; // 0x1d0
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 6544
|
|
class C_OP_RenderFogSprites : public C_OP_RenderSprites, CBaseRendererSource2, CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "material"
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_hMaterial; // 0x1980
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 624
|
|
class C_OP_DecayClampCount : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Maximum Count"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nCount; // 0x180
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 512
|
|
class C_OP_RenderLights : public C_OP_RenderPoints, CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "animation rate"
|
|
// MDefaultString
|
|
float m_flAnimationRate; // 0x1e0
|
|
// MPropertyFriendlyName "animation type"
|
|
// MDefaultString
|
|
AnimationType_t m_nAnimationType; // 0x1e4
|
|
// MPropertyFriendlyName "set animation value in FPS"
|
|
// MDefaultString
|
|
bool m_bAnimateInFPS; // 0x1e8
|
|
// MPropertyFriendlyName "minimum visual size"
|
|
// MDefaultString
|
|
float m_flMinSize; // 0x1ec
|
|
// MPropertyFriendlyName "maximum visual size"
|
|
// MDefaultString
|
|
float m_flMaxSize; // 0x1f0
|
|
// MPropertyFriendlyName "size at which to start fading"
|
|
// MDefaultString
|
|
float m_flStartFadeSize; // 0x1f4
|
|
// MPropertyFriendlyName "size at which to fade away"
|
|
// MDefaultString
|
|
float m_flEndFadeSize; // 0x1f8
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 448
|
|
class C_OP_ColorInterpolateRandom : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "color fade min"
|
|
// MDefaultString
|
|
Color m_ColorFadeMin; // 0x180
|
|
// MPropertyFriendlyName "color fade max"
|
|
// MDefaultString
|
|
Color m_ColorFadeMax; // 0x19c
|
|
// MPropertyFriendlyName "fade start time"
|
|
// MDefaultString
|
|
float m_flFadeStartTime; // 0x1ac
|
|
// MPropertyFriendlyName "fade end time"
|
|
// MDefaultString
|
|
float m_flFadeEndTime; // 0x1b0
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x1b4
|
|
// MPropertyFriendlyName "ease in and out"
|
|
// MDefaultString
|
|
bool m_bEaseInOut; // 0x1b8
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 656
|
|
class C_OP_SetControlPointsToModelParticles : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "hitbox set"
|
|
// MDefaultString
|
|
char[128] m_HitboxSetName; // 0x180
|
|
// MPropertyFriendlyName "attachment to follow"
|
|
// MDefaultString
|
|
char[128] m_AttachmentName; // 0x200
|
|
// MPropertyFriendlyName "First control point to set"
|
|
// MDefaultString
|
|
int32_t m_nFirstControlPoint; // 0x280
|
|
// MPropertyFriendlyName "# of control points to set"
|
|
// MDefaultString
|
|
int32_t m_nNumControlPoints; // 0x284
|
|
// MPropertyFriendlyName "first particle to copy"
|
|
// MDefaultString
|
|
int32_t m_nFirstSourcePoint; // 0x288
|
|
// MPropertyFriendlyName "use skinning instead of hitboxes"
|
|
// MDefaultString
|
|
bool m_bSkin; // 0x28c
|
|
// MPropertyFriendlyName "follow attachment"
|
|
// MDefaultString
|
|
bool m_bAttachment; // 0x28d
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 416
|
|
class C_OP_DistanceCull : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint; // 0x180
|
|
// MPropertyFriendlyName "control point offset"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecPointOffset; // 0x184
|
|
// MPropertyFriendlyName "cull distance"
|
|
// MDefaultString
|
|
float m_flDistance; // 0x190
|
|
// MPropertyFriendlyName "cull inside instead of outside"
|
|
// MDefaultString
|
|
bool m_bCullInside; // 0x194
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 480
|
|
class C_OP_ConstrainDistanceToPath : public CParticleFunctionConstraint, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "minimum distance"
|
|
// MDefaultString
|
|
float m_fMinDistance; // 0x180
|
|
// MPropertyFriendlyName "maximum distance"
|
|
// MDefaultString
|
|
float m_flMaxDistance0; // 0x184
|
|
// MPropertyFriendlyName "maximum distance middle"
|
|
// MDefaultString
|
|
float m_flMaxDistanceMid; // 0x188
|
|
// MPropertyFriendlyName "maximum distance end"
|
|
// MDefaultString
|
|
float m_flMaxDistance1; // 0x18c
|
|
CPathParameters m_PathParameters; // 0x190
|
|
// MPropertyFriendlyName "travel time"
|
|
// MDefaultString
|
|
float m_flTravelTime; // 0x1d0
|
|
// MPropertyFriendlyName "travel time scale field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldScale; // 0x1d4
|
|
// MPropertyFriendlyName "manual time placement field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nManualTField; // 0x1d8
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 416
|
|
class C_OP_SetControlPointToHand : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP1; // 0x180
|
|
// MPropertyFriendlyName "hand"
|
|
// MDefaultString
|
|
int32_t m_nHand; // 0x184
|
|
// MPropertyFriendlyName "control point offset"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecCP1Pos; // 0x188
|
|
// MPropertyFriendlyName "use hand orientation"
|
|
// MDefaultString
|
|
bool m_bOrientToHand; // 0x194
|
|
};
|
|
|
|
// Aligment: 12
|
|
// Size: 560
|
|
class C_OP_DistanceBetweenCPsToCP : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "starting control point"
|
|
// MDefaultString
|
|
int32_t m_nStartCP; // 0x180
|
|
// MPropertyFriendlyName "ending control point"
|
|
// MDefaultString
|
|
int32_t m_nEndCP; // 0x184
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutputCP; // 0x188
|
|
// MPropertyFriendlyName "output control point field"
|
|
// MDefaultString
|
|
int32_t m_nOutputCPField; // 0x18c
|
|
// MPropertyFriendlyName "distance minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x190
|
|
// MPropertyFriendlyName "distance maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x194
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x198
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x19c
|
|
// MPropertyFriendlyName "maximum trace length"
|
|
// MDefaultString
|
|
float m_flMaxTraceLength; // 0x1a0
|
|
// MPropertyFriendlyName "LOS Failure Scale"
|
|
// MDefaultString
|
|
float m_flLOSScale; // 0x1a4
|
|
// MPropertyFriendlyName "ensure line of sight"
|
|
// MDefaultString
|
|
bool m_bLOS; // 0x1a8
|
|
// MPropertyFriendlyName "LOS collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x1a9
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 880
|
|
class C_OP_SetFromCPSnapshot : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "snapshot control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "field to read"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nAttributeToRead; // 0x184
|
|
// MPropertyFriendlyName "field to write"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nAttributeToWrite; // 0x188
|
|
// MPropertyFriendlyName "local space control point number"
|
|
// MDefaultString
|
|
int32_t m_nLocalSpaceCP; // 0x18c
|
|
// MPropertyFriendlyName "random order"
|
|
// MDefaultString
|
|
bool m_bRandom; // 0x190
|
|
// MPropertyFriendlyName "reverse order"
|
|
// MDefaultString
|
|
bool m_bReverse; // 0x191
|
|
// MPropertyFriendlyName "random seed"
|
|
// MDefaultString
|
|
int32_t m_nRandomSeed; // 0x194
|
|
// MPropertyFriendlyName "Snapshot start point"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nSnapShotStartPoint; // 0x198
|
|
// MPropertyFriendlyName "Interpolation"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInterpolation; // 0x280
|
|
// MPropertyFriendlyName "Sub-Sample Between Input Points"
|
|
// MDefaultString
|
|
bool m_bSubSample; // 0x368
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_RemapVectortoCP : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x184
|
|
// MPropertyFriendlyName "particle number to read"
|
|
// MDefaultString
|
|
int32_t m_nParticleNumber; // 0x188
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 432
|
|
class C_OP_RemapDistanceToLineSegmentToScalar : public C_OP_RemapDistanceToLineSegmentBase, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x1a0
|
|
// MPropertyFriendlyName "output value at min distance"
|
|
// MDefaultString
|
|
float m_flMinOutputValue; // 0x1a4
|
|
// MPropertyFriendlyName "output value at max distance"
|
|
// MDefaultString
|
|
float m_flMaxOutputValue; // 0x1a8
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 896
|
|
class C_OP_SetFloat : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "value"
|
|
CPerParticleFloatInput m_InputValue; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nOutputField; // 0x268
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x26c
|
|
// MPropertyFriendlyName "interpolation"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_Lerp; // 0x270
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 528
|
|
class C_OP_ModelCull : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "use only bounding box"
|
|
// MDefaultString
|
|
bool m_bBoundBox; // 0x184
|
|
// MPropertyFriendlyName "cull outside instead of inside"
|
|
// MDefaultString
|
|
bool m_bCullOutside; // 0x185
|
|
// MPropertyFriendlyName "use bones instead of hitboxes"
|
|
// MDefaultString
|
|
bool m_bUseBones; // 0x186
|
|
// MPropertyFriendlyName "hitbox set"
|
|
// MDefaultString
|
|
char[128] m_HitboxSetName; // 0x187
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 1472
|
|
class C_OP_LocalAccelerationForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "local space control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "scale control point"
|
|
// MDefaultString
|
|
int32_t m_nScaleCP; // 0x184
|
|
// MPropertyFriendlyName "local space acceleration"
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecAccel; // 0x188
|
|
};
|
|
|
|
// Aligment: 15
|
|
// Size: 88
|
|
struct ParticlePreviewState_t
|
|
{
|
|
public:
|
|
CUtlString m_previewModel; // 0x0
|
|
uint32_t m_nModSpecificData; // 0x8
|
|
// MDefaultString
|
|
PetGroundType_t m_groundType; // 0xc
|
|
CUtlString m_sequenceName; // 0x10
|
|
int32_t m_nFireParticleOnSequenceFrame; // 0x18
|
|
CUtlString m_hitboxSetName; // 0x20
|
|
CUtlString m_materialGroupName; // 0x28
|
|
CUtlVector< ParticlePreviewBodyGroup_t > m_vecBodyGroups; // 0x30
|
|
// MDefaultString
|
|
float m_flPlaybackSpeed; // 0x48
|
|
// MDefaultString
|
|
float m_flParticleSimulationRate; // 0x4c
|
|
bool m_bShouldDrawHitboxes; // 0x50
|
|
bool m_bShouldDrawAttachments; // 0x51
|
|
bool m_bShouldDrawAttachmentNames; // 0x52
|
|
bool m_bShouldDrawControlPointAxes; // 0x53
|
|
bool m_bAnimationNonLooping; // 0x54
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 416
|
|
class C_OP_RemapParticleCountOnScalarEndCap : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
int32_t m_nInputMin; // 0x184
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
int32_t m_nInputMax; // 0x188
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x18c
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x190
|
|
// MPropertyFriendlyName "count back from last particle"
|
|
// MDefaultString
|
|
bool m_bBackwards; // 0x194
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x198
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 416
|
|
class C_OP_RandomForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "min force"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_MinForce; // 0x180
|
|
// MPropertyFriendlyName "max force"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_MaxForce; // 0x18c
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 528
|
|
class C_OP_RenderStatusEffect : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "color warp texture (3d)"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex, *showassetpreview )"
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_pTextureColorWarp; // 0x1d0
|
|
// MPropertyFriendlyName "detail 2 texture"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex, *showassetpreview )"
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_pTextureDetail2; // 0x1d8
|
|
// MPropertyFriendlyName "diffuse warp texture (3d)"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex, *showassetpreview )"
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_pTextureDiffuseWarp; // 0x1e0
|
|
// MPropertyFriendlyName "fresnel color warp texture (3d)"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex, *showassetpreview )"
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_pTextureFresnelColorWarp; // 0x1e8
|
|
// MPropertyFriendlyName "fresnel warp texture"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex, *showassetpreview )"
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_pTextureFresnelWarp; // 0x1f0
|
|
// MPropertyFriendlyName "specular warp texture"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex, *showassetpreview )"
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_pTextureSpecularWarp; // 0x1f8
|
|
// MPropertyFriendlyName "environment map texture"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex, *showassetpreview )"
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_pTextureEnvMap; // 0x200
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_INIT_RemapInitialVisibilityScalar : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "visibility minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x188
|
|
// MPropertyFriendlyName "visibility maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x18c
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x190
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x194
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 448
|
|
class C_OP_RampScalarSplineSimple : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "ramp rate"
|
|
// MDefaultString
|
|
float m_Rate; // 0x180
|
|
// MPropertyFriendlyName "start time"
|
|
// MDefaultString
|
|
float m_flStartTime; // 0x184
|
|
// MPropertyFriendlyName "end time"
|
|
// MDefaultString
|
|
float m_flEndTime; // 0x188
|
|
// MPropertyFriendlyName "ramp field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nField; // 0x1b0
|
|
// MPropertyFriendlyName "ease out"
|
|
// MDefaultString
|
|
bool m_bEaseOut; // 0x1b4
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 464
|
|
class C_OP_FadeOut : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "fade out time min"
|
|
// MDefaultString
|
|
float m_flFadeOutTimeMin; // 0x180
|
|
// MPropertyFriendlyName "fade out time max"
|
|
// MDefaultString
|
|
float m_flFadeOutTimeMax; // 0x184
|
|
// MPropertyFriendlyName "fade out time exponent"
|
|
// MDefaultString
|
|
float m_flFadeOutTimeExp; // 0x188
|
|
// MPropertyFriendlyName "fade bias"
|
|
// MDefaultString
|
|
float m_flFadeBias; // 0x18c
|
|
// MPropertyFriendlyName "proportional 0/1"
|
|
// MDefaultString
|
|
bool m_bProportional; // 0x1c0
|
|
// MPropertyFriendlyName "ease in and out"
|
|
// MDefaultString
|
|
bool m_bEaseInAndOut; // 0x1c1
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 432
|
|
class C_OP_OscillateScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "oscillation rate min"
|
|
// MDefaultString
|
|
float m_RateMin; // 0x180
|
|
// MPropertyFriendlyName "oscillation rate max"
|
|
// MDefaultString
|
|
float m_RateMax; // 0x184
|
|
// MPropertyFriendlyName "oscillation frequency min"
|
|
// MDefaultString
|
|
float m_FrequencyMin; // 0x188
|
|
// MPropertyFriendlyName "oscillation frequency max"
|
|
// MDefaultString
|
|
float m_FrequencyMax; // 0x18c
|
|
// MPropertyFriendlyName "oscillation field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nField; // 0x190
|
|
// MPropertyFriendlyName "proportional 0/1"
|
|
// MDefaultString
|
|
bool m_bProportional; // 0x194
|
|
// MPropertyFriendlyName "start/end proportional"
|
|
// MDefaultString
|
|
bool m_bProportionalOp; // 0x195
|
|
// MPropertyFriendlyName "start time min"
|
|
// MDefaultString
|
|
float m_flStartTime_min; // 0x198
|
|
// MPropertyFriendlyName "start time max"
|
|
// MDefaultString
|
|
float m_flStartTime_max; // 0x19c
|
|
// MPropertyFriendlyName "end time min"
|
|
// MDefaultString
|
|
float m_flEndTime_min; // 0x1a0
|
|
// MPropertyFriendlyName "end time max"
|
|
// MDefaultString
|
|
float m_flEndTime_max; // 0x1a4
|
|
// MPropertyFriendlyName "oscillation multiplier"
|
|
// MDefaultString
|
|
float m_flOscMult; // 0x1a8
|
|
// MPropertyFriendlyName "oscillation start phase"
|
|
// MDefaultString
|
|
float m_flOscAdd; // 0x1ac
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 496
|
|
class C_OP_RenderBlobs : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "cube width"
|
|
// MDefaultString
|
|
float m_cubeWidth; // 0x1d0
|
|
// MPropertyFriendlyName "cutoff radius"
|
|
// MDefaultString
|
|
float m_cutoffRadius; // 0x1d4
|
|
// MPropertyFriendlyName "render radius"
|
|
// MDefaultString
|
|
float m_renderRadius; // 0x1d8
|
|
// MPropertyFriendlyName "scale CP (cube width/cutoff/render = x/y/z)"
|
|
// MDefaultString
|
|
int32_t m_nScaleCP; // 0x1dc
|
|
// MPropertyFriendlyName "material"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "AssetBrowse( vmat )"
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_hMaterial; // 0x1e0
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1072
|
|
class CParticleCollectionVecInput : public CParticleVecInput
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 22
|
|
// Size: 1520
|
|
class C_OP_WorldTraceConstraint : public CParticleFunctionConstraint, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point for fast collision tests"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "control point offset for fast collisions"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecCpOffset; // 0x184
|
|
// MPropertyFriendlyName "collision mode"
|
|
// MDefaultString
|
|
ParticleCollisionMode_t m_nCollisionMode; // 0x190
|
|
// MPropertyFriendlyName "minimum detail collision mode"
|
|
// MDefaultString
|
|
ParticleCollisionMode_t m_nCollisionModeMin; // 0x194
|
|
// MPropertyFriendlyName "amount of bounce"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flBounceAmount; // 0x198
|
|
// MPropertyFriendlyName "amount of slide"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flSlideAmount; // 0x280
|
|
// MPropertyFriendlyName "radius scale"
|
|
// MDefaultString
|
|
float m_flRadiusScale; // 0x368
|
|
// MPropertyFriendlyName "Random Direction scale"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flRandomDirScale; // 0x370
|
|
// MPropertyFriendlyName "control point movement distance tolerance"
|
|
// MDefaultString
|
|
float m_flCpMovementTolerance; // 0x458
|
|
// MPropertyFriendlyName "trace accuracy tolerance"
|
|
// MDefaultString
|
|
float m_flTraceTolerance; // 0x45c
|
|
// MPropertyFriendlyName "minimum speed to kill on collision"
|
|
// MDefaultString
|
|
float m_flMinSpeed; // 0x460
|
|
// MPropertyFriendlyName "Add Decay to Bounce"
|
|
// MDefaultString
|
|
bool m_bDecayBounce; // 0x464
|
|
// MPropertyFriendlyName "kill particle on collision"
|
|
// MDefaultString
|
|
bool m_bKillonContact; // 0x465
|
|
// MPropertyFriendlyName "Confirm Collision Speed Threshold"
|
|
// MDefaultString
|
|
float m_flCollisionConfirmationSpeed; // 0x468
|
|
// MPropertyFriendlyName "Set Normal"
|
|
// MDefaultString
|
|
bool m_bSetNormal; // 0x46c
|
|
// MPropertyFriendlyName "Stick On Collision Cache Field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nStickOnCollisionField; // 0x470
|
|
// MPropertyFriendlyName "Speed to stop when sticking"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flStopSpeed; // 0x478
|
|
// MPropertyFriendlyName "Entity Hitbox Cache Field (Requires Stick on Collision)"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nEntityStickDataField; // 0x560
|
|
// MPropertyFriendlyName "World Only"
|
|
// MDefaultString
|
|
bool m_bWorldOnly; // 0x564
|
|
// MPropertyFriendlyName "CP Entity to Ignore for Collisions"
|
|
// MDefaultString
|
|
int32_t m_nIgnoreCP; // 0x568
|
|
// MPropertyFriendlyName "collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x56c
|
|
// MPropertyFriendlyName "brush only"
|
|
// MDefaultString
|
|
bool m_bBrushOnly; // 0x5ec
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 784
|
|
class C_INIT_PositionPlaceOnGround : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "offset"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flOffset; // 0x180
|
|
// MPropertyFriendlyName "max trace length"
|
|
// MDefaultString
|
|
float m_flMaxTraceLength; // 0x268
|
|
// MPropertyFriendlyName "collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x26c
|
|
// MPropertyFriendlyName "kill on no collision"
|
|
// MDefaultString
|
|
bool m_bKill; // 0x2f0
|
|
// MPropertyFriendlyName "include water"
|
|
// MDefaultString
|
|
bool m_bIncludeWater; // 0x2f1
|
|
// MPropertyFriendlyName "set normal"
|
|
// MDefaultString
|
|
bool m_bSetNormal; // 0x2f2
|
|
// MPropertyFriendlyName "set Previous XYZ only"
|
|
// MDefaultString
|
|
bool m_bSetPXYZOnly; // 0x2f3
|
|
// MPropertyFriendlyName "Trace along particle normal"
|
|
// MDefaultString
|
|
bool m_bTraceAlongNormal; // 0x2f4
|
|
// MPropertyFriendlyName "offset final position by this fraction of the particle radius"
|
|
// MDefaultString
|
|
float m_flOffsetByRadiusFactor; // 0x2f8
|
|
// MPropertyFriendlyName "preserve initial Z-offset relative to cp"
|
|
// MDefaultString
|
|
int32_t m_nPreserveOffsetCP; // 0x2fc
|
|
// MPropertyFriendlyName "CP Entity to Ignore for Collisions"
|
|
// MDefaultString
|
|
int32_t m_nIgnoreCP; // 0x300
|
|
};
|
|
|
|
// Aligment: 33
|
|
// Size: 1584
|
|
class C_OP_ControlpointLight : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "initial color bias"
|
|
// MDefaultString
|
|
float m_flScale; // 0x180
|
|
// MPropertyFriendlyName "light 1 control point"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint1; // 0x5a8
|
|
// MPropertyFriendlyName "light 2 control point"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint2; // 0x5ac
|
|
// MPropertyFriendlyName "light 3 control point"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint3; // 0x5b0
|
|
// MPropertyFriendlyName "light 4 control point"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint4; // 0x5b4
|
|
// MPropertyFriendlyName "light 1 control point offset"
|
|
// MDefaultString
|
|
Vector m_vecCPOffset1; // 0x5b8
|
|
// MPropertyFriendlyName "light 2 control point offset"
|
|
// MDefaultString
|
|
Vector m_vecCPOffset2; // 0x5c4
|
|
// MPropertyFriendlyName "light 3 control point offset"
|
|
// MDefaultString
|
|
Vector m_vecCPOffset3; // 0x5d0
|
|
// MPropertyFriendlyName "light 4 control point offset"
|
|
// MDefaultString
|
|
Vector m_vecCPOffset4; // 0x5dc
|
|
// MPropertyFriendlyName "light 1 50% distance"
|
|
// MDefaultString
|
|
float m_LightFiftyDist1; // 0x5e8
|
|
// MPropertyFriendlyName "light 1 0% distance"
|
|
// MDefaultString
|
|
float m_LightZeroDist1; // 0x5ec
|
|
// MPropertyFriendlyName "light 2 50% distance"
|
|
// MDefaultString
|
|
float m_LightFiftyDist2; // 0x5f0
|
|
// MPropertyFriendlyName "light 2 0% distance"
|
|
// MDefaultString
|
|
float m_LightZeroDist2; // 0x5f4
|
|
// MPropertyFriendlyName "light 3 50% distance"
|
|
// MDefaultString
|
|
float m_LightFiftyDist3; // 0x5f8
|
|
// MPropertyFriendlyName "light 3 0% distance"
|
|
// MDefaultString
|
|
float m_LightZeroDist3; // 0x5fc
|
|
// MPropertyFriendlyName "light 4 50% distance"
|
|
// MDefaultString
|
|
float m_LightFiftyDist4; // 0x600
|
|
// MPropertyFriendlyName "light 4 0% distance"
|
|
// MDefaultString
|
|
float m_LightZeroDist4; // 0x604
|
|
// MPropertyFriendlyName "light 1 color"
|
|
// MDefaultString
|
|
Color m_LightColor1; // 0x608
|
|
// MPropertyFriendlyName "light 2 color"
|
|
// MDefaultString
|
|
Color m_LightColor2; // 0x60c
|
|
// MPropertyFriendlyName "light 3 color"
|
|
// MDefaultString
|
|
Color m_LightColor3; // 0x610
|
|
// MPropertyFriendlyName "light 4 color"
|
|
// MDefaultString
|
|
Color m_LightColor4; // 0x614
|
|
// MPropertyFriendlyName "light 1 type 0=point 1=spot"
|
|
// MDefaultString
|
|
bool m_bLightType1; // 0x618
|
|
// MPropertyFriendlyName "light 2 type 0=point 1=spot"
|
|
// MDefaultString
|
|
bool m_bLightType2; // 0x619
|
|
// MPropertyFriendlyName "light 3 type 0=point 1=spot"
|
|
// MDefaultString
|
|
bool m_bLightType3; // 0x61a
|
|
// MPropertyFriendlyName "light 4 type 0=point 1=spot"
|
|
// MDefaultString
|
|
bool m_bLightType4; // 0x61b
|
|
// MPropertyFriendlyName "light 1 dynamic light"
|
|
// MDefaultString
|
|
bool m_bLightDynamic1; // 0x61c
|
|
// MPropertyFriendlyName "light 2 dynamic light"
|
|
// MDefaultString
|
|
bool m_bLightDynamic2; // 0x61d
|
|
// MPropertyFriendlyName "light 3 dynamic light"
|
|
// MDefaultString
|
|
bool m_bLightDynamic3; // 0x61e
|
|
// MPropertyFriendlyName "light 4 dynamic light"
|
|
// MDefaultString
|
|
bool m_bLightDynamic4; // 0x61f
|
|
// MPropertyFriendlyName "compute normals from control points"
|
|
// MDefaultString
|
|
bool m_bUseNormal; // 0x620
|
|
// MPropertyFriendlyName "half-lambert normals"
|
|
// MDefaultString
|
|
bool m_bUseHLambert; // 0x621
|
|
// MPropertyFriendlyName "clamp minimum light value to initial color"
|
|
// MDefaultString
|
|
bool m_bClampLowerRange; // 0x626
|
|
// MPropertyFriendlyName "clamp maximum light value to initial color"
|
|
// MDefaultString
|
|
bool m_bClampUpperRange; // 0x627
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 624
|
|
class C_OP_ChooseRandomChildrenInGroup : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "group ID to affect"
|
|
// MDefaultString
|
|
int32_t m_nChildGroupID; // 0x180
|
|
// MPropertyFriendlyName "Number of Children to Use"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flNumberOfChildren; // 0x188
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 432
|
|
class C_INIT_CreateWithinBox : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "min"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecMin; // 0x180
|
|
// MPropertyFriendlyName "max"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecMax; // 0x18c
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x198
|
|
// MPropertyFriendlyName "use local space"
|
|
// MDefaultString
|
|
bool m_bLocalSpace; // 0x19c
|
|
// MPropertyFriendlyName "scale CP (.x= distance)"
|
|
// MDefaultString
|
|
int32_t m_nScaleCP; // 0x1a0
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_OP_UpdateLightSource : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "color tint"
|
|
// MDefaultString
|
|
Color m_vColorTint; // 0x180
|
|
// MPropertyFriendlyName "amount to multiply light brightness by"
|
|
// MDefaultString
|
|
float m_flBrightnessScale; // 0x184
|
|
// MPropertyFriendlyName "amount to multiply particle system radius by to get light radius"
|
|
// MDefaultString
|
|
float m_flRadiusScale; // 0x188
|
|
// MPropertyFriendlyName "minimum radius for created lights"
|
|
// MDefaultString
|
|
float m_flMinimumLightingRadius; // 0x18c
|
|
// MPropertyFriendlyName "maximum radius for created lights"
|
|
// MDefaultString
|
|
float m_flMaximumLightingRadius; // 0x190
|
|
// MPropertyFriendlyName "amount of damping of changes"
|
|
// MDefaultString
|
|
float m_flPositionDampingConstant; // 0x194
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 480
|
|
class C_OP_RenderScreenVelocityRotate : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "rotate rate(dps)"
|
|
// MDefaultString
|
|
float m_flRotateRateDegrees; // 0x1d0
|
|
// MPropertyFriendlyName "forward angle"
|
|
// MDefaultString
|
|
float m_flForwardDegrees; // 0x1d4
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 480
|
|
class C_OP_RemapNamedModelMeshGroupEndCap : public C_OP_RemapNamedModelElementEndCap, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 59
|
|
// Size: 848
|
|
class CParticleSystemDefinition : public IParticleSystemDefinition
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "version"
|
|
// MDefaultString
|
|
// MPropertySuppressField
|
|
int32_t m_nBehaviorVersion; // 0x8
|
|
// MPropertySuppressField
|
|
CUtlVector< CParticleFunctionPreEmission* > m_PreEmissionOperators; // 0x10
|
|
// MPropertySuppressField
|
|
CUtlVector< CParticleFunctionEmitter* > m_Emitters; // 0x28
|
|
// MPropertySuppressField
|
|
CUtlVector< CParticleFunctionInitializer* > m_Initializers; // 0x40
|
|
// MPropertySuppressField
|
|
CUtlVector< CParticleFunctionOperator* > m_Operators; // 0x58
|
|
// MPropertySuppressField
|
|
CUtlVector< CParticleFunctionForce* > m_ForceGenerators; // 0x70
|
|
// MPropertySuppressField
|
|
CUtlVector< CParticleFunctionConstraint* > m_Constraints; // 0x88
|
|
// MPropertySuppressField
|
|
CUtlVector< CParticleFunctionRenderer* > m_Renderers; // 0xa0
|
|
// MPropertySuppressField
|
|
CUtlVector< ParticleChildrenInfo_t > m_Children; // 0xb8
|
|
// MPropertySuppressField
|
|
// MDefaultString
|
|
int32_t m_nFirstMultipleOverride_BackwardCompat; // 0x178
|
|
// MPropertyFriendlyName "initial particles"
|
|
// MDefaultString
|
|
int32_t m_nInitialParticles; // 0x17c
|
|
// MPropertyFriendlyName "max particles"
|
|
// MDefaultString
|
|
int32_t m_nMaxParticles; // 0x180
|
|
// MPropertyFriendlyName "bounding box min"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_BoundingBoxMin; // 0x1c0
|
|
// MPropertyFriendlyName "bounding box max"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_BoundingBoxMax; // 0x1cc
|
|
// MPropertyFriendlyName "snapshot control point"
|
|
// MDefaultString
|
|
int32_t m_nSnapshotControlPoint; // 0x1d8
|
|
// MPropertyFriendlyName "snapshot"
|
|
// MPropertyAttributeEditor "AssetBrowse( vsnap )"
|
|
CStrongHandle< InfoForResourceTypeIParticleSnapshot > m_hSnapshot; // 0x1e0
|
|
// MPropertyFriendlyName "target layer ID for rendering"
|
|
// MDefaultString
|
|
CUtlSymbolLarge m_pszTargetLayerID; // 0x1e8
|
|
// MPropertyFriendlyName "Topology"
|
|
// MDefaultString
|
|
ParticleTopology_t m_nTopology; // 0x1f0
|
|
// MPropertyFriendlyName "reference replacement definition"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "AssetBrowse( vpcf )"
|
|
// MParticleAdvancedField
|
|
CStrongHandle< InfoForResourceTypeIParticleSystemDefinition > m_hReferenceReplacement; // 0x210
|
|
// MPropertyFriendlyName "cull replacement definition"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "AssetBrowse( vpcf )"
|
|
// MParticleAdvancedField
|
|
CStrongHandle< InfoForResourceTypeIParticleSystemDefinition > m_pszCullReplacementName; // 0x218
|
|
// MPropertyFriendlyName "cull radius"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flCullRadius; // 0x220
|
|
// MPropertyFriendlyName "cull cost"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flCullFillCost; // 0x224
|
|
// MPropertyFriendlyName "cull control point"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
int32_t m_nCullControlPoint; // 0x228
|
|
// MPropertyFriendlyName "fallback replacement definition"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "AssetBrowse( vpcf )"
|
|
// MParticleAdvancedField
|
|
CStrongHandle< InfoForResourceTypeIParticleSystemDefinition > m_hFallback; // 0x238
|
|
// MPropertyFriendlyName "fallback max count"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
int32_t m_nFallbackMaxCount; // 0x240
|
|
// MPropertyFriendlyName "low violence definition"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "AssetBrowse( vpcf )"
|
|
// MParticleAdvancedField
|
|
CStrongHandle< InfoForResourceTypeIParticleSystemDefinition > m_hLowViolenceDef; // 0x248
|
|
// MPropertyFriendlyName "color"
|
|
// MDefaultString
|
|
Color m_ConstantColor; // 0x250
|
|
// MPropertyFriendlyName "normal"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_ConstantNormal; // 0x254
|
|
// MPropertyFriendlyName "radius"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "biased 0 500"
|
|
float m_flConstantRadius; // 0x260
|
|
// MPropertyFriendlyName "rotation"
|
|
// MDefaultString
|
|
float m_flConstantRotation; // 0x264
|
|
// MPropertyFriendlyName "rotation speed"
|
|
// MDefaultString
|
|
float m_flConstantRotationSpeed; // 0x268
|
|
// MPropertyFriendlyName "lifetime"
|
|
// MDefaultString
|
|
float m_flConstantLifespan; // 0x26c
|
|
// MPropertyFriendlyName "sequence number"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "SequencePicker( 1 )"
|
|
int32_t m_nConstantSequenceNumber; // 0x270
|
|
// MPropertyFriendlyName "sequence number 1"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "SequencePicker( 2 )"
|
|
int32_t m_nConstantSequenceNumber1; // 0x274
|
|
// MPropertyFriendlyName "group id"
|
|
// MDefaultString
|
|
int32_t m_nGroupID; // 0x278
|
|
// MPropertyFriendlyName "maximum time step"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flMaximumTimeStep; // 0x27c
|
|
// MPropertyFriendlyName "maximum sim tick rate"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flMaximumSimTime; // 0x280
|
|
// MPropertyFriendlyName "minimum sim tick rate"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flMinimumSimTime; // 0x284
|
|
// MPropertyFriendlyName "minimum simulation time step"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flMinimumTimeStep; // 0x288
|
|
// MPropertyFriendlyName "minimum rendered frames"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
int32_t m_nMinimumFrames; // 0x28c
|
|
// MPropertyFriendlyName "minimum CPU level"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
int32_t m_nMinCPULevel; // 0x290
|
|
// MPropertyFriendlyName "minimum GPU level"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
int32_t m_nMinGPULevel; // 0x294
|
|
// MPropertyFriendlyName "view model effect"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
bool m_bViewModelEffect; // 0x298
|
|
// MPropertyFriendlyName "screen space effect"
|
|
// MDefaultString
|
|
bool m_bScreenSpaceEffect; // 0x299
|
|
CUtlVector< ParticleControlPointConfiguration_t > m_controlPointConfigurations; // 0x2b0
|
|
// MPropertyFriendlyName "time to sleep when not drawn"
|
|
// MDefaultString
|
|
float m_flNoDrawTimeToGoToSleep; // 0x2c8
|
|
// MPropertyFriendlyName "maximum draw distance"
|
|
// MDefaultString
|
|
float m_flMaxDrawDistance; // 0x2cc
|
|
// MPropertyFriendlyName "start fade distance"
|
|
// MDefaultString
|
|
float m_flStartFadeDistance; // 0x2d0
|
|
// MPropertyFriendlyName "maximum creation distance"
|
|
// MDefaultString
|
|
float m_flMaxCreationDistance; // 0x2d4
|
|
// MPropertyFriendlyName "control point to disable rendering if it is the camera"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
int32_t m_nSkipRenderControlPoint; // 0x2d8
|
|
// MPropertyFriendlyName "control point to only enable rendering if it is the camera"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
int32_t m_nAllowRenderControlPoint; // 0x2dc
|
|
// MPropertyFriendlyName "minimum free particles to aggregate"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
int32_t m_nAggregationMinAvailableParticles; // 0x2e0
|
|
// MPropertyFriendlyName "aggregation radius"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flAggregateRadius; // 0x2e4
|
|
// MPropertyFriendlyName "freeze simulation after time"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flStopSimulationAfterTime; // 0x2e8
|
|
// MPropertyFriendlyName "sort particles (DEPRECATED - USE RENDERER OPTION)"
|
|
// MDefaultString
|
|
bool m_bShouldSort; // 0x324
|
|
// MPropertyFriendlyName "batch particle systems"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
bool m_bShouldBatch; // 0x325
|
|
// MPropertyFriendlyName "depth sort bias"
|
|
// MDefaultString
|
|
float m_flDepthSortBias; // 0x328
|
|
// MPropertyFriendlyName "infinite bounds - don't cull"
|
|
// MDefaultString
|
|
bool m_bInfiniteBounds; // 0x32c
|
|
// MPropertyFriendlyName "Hitboxes fall back to render bounds"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
bool m_bShouldHitboxesFallbackToRenderBounds; // 0x32e
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 464
|
|
class CParticleFunctionRenderer : public CParticleFunction
|
|
{
|
|
public:
|
|
// MParticleAdvancedField
|
|
CParticleVisibilityInputs VisibilityInputs; // 0x180
|
|
// MPropertyFriendlyName "I cannot be refracted through refracting objects like water"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Rendering filter"
|
|
bool m_bCannotBeRefracted; // 0x1c4
|
|
// MPropertyFriendlyName "Skip rendering on mobile"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Rendering filter"
|
|
bool m_bSkipRenderingOnMobile; // 0x1c5
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 432
|
|
class C_OP_RemapCPtoScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point number"
|
|
// MDefaultString
|
|
int32_t m_nCPInput; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "input field 0-2 X/Y/Z"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nField; // 0x188
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x18c
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x190
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x194
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x198
|
|
// MPropertyFriendlyName "emitter lifetime start time (seconds)"
|
|
// MDefaultString
|
|
float m_flStartTime; // 0x19c
|
|
// MPropertyFriendlyName "emitter lifetime end time (seconds)"
|
|
// MDefaultString
|
|
float m_flEndTime; // 0x1a0
|
|
// MPropertyFriendlyName "interpolation scale"
|
|
// MDefaultString
|
|
float m_flInterpRate; // 0x1a4
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x1a8
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_OP_SetSingleControlPointPosition : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "set positions in world space"
|
|
// MDefaultString
|
|
bool m_bUseWorldLocation; // 0x180
|
|
// MPropertyFriendlyName "only set position once"
|
|
// MDefaultString
|
|
bool m_bSetOnce; // 0x181
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP1; // 0x184
|
|
// MPropertyFriendlyName "control point location"
|
|
// MDefaultString
|
|
Vector m_vecCP1Pos; // 0x188
|
|
// MPropertyFriendlyName "control point to offset positions from"
|
|
// MDefaultString
|
|
int32_t m_nHeadLocation; // 0x194
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_SnapshotRigidSkinToBones : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "rotate normals"
|
|
// MDefaultString
|
|
bool m_bTransformNormals; // 0x180
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x184
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_SetCPtoVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point number"
|
|
// MDefaultString
|
|
int32_t m_nCPInput; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 384
|
|
class CParticleFunctionOperator : public CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_RemapControlPointDirectionToVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "scale factor"
|
|
// MDefaultString
|
|
float m_flScale; // 0x184
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x188
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 896
|
|
class C_OP_SetRandomControlPointPosition : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "set positions in world space"
|
|
// MDefaultString
|
|
bool m_bUseWorldLocation; // 0x180
|
|
// MPropertyFriendlyName "inherit CP orientation"
|
|
// MDefaultString
|
|
bool m_bOrient; // 0x181
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP1; // 0x184
|
|
// MPropertyFriendlyName "control point to offset positions from"
|
|
// MDefaultString
|
|
int32_t m_nHeadLocation; // 0x188
|
|
// MPropertyFriendlyName "re-randomize rate (-1 for once only)"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flReRandomRate; // 0x190
|
|
// MPropertyFriendlyName "control point min"
|
|
// MDefaultString
|
|
Vector m_vecCPMinPos; // 0x278
|
|
// MPropertyFriendlyName "control point max"
|
|
// MDefaultString
|
|
Vector m_vecCPMaxPos; // 0x284
|
|
// MPropertyFriendlyName "Interpolation"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flInterpolation; // 0x290
|
|
};
|
|
|
|
// Aligment: 23
|
|
// Size: 184
|
|
class CNewParticleEffect : public IParticleEffect
|
|
{
|
|
public:
|
|
CNewParticleEffect* m_pNext; // 0x10
|
|
CNewParticleEffect* m_pPrev; // 0x18
|
|
IParticleCollection* m_pParticles; // 0x20
|
|
char* m_pDebugName; // 0x28
|
|
bitfield:1 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_bDisableAggregation; // 0x0
|
|
bitfield:1 m_bShouldSimulateDuringGamePaused; // 0x0
|
|
Vector m_vSortOrigin; // 0x40
|
|
float m_flScale; // 0x4c
|
|
PARTICLE_EHANDLE__* m_hOwner; // 0x50
|
|
CParticleProperty* m_pOwningParticleProperty; // 0x58
|
|
Vector m_LastMin; // 0x70
|
|
Vector m_LastMax; // 0x7c
|
|
Vector m_vecAggregationCenter; // 0x88
|
|
int32_t m_RefCount; // 0xb0
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 624
|
|
class C_OP_EndCapTimedFreeze : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "freeze time"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flFreezeTime; // 0x180
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_OP_SetControlPointToPlayer : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP1; // 0x180
|
|
// MPropertyFriendlyName "control point offset"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecCP1Pos; // 0x184
|
|
// MPropertyFriendlyName "use eye orientation"
|
|
// MDefaultString
|
|
bool m_bOrientToEyes; // 0x190
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 480
|
|
class C_OP_RemapNamedModelElementOnceTimed : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "model"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "AssetBrowse( vmdl )"
|
|
CStrongHandle< InfoForResourceTypeCModel > m_hModel; // 0x180
|
|
// MPropertyFriendlyName "input names"
|
|
CUtlVector< CUtlString > m_inNames; // 0x188
|
|
// MPropertyFriendlyName "output names"
|
|
CUtlVector< CUtlString > m_outNames; // 0x1a0
|
|
// MPropertyFriendlyName "fallback names when the input doesn't match"
|
|
CUtlVector< CUtlString > m_fallbackNames; // 0x1b8
|
|
// MPropertyFriendlyName "model from renderer"
|
|
// MDefaultString
|
|
bool m_bModelFromRenderer; // 0x1d0
|
|
// MPropertyFriendlyName "remap time proportional"
|
|
// MDefaultString
|
|
bool m_bProportional; // 0x1d1
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x1d4
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x1d8
|
|
// MPropertyFriendlyName "remap time"
|
|
// MDefaultString
|
|
float m_flRemapTime; // 0x1dc
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 448
|
|
class C_OP_TurbulenceForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "noise scale 0"
|
|
// MDefaultString
|
|
float m_flNoiseCoordScale0; // 0x180
|
|
// MPropertyFriendlyName "noise scale 1"
|
|
// MDefaultString
|
|
float m_flNoiseCoordScale1; // 0x184
|
|
// MPropertyFriendlyName "noise scale 2"
|
|
// MDefaultString
|
|
float m_flNoiseCoordScale2; // 0x188
|
|
// MPropertyFriendlyName "noise scale 3"
|
|
// MDefaultString
|
|
float m_flNoiseCoordScale3; // 0x18c
|
|
// MPropertyFriendlyName "noise amount 0"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecNoiseAmount0; // 0x190
|
|
// MPropertyFriendlyName "noise amount 1"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecNoiseAmount1; // 0x19c
|
|
// MPropertyFriendlyName "noise amount 2"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecNoiseAmount2; // 0x1a8
|
|
// MPropertyFriendlyName "noise amount 3"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecNoiseAmount3; // 0x1b4
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_ReinitializeScalarEndCap : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x184
|
|
// MPropertyFriendlyName "maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x188
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 464
|
|
class C_OP_InterpolateRadius : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "start time"
|
|
// MDefaultString
|
|
float m_flStartTime; // 0x180
|
|
// MPropertyFriendlyName "end time"
|
|
// MDefaultString
|
|
float m_flEndTime; // 0x184
|
|
// MPropertyFriendlyName "radius start scale"
|
|
// MDefaultString
|
|
float m_flStartScale; // 0x188
|
|
// MPropertyFriendlyName "radius end scale"
|
|
// MDefaultString
|
|
float m_flEndScale; // 0x18c
|
|
// MPropertyFriendlyName "ease in and out"
|
|
// MDefaultString
|
|
bool m_bEaseInAndOut; // 0x190
|
|
// MPropertyFriendlyName "scale bias"
|
|
// MDefaultString
|
|
float m_flBias; // 0x194
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 560
|
|
class C_OP_SetControlPointToImpactPoint : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point to set"
|
|
// MDefaultString
|
|
int32_t m_nCPOut; // 0x180
|
|
// MPropertyFriendlyName "control point to trace from"
|
|
// MDefaultString
|
|
int32_t m_nCPIn; // 0x184
|
|
// MPropertyFriendlyName "trace update rate"
|
|
// MDefaultString
|
|
float m_flUpdateRate; // 0x188
|
|
// MPropertyFriendlyName "max trace length"
|
|
// MDefaultString
|
|
float m_flTraceLength; // 0x18c
|
|
// MPropertyFriendlyName "offset end point amount"
|
|
// MDefaultString
|
|
float m_flOffset; // 0x190
|
|
// MPropertyFriendlyName "trace direction override"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecTraceDir; // 0x194
|
|
// MPropertyFriendlyName "trace collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x1a0
|
|
// MPropertyFriendlyName "set to trace endpoint if no collision"
|
|
// MDefaultString
|
|
bool m_bSetToEndpoint; // 0x220
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 720
|
|
class C_OP_RenderVRHapticEvent : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "haptic hand"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceEnumName
|
|
int32_t m_nHand; // 0x1d0
|
|
// MPropertyFriendlyName "hand control point number"
|
|
// MDefaultString
|
|
int32_t m_nOutputHandCP; // 0x1d4
|
|
// MPropertyFriendlyName "cp field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nOutputField; // 0x1d8
|
|
// MPropertyFriendlyName "amplitude"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flAmplitude; // 0x1e0
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 432
|
|
class C_OP_PositionLock : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "start fadeout min"
|
|
// MDefaultString
|
|
float m_flStartTime_min; // 0x184
|
|
// MPropertyFriendlyName "start fadeout max"
|
|
// MDefaultString
|
|
float m_flStartTime_max; // 0x188
|
|
// MPropertyFriendlyName "start fadeout exponent"
|
|
// MDefaultString
|
|
float m_flStartTime_exp; // 0x18c
|
|
// MPropertyFriendlyName "end fadeout min"
|
|
// MDefaultString
|
|
float m_flEndTime_min; // 0x190
|
|
// MPropertyFriendlyName "end fadeout max"
|
|
// MDefaultString
|
|
float m_flEndTime_max; // 0x194
|
|
// MPropertyFriendlyName "end fadeout exponent"
|
|
// MDefaultString
|
|
float m_flEndTime_exp; // 0x198
|
|
// MPropertyFriendlyName "distance fade range"
|
|
// MDefaultString
|
|
float m_flRange; // 0x19c
|
|
// MPropertyFriendlyName "instant jump threshold"
|
|
// MDefaultString
|
|
float m_flJumpThreshold; // 0x1a0
|
|
// MPropertyFriendlyName "previous position scale"
|
|
// MDefaultString
|
|
float m_flPrevPosScale; // 0x1a4
|
|
// MPropertyFriendlyName "lock rotation"
|
|
// MDefaultString
|
|
bool m_bLockRot; // 0x1a8
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 464
|
|
class C_OP_OscillateVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "oscillation rate min"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_RateMin; // 0x180
|
|
// MPropertyFriendlyName "oscillation rate max"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_RateMax; // 0x18c
|
|
// MPropertyFriendlyName "oscillation frequency min"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_FrequencyMin; // 0x198
|
|
// MPropertyFriendlyName "oscillation frequency max"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_FrequencyMax; // 0x1a4
|
|
// MPropertyFriendlyName "oscillation field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nField; // 0x1b0
|
|
// MPropertyFriendlyName "proportional 0/1"
|
|
// MDefaultString
|
|
bool m_bProportional; // 0x1b4
|
|
// MPropertyFriendlyName "start/end proportional"
|
|
// MDefaultString
|
|
bool m_bProportionalOp; // 0x1b5
|
|
// MPropertyFriendlyName "offset instead of accelerate position"
|
|
// MDefaultString
|
|
bool m_bOffset; // 0x1b6
|
|
// MPropertyFriendlyName "start time min"
|
|
// MDefaultString
|
|
float m_flStartTime_min; // 0x1b8
|
|
// MPropertyFriendlyName "start time max"
|
|
// MDefaultString
|
|
float m_flStartTime_max; // 0x1bc
|
|
// MPropertyFriendlyName "end time min"
|
|
// MDefaultString
|
|
float m_flEndTime_min; // 0x1c0
|
|
// MPropertyFriendlyName "end time max"
|
|
// MDefaultString
|
|
float m_flEndTime_max; // 0x1c4
|
|
// MPropertyFriendlyName "oscillation multiplier"
|
|
// MDefaultString
|
|
float m_flOscMult; // 0x1c8
|
|
// MPropertyFriendlyName "oscillation start phase"
|
|
// MDefaultString
|
|
float m_flOscAdd; // 0x1cc
|
|
};
|
|
|
|
// Aligment: 9
|
|
// Size: 1344
|
|
class C_OP_MovementSkinnedPositionFromCPSnapshot : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "snapshot control point number"
|
|
// MDefaultString
|
|
int32_t m_nSnapshotControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x184
|
|
// MPropertyFriendlyName "random order"
|
|
// MDefaultString
|
|
bool m_bRandom; // 0x188
|
|
// MPropertyFriendlyName "random seed"
|
|
// MDefaultString
|
|
int32_t m_nRandomSeed; // 0x18c
|
|
// MPropertyFriendlyName "set normal"
|
|
// MDefaultString
|
|
bool m_bSetNormal; // 0x190
|
|
// MPropertyFriendlyName "particle increment amount"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flIncrement; // 0x198
|
|
// MPropertyFriendlyName "Full Loop Increment Amount"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nFullLoopIncrement; // 0x280
|
|
// MPropertyFriendlyName "Snapshot start point"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_nSnapShotStartPoint; // 0x368
|
|
// MPropertyFriendlyName "Interpolation"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInterpolation; // 0x450
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 656
|
|
class C_OP_SetControlPointOrientation : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "set orientation in world space"
|
|
// MDefaultString
|
|
bool m_bUseWorldLocation; // 0x180
|
|
// MPropertyFriendlyName "randomize"
|
|
// MDefaultString
|
|
bool m_bRandomize; // 0x182
|
|
// MPropertyFriendlyName "only set orientation once"
|
|
// MDefaultString
|
|
bool m_bSetOnce; // 0x183
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x184
|
|
// MPropertyFriendlyName "control point to offset orientation from"
|
|
// MDefaultString
|
|
int32_t m_nHeadLocation; // 0x188
|
|
// MPropertyFriendlyName "pitch yaw roll"
|
|
// MDefaultString
|
|
QAngle m_vecRotation; // 0x18c
|
|
// MPropertyFriendlyName "pitch yaw roll max"
|
|
// MDefaultString
|
|
QAngle m_vecRotationB; // 0x198
|
|
// MPropertyFriendlyName "interpolation"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flInterpolation; // 0x1a8
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_INIT_VelocityFromCP : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint; // 0x180
|
|
// MPropertyFriendlyName "comparison control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointCompare; // 0x184
|
|
// MPropertyFriendlyName "local space control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointLocal; // 0x188
|
|
// MPropertyFriendlyName "velocity scale"
|
|
// MDefaultString
|
|
float m_flVelocityScale; // 0x18c
|
|
// MPropertyFriendlyName "direction only"
|
|
// MDefaultString
|
|
bool m_bDirectionOnly; // 0x190
|
|
};
|
|
|
|
// Aligment: 16
|
|
// Size: 5280
|
|
class CBaseTrailRenderer : public CBaseRendererSource2, CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "orientation type"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceEnumName
|
|
int32_t m_nOrientationType; // 0xca0
|
|
// MPropertyFriendlyName "orientation control point"
|
|
// MDefaultString
|
|
int32_t m_nOrientationControlPoint; // 0xca4
|
|
// MPropertyFriendlyName "minimum visual size"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flMinSize; // 0xca8
|
|
// MPropertyFriendlyName "maximum visual size"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flMaxSize; // 0xcac
|
|
// MPropertyFriendlyName "size at which to start fading"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
CParticleCollectionFloatInput m_flStartFadeSize; // 0xcb0
|
|
// MPropertyFriendlyName "size at which to fade away"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
CParticleCollectionFloatInput m_flEndFadeSize; // 0xd98
|
|
// MPropertyFriendlyName "depth comparison bias"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Depth buffer control and effects"
|
|
float m_flDepthBias; // 0xe80
|
|
// MPropertyFriendlyName "radius scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flRadiusScale; // 0xe88
|
|
// MPropertyFriendlyName "alpha scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flAlphaScale; // 0xf70
|
|
// MPropertyFriendlyName "color blend"
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecColorScale; // 0x1058
|
|
// MPropertyFriendlyName "color blend type"
|
|
// MDefaultString
|
|
ParticleColorBlendType_t m_nColorBlendType; // 0x1488
|
|
// MPropertyFriendlyName "Clamp Non-Sheet texture V coords"
|
|
// MDefaultString
|
|
bool m_bClampV; // 0x148c
|
|
// MPropertyFriendlyName "horizontal texture scale"
|
|
// MDefaultString
|
|
float m_flFinalTextureScaleU; // 0x1490
|
|
// MPropertyFriendlyName "vertical texture scale"
|
|
// MDefaultString
|
|
float m_flFinalTextureScaleV; // 0x1494
|
|
// MPropertyFriendlyName "horizontal texture offset"
|
|
// MDefaultString
|
|
float m_flFinalTextureOffsetU; // 0x1498
|
|
// MPropertyFriendlyName "vertical texture offset"
|
|
// MDefaultString
|
|
float m_flFinalTextureOffsetV; // 0x149c
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 448
|
|
class C_OP_PercentageBetweenCPsVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "percentage minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x184
|
|
// MPropertyFriendlyName "percentage maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x188
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vecOutputMin; // 0x18c
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vecOutputMax; // 0x198
|
|
// MPropertyFriendlyName "starting control point"
|
|
// MDefaultString
|
|
int32_t m_nStartCP; // 0x1a4
|
|
// MPropertyFriendlyName "ending control point"
|
|
// MDefaultString
|
|
int32_t m_nEndCP; // 0x1a8
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x1ac
|
|
// MPropertyFriendlyName "only active within input range"
|
|
// MDefaultString
|
|
bool m_bActiveRange; // 0x1b0
|
|
// MPropertyFriendlyName "treat distance between points as radius"
|
|
// MDefaultString
|
|
bool m_bRadialCheck; // 0x1b1
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 560
|
|
class C_INIT_LifespanFromVelocity : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "bias distance"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecComponentScale; // 0x180
|
|
// MPropertyFriendlyName "trace offset"
|
|
// MDefaultString
|
|
float m_flTraceOffset; // 0x18c
|
|
// MPropertyFriendlyName "maximum trace length"
|
|
// MDefaultString
|
|
float m_flMaxTraceLength; // 0x190
|
|
// MPropertyFriendlyName "trace recycle tolerance"
|
|
// MDefaultString
|
|
float m_flTraceTolerance; // 0x194
|
|
// MPropertyFriendlyName "maximum points to cache"
|
|
// MDefaultString
|
|
int32_t m_nMaxPlanes; // 0x198
|
|
// MPropertyFriendlyName "trace collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x1a0
|
|
// MPropertyFriendlyName "collide with water"
|
|
// MDefaultString
|
|
bool m_bIncludeWater; // 0x224
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_ConstrainLineLength : public CParticleFunctionConstraint, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "minimum length"
|
|
// MDefaultString
|
|
float m_flMinDistance; // 0x180
|
|
// MPropertyFriendlyName "maximum length"
|
|
// MDefaultString
|
|
float m_flMaxDistance; // 0x184
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 864
|
|
class C_OP_InstantaneousEmitter : public CParticleFunctionEmitter, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Emit Count"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "1 1000"
|
|
CParticleCollectionFloatInput m_nParticlesToEmit; // 0x180
|
|
// MPropertyFriendlyName "Start Time Offset"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flStartTime; // 0x268
|
|
// MPropertyFriendlyName "emission scale from killed parent particles"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Advanced"
|
|
float m_flInitFromKilledParentParticles; // 0x350
|
|
// MPropertyFriendlyName "maximum emission per frame"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Advanced"
|
|
int32_t m_nMaxEmittedPerFrame; // 0x354
|
|
// MPropertyFriendlyName "control point with snapshot data"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Advanced"
|
|
int32_t m_nSnapshotControlPoint; // 0x358
|
|
};
|
|
|
|
// Aligment: 18
|
|
// Size: 1072
|
|
class CParticleVecInput
|
|
{
|
|
public:
|
|
// MDefaultString
|
|
ParticleVecType_t m_nType; // 0x0
|
|
// MDefaultString
|
|
Vector m_vLiteralValue; // 0x4
|
|
// MDefaultString
|
|
Color m_LiteralColor; // 0x10
|
|
// MDefaultString
|
|
ParticleAttributeIndex_t m_nVectorAttribute; // 0x14
|
|
// MDefaultString
|
|
Vector m_vVectorAttributeScale; // 0x18
|
|
// MDefaultString
|
|
int32_t m_nControlPoint; // 0x24
|
|
// MDefaultString
|
|
Vector m_vCPValueScale; // 0x28
|
|
// MDefaultString
|
|
Vector m_vCPRelativePosition; // 0x34
|
|
// MDefaultString
|
|
Vector m_vCPRelativeDir; // 0x40
|
|
CParticleFloatInput m_FloatComponentX; // 0x50
|
|
CParticleFloatInput m_FloatComponentY; // 0x138
|
|
CParticleFloatInput m_FloatComponentZ; // 0x220
|
|
CParticleFloatInput m_FloatInterp; // 0x308
|
|
// MDefaultString
|
|
float m_flInterpInput0; // 0x3f0
|
|
// MDefaultString
|
|
float m_flInterpInput1; // 0x3f4
|
|
// MDefaultString
|
|
Vector m_vInterpOutput0; // 0x3f8
|
|
// MDefaultString
|
|
Vector m_vInterpOutput1; // 0x404
|
|
CColorGradient m_Gradient; // 0x410
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 416
|
|
class C_OP_Spin : public CGeneralSpin, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 528
|
|
class C_OP_RenderAsModels : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "models"
|
|
CUtlVector< ModelReference_t > m_ModelList; // 0x1d0
|
|
// MPropertyFriendlyName "scale factor for radius"
|
|
// MDefaultString
|
|
float m_flModelScale; // 0x1ec
|
|
// MPropertyFriendlyName "scale model to match particle size"
|
|
// MDefaultString
|
|
bool m_bFitToModelSize; // 0x1f0
|
|
// MPropertyFriendlyName "non-uniform scaling"
|
|
// MDefaultString
|
|
bool m_bNonUniformScaling; // 0x1f1
|
|
// MPropertyFriendlyName "X axis scaling scalar field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nXAxisScalingAttribute; // 0x1f4
|
|
// MPropertyFriendlyName "Y axis scaling scalar field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nYAxisScalingAttribute; // 0x1f8
|
|
// MPropertyFriendlyName "Z axis scaling scalar field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nZAxisScalingAttribute; // 0x1fc
|
|
// MPropertyFriendlyName "model size cull bloat"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_size_cull_bloat"
|
|
int32_t m_nSizeCullBloat; // 0x200
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 448
|
|
class C_OP_RemapDistanceToLineSegmentToVector : public C_OP_RemapDistanceToLineSegmentBase, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x1a0
|
|
// MPropertyFriendlyName "output value at min distance"
|
|
// MDefaultString
|
|
Vector m_vMinOutputValue; // 0x1a4
|
|
// MPropertyFriendlyName "output value at max distance"
|
|
// MDefaultString
|
|
Vector m_vMaxOutputValue; // 0x1b0
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 384
|
|
class C_OP_SpinUpdate : public CSpinUpdateBase, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_INIT_CreateFromPlaneCache : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "local offset min"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecOffsetMin; // 0x180
|
|
// MPropertyFriendlyName "local offset max"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecOffsetMax; // 0x18c
|
|
// MPropertyFriendlyName "set normal"
|
|
// MDefaultString
|
|
bool m_bUseNormal; // 0x199
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_OP_RemapScalarEndCap : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x188
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x18c
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x190
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x194
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 64
|
|
class CPathParameters
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "start control point number"
|
|
// MDefaultString
|
|
int32_t m_nStartControlPointNumber; // 0x0
|
|
// MPropertyFriendlyName "end control point number"
|
|
// MDefaultString
|
|
int32_t m_nEndControlPointNumber; // 0x4
|
|
// MPropertyFriendlyName "bulge control 0=random 1=orientation of start pnt 2=orientation of end point"
|
|
// MDefaultString
|
|
int32_t m_nBulgeControl; // 0x8
|
|
// MPropertyFriendlyName "random bulge"
|
|
// MDefaultString
|
|
float m_flBulge; // 0xc
|
|
// MPropertyFriendlyName "mid point position"
|
|
// MDefaultString
|
|
float m_flMidPoint; // 0x10
|
|
// MPropertyFriendlyName "Offset from curve start point for path start"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vStartPointOffset; // 0x14
|
|
// MPropertyFriendlyName "Offset from curve midpoint for curve center"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vMidPointOffset; // 0x20
|
|
// MPropertyFriendlyName "Offset from control point for path end"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vEndOffset; // 0x2c
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 624
|
|
class C_INIT_InitFloatCollection : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "value"
|
|
CParticleCollectionFloatInput m_InputValue; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nOutputField; // 0x268
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_PlayEndCapWhenFinished : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "play when emission ends"
|
|
// MDefaultString
|
|
bool m_bFireOnEmissionEnd; // 0x180
|
|
// MPropertyFriendlyName "wait for children to finish"
|
|
// MDefaultString
|
|
bool m_bIncludeChildren; // 0x181
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_OP_MovementLoopInsideSphere : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "distance maximum"
|
|
// MDefaultString
|
|
float m_flDistance; // 0x184
|
|
// MPropertyFriendlyName "component scale"
|
|
// MDefaultString
|
|
Vector m_vecScale; // 0x188
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_OP_InheritFromParentParticles : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "scale"
|
|
// MDefaultString
|
|
float m_flScale; // 0x180
|
|
// MPropertyFriendlyName "inherited field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "particle increment amount"
|
|
// MDefaultString
|
|
int32_t m_nIncrement; // 0x188
|
|
// MPropertyFriendlyName "random parent particle distribution"
|
|
// MDefaultString
|
|
bool m_bRandomDistribution; // 0x18c
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 384
|
|
class CParticleFunctionForce : public CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_INIT_RemapInitialDirectionToCPToVector : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "scale factor"
|
|
// MDefaultString
|
|
float m_flScale; // 0x188
|
|
// MPropertyFriendlyName "offset rotation"
|
|
// MDefaultString
|
|
float m_flOffsetRot; // 0x18c
|
|
// MPropertyFriendlyName "offset axis"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecOffsetAxis; // 0x190
|
|
// MPropertyFriendlyName "normalize"
|
|
// MDefaultString
|
|
bool m_bNormalize; // 0x19c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 864
|
|
class C_OP_SetControlPointFieldToScalarExpression : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "expression"
|
|
// MDefaultString
|
|
ScalarExpressionType_t m_nExpression; // 0x180
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutputCP; // 0x184
|
|
// MPropertyFriendlyName "output component"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nOutVectorField; // 0x188
|
|
// MPropertyFriendlyName "input 1"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flInput1; // 0x190
|
|
// MPropertyFriendlyName "input 2"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flInput2; // 0x278
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_INIT_RemapQAnglesToRotation : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x180
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_INIT_MakeShapes : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "min size"
|
|
// MDefaultString
|
|
float m_flMinSize; // 0x180
|
|
// MPropertyFriendlyName "max size"
|
|
// MDefaultString
|
|
float m_flMaxSize; // 0x184
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 432
|
|
class C_OP_RemapCPVisibilityToVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x180
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint; // 0x184
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x188
|
|
// MPropertyFriendlyName "CP visibility minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x18c
|
|
// MPropertyFriendlyName "CP visibility maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x190
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
Vector m_vecOutputMin; // 0x194
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
Vector m_vecOutputMax; // 0x1a0
|
|
// MPropertyFriendlyName "visibility radius"
|
|
// MDefaultString
|
|
float m_flRadius; // 0x1ac
|
|
};
|
|
|
|
// Aligment: 12
|
|
// Size: 1472
|
|
class C_OP_DistanceBetweenCPs : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "starting control point"
|
|
// MDefaultString
|
|
int32_t m_nStartCP; // 0x184
|
|
// MPropertyFriendlyName "ending control point"
|
|
// MDefaultString
|
|
int32_t m_nEndCP; // 0x188
|
|
// MPropertyFriendlyName "distance minimum"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInputMin; // 0x190
|
|
// MPropertyFriendlyName "distance maximum"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInputMax; // 0x278
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flOutputMin; // 0x360
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flOutputMax; // 0x448
|
|
// MPropertyFriendlyName "maximum trace length"
|
|
// MDefaultString
|
|
float m_flMaxTraceLength; // 0x530
|
|
// MPropertyFriendlyName "LOS Failure Scalar"
|
|
// MDefaultString
|
|
float m_flLOSScale; // 0x534
|
|
// MPropertyFriendlyName "LOS collision group"
|
|
// MDefaultString
|
|
char[128] m_CollisionGroupName; // 0x538
|
|
// MPropertyFriendlyName "ensure line of sight"
|
|
// MDefaultString
|
|
bool m_bLOS; // 0x5b8
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x5bc
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 480
|
|
class C_OP_RemapNamedModelMeshGroupOnceTimed : public C_OP_RemapNamedModelElementOnceTimed, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 2544
|
|
class C_OP_SetControlPointToVectorExpression : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "expression"
|
|
// MDefaultString
|
|
VectorExpressionType_t m_nExpression; // 0x180
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutputCP; // 0x184
|
|
// MPropertyFriendlyName "input 1"
|
|
CParticleCollectionVecInput m_vInput1; // 0x188
|
|
// MPropertyFriendlyName "input 2"
|
|
CParticleCollectionVecInput m_vInput2; // 0x5b8
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 20
|
|
struct ControlPointReference_t
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Control point"
|
|
// MDefaultString
|
|
int32_t m_controlPointNameString; // 0x0
|
|
// MPropertyFriendlyName "Offset from control point"
|
|
// MDefaultString
|
|
Vector m_vOffsetFromControlPoint; // 0x4
|
|
// MPropertyFriendlyName "Use local space offset"
|
|
// MDefaultString
|
|
bool m_bOffsetInLocalSpace; // 0x10
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_OP_Orient2DRelToCP : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "rotation offset"
|
|
// MDefaultString
|
|
float m_flRotOffset; // 0x180
|
|
// MPropertyFriendlyName "spin strength"
|
|
// MDefaultString
|
|
float m_flSpinStrength; // 0x184
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x188
|
|
// MPropertyFriendlyName "rotation field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_rotation"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x18c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_INIT_VelocityRadialRandom : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "random speed min"
|
|
// MDefaultString
|
|
float m_fSpeedMin; // 0x184
|
|
// MPropertyFriendlyName "random speed max"
|
|
// MDefaultString
|
|
float m_fSpeedMax; // 0x188
|
|
// MPropertyFriendlyName "local space scale"
|
|
// MDefaultString
|
|
Vector m_vecLocalCoordinateSystemSpeedScale; // 0x18c
|
|
// MPropertyFriendlyName "ignore delta time"
|
|
// MDefaultString
|
|
bool m_bIgnoreDelta; // 0x199
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 64
|
|
class CPiecewiseCurveSchemaWrapper
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 896
|
|
class C_OP_AttractToControlPoint : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "component scale"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecComponentScale; // 0x180
|
|
// MPropertyFriendlyName "amount of force (or Max Force)"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_fForceAmount; // 0x190
|
|
// MPropertyFriendlyName "falloff power"
|
|
// MDefaultString
|
|
float m_fFalloffPower; // 0x278
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x27c
|
|
// MPropertyFriendlyName "scale in local space"
|
|
// MDefaultString
|
|
bool m_bScaleLocal; // 0x280
|
|
// MPropertyFriendlyName "Min Pullforce"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_fForceAmountMin; // 0x288
|
|
// MPropertyFriendlyName "Apply Min Pullforce"
|
|
// MDefaultString
|
|
bool m_bApplyMinForce; // 0x370
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 432
|
|
class C_INIT_CreatePhyllotaxis : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "scale size multiplier from CP"
|
|
// MDefaultString
|
|
int32_t m_nScaleCP; // 0x184
|
|
// MPropertyFriendlyName "scale CP component 0/1/2 X/Y/Z"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nComponent; // 0x188
|
|
// MPropertyFriendlyName "center core radius"
|
|
// MDefaultString
|
|
float m_fRadCentCore; // 0x18c
|
|
// MPropertyFriendlyName "radius multiplier"
|
|
// MDefaultString
|
|
float m_fRadPerPoint; // 0x190
|
|
// MPropertyFriendlyName "radius max (-1 procedural growth)"
|
|
// MDefaultString
|
|
float m_fRadPerPointTo; // 0x194
|
|
// MPropertyFriendlyName "golden angle (is 137.508)"
|
|
// MDefaultString
|
|
float m_fpointAngle; // 0x198
|
|
// MPropertyFriendlyName "overall size multiplier (-1 count based distribution)"
|
|
// MDefaultString
|
|
float m_fsizeOverall; // 0x19c
|
|
// MPropertyFriendlyName "radius bias"
|
|
// MDefaultString
|
|
float m_fRadBias; // 0x1a0
|
|
// MPropertyFriendlyName "radius min "
|
|
// MDefaultString
|
|
float m_fMinRad; // 0x1a4
|
|
// MPropertyFriendlyName "Distribution Bias"
|
|
// MPropertyFriendlyName "distribution bias"
|
|
// MDefaultString
|
|
float m_fDistBias; // 0x1a8
|
|
// MPropertyFriendlyName "local space"
|
|
// MDefaultString
|
|
bool m_bUseLocalCoords; // 0x1ac
|
|
// MPropertyFriendlyName "use continuous emission"
|
|
// MDefaultString
|
|
bool m_bUseWithContEmit; // 0x1ad
|
|
// MPropertyFriendlyName "scale radius from initial value"
|
|
// MDefaultString
|
|
bool m_bUseOrigRadius; // 0x1ae
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 416
|
|
class C_OP_BoxConstraint : public CParticleFunctionConstraint, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "min coords"
|
|
// MDefaultString
|
|
Vector m_vecMin; // 0x180
|
|
// MPropertyFriendlyName "max coords"
|
|
// MDefaultString
|
|
Vector m_vecMax; // 0x18c
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nCP; // 0x198
|
|
// MPropertyFriendlyName "use local space"
|
|
// MDefaultString
|
|
bool m_bLocalSpace; // 0x19c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_OP_SetParentControlPointsToChildCP : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "group ID to affect"
|
|
// MDefaultString
|
|
int32_t m_nChildGroupID; // 0x180
|
|
// MPropertyFriendlyName "control point to set"
|
|
// MDefaultString
|
|
int32_t m_nChildControlPoint; // 0x184
|
|
// MPropertyFriendlyName "# of children to set"
|
|
// MDefaultString
|
|
int32_t m_nNumControlPoints; // 0x188
|
|
// MPropertyFriendlyName "first parent control point to set from"
|
|
// MDefaultString
|
|
int32_t m_nFirstSourcePoint; // 0x18c
|
|
// MPropertyFriendlyName "set orientation"
|
|
// MDefaultString
|
|
bool m_bSetOrientation; // 0x190
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 416
|
|
class C_OP_SetPerChildControlPointFromAttribute : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "group ID to affect"
|
|
// MDefaultString
|
|
int32_t m_nChildGroupID; // 0x180
|
|
// MPropertyFriendlyName "control point to set"
|
|
// MDefaultString
|
|
int32_t m_nFirstControlPoint; // 0x184
|
|
// MPropertyFriendlyName "# of children to set"
|
|
// MDefaultString
|
|
int32_t m_nNumControlPoints; // 0x188
|
|
// MPropertyFriendlyName "particle increment amount"
|
|
// MDefaultString
|
|
int32_t m_nParticleIncrement; // 0x18c
|
|
// MPropertyFriendlyName "first particle to copy"
|
|
// MDefaultString
|
|
int32_t m_nFirstSourcePoint; // 0x190
|
|
// MPropertyFriendlyName "set number of children based on particle count"
|
|
// MDefaultString
|
|
bool m_bNumBasedOnParticleCount; // 0x194
|
|
// MPropertyFriendlyName "field to read"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nAttributeToRead; // 0x198
|
|
// MPropertyFriendlyName "control point field for scalars"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nCPField; // 0x19c
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 416
|
|
class C_INIT_OffsetVectorToVector : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "output offset minimum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vecOutputMin; // 0x188
|
|
// MPropertyFriendlyName "output offset maximum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vecOutputMax; // 0x194
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_GlobalLight : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "initial color bias"
|
|
// MDefaultString
|
|
float m_flScale; // 0x180
|
|
// MPropertyFriendlyName "clamp minimum light value to initial color"
|
|
// MDefaultString
|
|
bool m_bClampLowerRange; // 0x184
|
|
// MPropertyFriendlyName "clamp maximum light value to initial color"
|
|
// MDefaultString
|
|
bool m_bClampUpperRange; // 0x185
|
|
};
|
|
|
|
// Aligment: 16
|
|
// Size: 384
|
|
class CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyGroupName "Operator Fade"
|
|
// MPropertyFriendlyName "operator start fadein"
|
|
// MDefaultString
|
|
float m_flOpStartFadeInTime; // 0x8
|
|
// MPropertyGroupName "Operator Fade"
|
|
// MPropertyFriendlyName "operator end fadein"
|
|
// MDefaultString
|
|
float m_flOpEndFadeInTime; // 0xc
|
|
// MPropertyGroupName "Operator Fade"
|
|
// MPropertyFriendlyName "operator start fadeout"
|
|
// MDefaultString
|
|
float m_flOpStartFadeOutTime; // 0x10
|
|
// MPropertyGroupName "Operator Fade"
|
|
// MPropertyFriendlyName "operator end fadeout"
|
|
// MDefaultString
|
|
float m_flOpEndFadeOutTime; // 0x14
|
|
// MPropertyGroupName "Operator Fade"
|
|
// MPropertyFriendlyName "operator fade oscillate"
|
|
// MDefaultString
|
|
float m_flOpFadeOscillatePeriod; // 0x18
|
|
// MPropertyGroupName "Operator Fade"
|
|
// MPropertyFriendlyName "normalize fade times to endcap"
|
|
// MDefaultString
|
|
bool m_bNormalizeToStopTime; // 0x1c
|
|
// MPropertyGroupName "Time Offset"
|
|
// MPropertyFriendlyName "operator time offset min"
|
|
// MDefaultString
|
|
float m_flOpTimeOffsetMin; // 0x20
|
|
// MPropertyGroupName "Time Offset"
|
|
// MPropertyFriendlyName "operator time offset max"
|
|
// MDefaultString
|
|
float m_flOpTimeOffsetMax; // 0x24
|
|
// MPropertyGroupName "Time Offset"
|
|
// MPropertyFriendlyName "operator time offset seed"
|
|
// MDefaultString
|
|
int32_t m_nOpTimeOffsetSeed; // 0x28
|
|
// MPropertyGroupName "Timescale Modifiers"
|
|
// MPropertyFriendlyName "operator time scale seed"
|
|
// MDefaultString
|
|
int32_t m_nOpTimeScaleSeed; // 0x2c
|
|
// MPropertyGroupName "Timescale Modifiers"
|
|
// MPropertyFriendlyName "operator time scale min"
|
|
// MDefaultString
|
|
float m_flOpTimeScaleMin; // 0x30
|
|
// MPropertyGroupName "Timescale Modifiers"
|
|
// MPropertyFriendlyName "operator time scale max"
|
|
// MDefaultString
|
|
float m_flOpTimeScaleMax; // 0x34
|
|
// MPropertySuppressField
|
|
// MDefaultString
|
|
bool m_bDisableOperator; // 0x39
|
|
// MPropertyFriendlyName "operator end cap state"
|
|
// MDefaultString
|
|
int32_t m_nOpEndCapState; // 0x3c
|
|
// MPropertyGroupName "Strength Modifiers"
|
|
// MPropertyFriendlyName "operator strength"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flOpStrength; // 0x40
|
|
// MPropertyFriendlyName "Notes"
|
|
// MDefaultString
|
|
// MParticleHelpField
|
|
CUtlString m_Notes; // 0x128
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 464
|
|
class C_OP_Callback : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 528
|
|
class C_INIT_InitFromParentKilled : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "field to init"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield"
|
|
ParticleAttributeIndex_t m_nAttributeToCopy; // 0x180
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 432
|
|
class C_INIT_RandomNamedModelElement : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "model"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "AssetBrowse( vmdl )"
|
|
CStrongHandle< InfoForResourceTypeCModel > m_hModel; // 0x180
|
|
// MPropertyFriendlyName "names"
|
|
CUtlVector< CUtlString > m_names; // 0x188
|
|
// MPropertyFriendlyName "shuffle"
|
|
// MDefaultString
|
|
bool m_bShuffle; // 0x1a0
|
|
// MPropertyFriendlyName "linear"
|
|
// MDefaultString
|
|
bool m_bLinear; // 0x1a1
|
|
// MPropertyFriendlyName "model from renderer"
|
|
// MDefaultString
|
|
bool m_bModelFromRenderer; // 0x1a2
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x1a4
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 416
|
|
class C_OP_BasicMovement : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "gravity"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_Gravity; // 0x180
|
|
// MPropertyFriendlyName "drag"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "-1 1"
|
|
float m_fDrag; // 0x18c
|
|
// MPropertyFriendlyName "max constraint passes"
|
|
// MDefaultString
|
|
int32_t m_nMaxConstraintPasses; // 0x190
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 656
|
|
class C_OP_QuantizeFloat : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "value"
|
|
CPerParticleFloatInput m_InputValue; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nOutputField; // 0x268
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 880
|
|
class C_INIT_MoveBetweenPoints : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Min Speed"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flSpeedMin; // 0x180
|
|
// MPropertyFriendlyName "Max Speed"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flSpeedMax; // 0x268
|
|
// MPropertyFriendlyName "Spread"
|
|
// MDefaultString
|
|
float m_flEndSpread; // 0x350
|
|
// MPropertyFriendlyName "Start Offset"
|
|
// MDefaultString
|
|
float m_flStartOffset; // 0x354
|
|
// MPropertyFriendlyName "End Offset"
|
|
// MDefaultString
|
|
float m_flEndOffset; // 0x358
|
|
// MPropertyFriendlyName "Target Control Point"
|
|
// MDefaultString
|
|
int32_t m_nEndControlPointNumber; // 0x35c
|
|
// MPropertyFriendlyName "Bias Lifetime by Trail Length"
|
|
// MDefaultString
|
|
bool m_bTrailBias; // 0x360
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_INIT_SequenceLifeTime : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "frames per second"
|
|
// MDefaultString
|
|
float m_flFramerate; // 0x180
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 432
|
|
class C_OP_OscillateVectorSimple : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "oscillation rate"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_Rate; // 0x180
|
|
// MPropertyFriendlyName "oscillation frequency"
|
|
// MDefaultString
|
|
Vector m_Frequency; // 0x18c
|
|
// MPropertyFriendlyName "oscillation field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nField; // 0x198
|
|
// MPropertyFriendlyName "oscillation multiplier"
|
|
// MDefaultString
|
|
float m_flOscMult; // 0x19c
|
|
// MPropertyFriendlyName "oscillation start phase"
|
|
// MDefaultString
|
|
float m_flOscAdd; // 0x1a0
|
|
// MPropertyFriendlyName "offset instead of accelerate position"
|
|
// MDefaultString
|
|
bool m_bOffset; // 0x1a4
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 1104
|
|
class C_OP_ContinuousEmitter : public CParticleFunctionEmitter, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Duration Limit"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flEmissionDuration; // 0x180
|
|
// MPropertyFriendlyName "Start Time Offset"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flStartTime; // 0x268
|
|
// MPropertyFriendlyName "Emit Rate"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flEmitRate; // 0x350
|
|
// MPropertyFriendlyName "scale emission to used control points"
|
|
// MDefaultString
|
|
// MParticleMaxVersion
|
|
// MPropertyGroupName "Advanced"
|
|
float m_flEmissionScale; // 0x438
|
|
// MPropertyFriendlyName "scale emission by parent particle count"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Advanced"
|
|
float m_flScalePerParentParticle; // 0x43c
|
|
// MPropertyFriendlyName "emit particles for killed parent particles"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Advanced"
|
|
bool m_bInitFromKilledParentParticles; // 0x440
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_OP_RemapDistanceToLineSegmentBase : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point 0"
|
|
// MDefaultString
|
|
int32_t m_nCP0; // 0x180
|
|
// MPropertyFriendlyName "control point 1"
|
|
// MDefaultString
|
|
int32_t m_nCP1; // 0x184
|
|
// MPropertyFriendlyName "min distance value"
|
|
// MDefaultString
|
|
float m_flMinInputValue; // 0x188
|
|
// MPropertyFriendlyName "max distance value"
|
|
// MDefaultString
|
|
float m_flMaxInputValue; // 0x18c
|
|
// MPropertyFriendlyName "use distance to an infinite line instead of a finite line segment"
|
|
// MDefaultString
|
|
bool m_bInfiniteLine; // 0x190
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_OP_EndCapTimedDecay : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "decay time"
|
|
// MDefaultString
|
|
float m_flDecayTime; // 0x180
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 624
|
|
class C_OP_DecayOffscreen : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Offscreen Time Before Decay"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flOffscreenTime; // 0x180
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 416
|
|
class C_OP_RemapCPVisibilityToScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x180
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint; // 0x184
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x188
|
|
// MPropertyFriendlyName "CP visibility minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x18c
|
|
// MPropertyFriendlyName "CP visibility maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x190
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x194
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x198
|
|
// MPropertyFriendlyName "visibility radius"
|
|
// MDefaultString
|
|
float m_flRadius; // 0x19c
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_OP_RemapScalar : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x188
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x18c
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x190
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x194
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 2256
|
|
class C_INIT_RingWave : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "even distribution count"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flParticlesPerOrbit; // 0x188
|
|
// MPropertyFriendlyName "initial radius"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInitialRadius; // 0x270
|
|
// MPropertyFriendlyName "thickness"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flThickness; // 0x358
|
|
// MPropertyFriendlyName "min initial speed"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInitialSpeedMin; // 0x440
|
|
// MPropertyFriendlyName "max initial speed"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInitialSpeedMax; // 0x528
|
|
// MPropertyFriendlyName "roll"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flRoll; // 0x610
|
|
// MPropertyFriendlyName "pitch"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flPitch; // 0x6f8
|
|
// MPropertyFriendlyName "yaw"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flYaw; // 0x7e0
|
|
// MPropertyFriendlyName "even distribution"
|
|
// MDefaultString
|
|
bool m_bEvenDistribution; // 0x8c8
|
|
// MPropertyFriendlyName "XY velocity only"
|
|
// MDefaultString
|
|
bool m_bXYVelocityOnly; // 0x8c9
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 528
|
|
class C_INIT_SetHitboxToClosest : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "desired hitbox"
|
|
// MDefaultString
|
|
int32_t m_nDesiredHitbox; // 0x184
|
|
// MPropertyFriendlyName "model hitbox scale"
|
|
// MDefaultString
|
|
float m_flHitBoxScale; // 0x188
|
|
// MPropertyFriendlyName "hitbox set"
|
|
// MDefaultString
|
|
char[128] m_HitboxSetName; // 0x18c
|
|
// MPropertyFriendlyName "use bones instead of hitboxes"
|
|
// MDefaultString
|
|
bool m_bUseBones; // 0x20c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_RemapVelocityToVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "scale factor"
|
|
// MDefaultString
|
|
float m_flScale; // 0x184
|
|
// MPropertyFriendlyName "normalize"
|
|
// MDefaultString
|
|
bool m_bNormalize; // 0x188
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 480
|
|
class C_OP_RenderTonemapController : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "tonemap level scale"
|
|
// MDefaultString
|
|
float m_flTonemapLevel; // 0x1d0
|
|
// MPropertyFriendlyName "tonemap weight scale"
|
|
// MDefaultString
|
|
float m_flTonemapWeight; // 0x1d4
|
|
// MPropertyFriendlyName "tonemap level"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nTonemapLevelField; // 0x1d8
|
|
// MPropertyFriendlyName "tonemap weight"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nTonemapWeightField; // 0x1dc
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 1088
|
|
class C_OP_RepeatedTriggerChildGroup : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "group ID to affect"
|
|
// MDefaultString
|
|
int32_t m_nChildGroupID; // 0x180
|
|
// MPropertyFriendlyName "Within-Cluster Refire Time"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flClusterRefireTime; // 0x188
|
|
// MPropertyFriendlyName "Within-Cluster Fire Count Before Cooldown"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flClusterSize; // 0x270
|
|
// MPropertyFriendlyName "Cluster Cooldown Time"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flClusterCooldown; // 0x358
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_FadeInSimple : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "proportional fade in time"
|
|
// MDefaultString
|
|
float m_flFadeInTime; // 0x180
|
|
// MPropertyFriendlyName "alpha field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_alpha"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_NormalizeVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "scale factor"
|
|
// MDefaultString
|
|
float m_flScale; // 0x184
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 624
|
|
class C_OP_ExternalGameImpulseForce : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "force scale"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flForceScale; // 0x180
|
|
// MPropertyFriendlyName "rope shake"
|
|
// MDefaultString
|
|
bool m_bRopes; // 0x268
|
|
// MPropertyFriendlyName "limit rope impulses to Z"
|
|
// MDefaultString
|
|
bool m_bRopesZOnly; // 0x269
|
|
// MPropertyFriendlyName "explosions"
|
|
// MDefaultString
|
|
bool m_bExplosions; // 0x26a
|
|
// MPropertyFriendlyName "particle systems"
|
|
// MDefaultString
|
|
bool m_bParticles; // 0x26b
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1072
|
|
class CPerParticleVecInput : public CParticleVecInput
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_OP_DecayMaintainCount : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "count to maintain"
|
|
// MDefaultString
|
|
int32_t m_nParticlesToMaintain; // 0x180
|
|
// MPropertyFriendlyName "maintain count scale control point"
|
|
// MDefaultString
|
|
int32_t m_nScaleControlPoint; // 0x184
|
|
// MPropertyFriendlyName "maintain count scale control point field"
|
|
// MDefaultString
|
|
int32_t m_nScaleControlPointField; // 0x188
|
|
// MPropertyFriendlyName "decay delay"
|
|
// MDefaultString
|
|
float m_flDecayDelay; // 0x18c
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 544
|
|
class C_OP_SetControlPointPositionToTimeOfDayValue : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "time-of-day parameter"
|
|
// MDefaultString
|
|
char[128] m_pszTimeOfDayParameter; // 0x184
|
|
// MPropertyFriendlyName "default value"
|
|
// MDefaultString
|
|
Vector m_vecDefaultValue; // 0x204
|
|
};
|
|
|
|
// Aligment: 19
|
|
// Size: 8416
|
|
class C_OP_RenderTrails : public CBaseTrailRenderer, CBaseRendererSource2, CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "enable fading and clamping"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
bool m_bEnableFadingAndClamping; // 0x14a0
|
|
// MPropertyFriendlyName "max length"
|
|
// MDefaultString
|
|
float m_flMaxLength; // 0x14a4
|
|
// MPropertyFriendlyName "min length"
|
|
// MDefaultString
|
|
float m_flMinLength; // 0x14a8
|
|
// MPropertyFriendlyName "ignore delta time"
|
|
// MDefaultString
|
|
bool m_bIgnoreDT; // 0x14ac
|
|
// MPropertyFriendlyName "constrain radius to no more than this times the length"
|
|
// MDefaultString
|
|
float m_flConstrainRadiusToLengthRatio; // 0x14b0
|
|
// MPropertyFriendlyName "amount to scale trail length by"
|
|
// MDefaultString
|
|
float m_flLengthScale; // 0x14b4
|
|
// MPropertyFriendlyName "how long before a trail grows to its full length"
|
|
// MDefaultString
|
|
float m_flLengthFadeInTime; // 0x14b8
|
|
// MPropertyFriendlyName "head taper scale"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flRadiusHeadTaper; // 0x14c0
|
|
// MPropertyFriendlyName "head color scale"
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecHeadColorScale; // 0x15a8
|
|
// MPropertyFriendlyName "head alpha scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flHeadAlphaScale; // 0x19d8
|
|
// MPropertyFriendlyName "tail taper scale"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flRadiusTaper; // 0x1ac0
|
|
// MPropertyFriendlyName "tail color scale"
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecTailColorScale; // 0x1ba8
|
|
// MPropertyFriendlyName "tail alpha scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flTailAlphaScale; // 0x1fd8
|
|
// MPropertyFriendlyName "texture UV horizontal Scale field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nHorizCropField; // 0x20c0
|
|
// MPropertyFriendlyName "texture UV vertical Scale field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nVertCropField; // 0x20c4
|
|
// MPropertyFriendlyName "Trail forward shift (fraction)"
|
|
// MDefaultString
|
|
float m_flForwardShift; // 0x20c8
|
|
// MPropertyFriendlyName "Flip U or V texcoords if pitch or yaw go over PI"
|
|
// MDefaultString
|
|
bool m_bFlipUVBasedOnPitchYaw; // 0x20cc
|
|
// MPropertyFriendlyName "Anchor point source"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nPrevPntSource; // 0x20d0
|
|
// MPropertyFriendlyName "Use particle system topology"
|
|
// MDefaultString
|
|
bool m_bUseTopology; // 0x20d4
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 1328
|
|
class C_OP_RemapDotProductToCP : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "first input control point"
|
|
// MDefaultString
|
|
int32_t m_nInputCP1; // 0x180
|
|
// MPropertyFriendlyName "second input control point"
|
|
// MDefaultString
|
|
int32_t m_nInputCP2; // 0x184
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutputCP; // 0x188
|
|
// MPropertyFriendlyName "output component"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nOutVectorField; // 0x18c
|
|
// MPropertyFriendlyName "input minimum (-1 to 1)"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flInputMin; // 0x190
|
|
// MPropertyFriendlyName "input maximum (-1 to 1)"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flInputMax; // 0x278
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flOutputMin; // 0x360
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flOutputMax; // 0x448
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 400
|
|
class C_OP_OrientTo2dDirection : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "rotation offset"
|
|
// MDefaultString
|
|
float m_flRotOffset; // 0x180
|
|
// MPropertyFriendlyName "spin strength"
|
|
// MDefaultString
|
|
float m_flSpinStrength; // 0x184
|
|
// MPropertyFriendlyName "rotation field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_rotation"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x188
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 384
|
|
class CSpinUpdateBase : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 50
|
|
// Size: 3232
|
|
class CBaseRendererSource2 : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "animation rate"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 5"
|
|
float m_flAnimationRate; // 0x1d0
|
|
// MPropertyFriendlyName "animation type"
|
|
// MDefaultString
|
|
AnimationType_t m_nAnimationType; // 0x1d4
|
|
// MPropertyFriendlyName "set animation value in FPS"
|
|
// MDefaultString
|
|
bool m_bAnimateInFPS; // 0x1d8
|
|
// MPropertyFriendlyName "light per vertex"
|
|
// MDefaultString
|
|
bool m_bPerVertexLighting; // 0x1d9
|
|
// MPropertyFriendlyName "self illum amount"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 2"
|
|
CParticleCollectionFloatInput m_flSelfIllumAmount; // 0x1e0
|
|
// MPropertyFriendlyName "diffuse lighting amount"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 1"
|
|
CParticleCollectionFloatInput m_flDiffuseAmount; // 0x2c8
|
|
// MPropertyFriendlyName "diffuse lighting origin Control Point"
|
|
// MDefaultString
|
|
int32_t m_nLightingControlPoint; // 0x3b0
|
|
// MPropertyFriendlyName "self illum per-particle"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nSelfIllumPerParticle; // 0x3b4
|
|
// MPropertyFriendlyName "desaturation amount"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 1"
|
|
CParticleCollectionFloatInput m_flDesaturation; // 0x3b8
|
|
// MPropertyFriendlyName "source alpha value to map to alpha of zero"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
CParticleCollectionFloatInput m_flSourceAlphaValueToMapToZero; // 0x4a0
|
|
// MPropertyFriendlyName "source alpha value to map to alpha of 1"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
CParticleCollectionFloatInput m_flSourceAlphaValueToMapToOne; // 0x588
|
|
// MPropertyFriendlyName "Gamma-correct vertex colors"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
bool m_bGammaCorrectVertexColors; // 0x670
|
|
// MPropertyFriendlyName "Saturate color pre alphablend"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
bool m_bSaturateColorPreAlphaBlend; // 0x671
|
|
// MPropertyFriendlyName "dual sequence combine mode"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Dual sequence controls"
|
|
SequenceCombineMode_t m_nSequenceCombineMode; // 0x674
|
|
// MPropertyFriendlyName "second sequence animation rate"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 5"
|
|
// MPropertyGroupName "Dual sequence controls"
|
|
float m_flAnimationRate2; // 0x678
|
|
// MPropertyFriendlyName "RGB blend weight for sequence 0"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyGroupName "Dual sequence controls"
|
|
float m_flSequence0RGBWeight; // 0x67c
|
|
// MPropertyFriendlyName "alpha blend weight for sequence 0"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyGroupName "Dual sequence controls"
|
|
float m_flSequence0AlphaWeight; // 0x680
|
|
// MPropertyFriendlyName "RGB blend weight for sequence 1"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyGroupName "Dual sequence controls"
|
|
float m_flSequence1RGBWeight; // 0x684
|
|
// MPropertyFriendlyName "alpha blend weight for sequence 1"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "0 1"
|
|
// MPropertyGroupName "Dual sequence controls"
|
|
float m_flSequence1AlphaWeight; // 0x688
|
|
// MPropertyFriendlyName "add self amount for combined additive and alpha blended"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
CParticleCollectionFloatInput m_flAddSelfAmount; // 0x690
|
|
// MPropertyFriendlyName "use additive blending"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
bool m_bAdditive; // 0x778
|
|
// MPropertyFriendlyName "Additive alpha - write alpha during additive"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
bool m_bAdditiveAlpha; // 0x779
|
|
// MPropertyFriendlyName "Mod2x blend mode"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
bool m_bMod2X; // 0x77a
|
|
// MPropertyFriendlyName "'Lighten blend mode"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
bool m_bLightenMode; // 0x77b
|
|
// MPropertyFriendlyName "use max-luminance blending for sequence 0"
|
|
// MDefaultString
|
|
bool m_bMaxLuminanceBlendingSequence0; // 0x77c
|
|
// MPropertyFriendlyName "use max-luminance blending for sequence 1"
|
|
// MDefaultString
|
|
bool m_bMaxLuminanceBlendingSequence1; // 0x77d
|
|
// MPropertyFriendlyName "refract background"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Refraction"
|
|
bool m_bRefract; // 0x77e
|
|
// MPropertyFriendlyName "refract amount"
|
|
// MDefaultString
|
|
// MPropertyAttributeRange "-2 2"
|
|
// MPropertyGroupName "Refraction"
|
|
CParticleCollectionFloatInput m_flRefractAmount; // 0x780
|
|
// MPropertyFriendlyName "refract blur radius"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Refraction"
|
|
int32_t m_nRefractBlurRadius; // 0x868
|
|
// MPropertyFriendlyName "refract blur type"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Refraction"
|
|
BlurFilterType_t m_nRefractBlurType; // 0x86c
|
|
// MPropertyFriendlyName "Only Render in effects bloom pass"
|
|
// MDefaultString
|
|
bool m_bOnlyRenderInEffectsBloomPass; // 0x870
|
|
// MPropertyFriendlyName "stencil test ID"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Stencil"
|
|
char[128] m_stencilTestID; // 0x871
|
|
// MPropertyFriendlyName "only write where stencil is NOT stencil test ID"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Stencil"
|
|
bool m_bStencilTestExclude; // 0x8f1
|
|
// MPropertyFriendlyName "stencil write ID"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Stencil"
|
|
char[128] m_stencilWriteID; // 0x8f2
|
|
// MPropertyFriendlyName "write stencil on z-buffer test success"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Stencil"
|
|
bool m_bWriteStencilOnDepthPass; // 0x972
|
|
// MPropertyFriendlyName "write stencil on z-buffer test failure"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Stencil"
|
|
bool m_bWriteStencilOnDepthFail; // 0x973
|
|
// MPropertyFriendlyName "reverse z-buffer test"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Depth buffer control and effects"
|
|
bool m_bReverseZBuffering; // 0x974
|
|
// MPropertyFriendlyName "disable z-buffer test"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Depth buffer control and effects"
|
|
bool m_bDisableZBuffering; // 0x975
|
|
// MPropertyFriendlyName "Depth feathering mode"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Depth buffer control and effects"
|
|
ParticleDepthFeatheringMode_t m_nFeatheringMode; // 0x978
|
|
// MPropertyFriendlyName "particle feathering closest distance to surface"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Depth buffer control and effects"
|
|
CParticleCollectionFloatInput m_flFeatheringMinDist; // 0x980
|
|
// MPropertyFriendlyName "particle feathering farthest distance to surface"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Depth buffer control and effects"
|
|
CParticleCollectionFloatInput m_flFeatheringMaxDist; // 0xa68
|
|
// MPropertyFriendlyName "overbright factor"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
CParticleCollectionFloatInput m_flOverbrightFactor; // 0xb50
|
|
// MPropertyFriendlyName "Apply fog of war to color"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
bool m_bTintByFOW; // 0xc38
|
|
// MPropertyFriendlyName "Apply fog to particle"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
bool m_bFogParticles; // 0xc39
|
|
// MPropertyFriendlyName "Apply global light to color"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Color and alpha adjustments"
|
|
bool m_bTintByGlobalLight; // 0xc3a
|
|
// MPropertyFriendlyName "texture"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex, *showassetpreview )"
|
|
// MDefaultString
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_hTexture; // 0xc40
|
|
// MPropertyFriendlyName "Apply motion vectors"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Motion vectors"
|
|
bool m_bMotionVectors; // 0xc48
|
|
// MPropertyFriendlyName "motion vectors texture"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex, *showassetpreview )"
|
|
// MPropertyGroupName "Motion vectors"
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_hMotionVectorsTexture; // 0xc50
|
|
// MPropertyFriendlyName "blend sequence 0 animation frames"
|
|
// MDefaultString
|
|
bool m_bBlendFramesSeq0; // 0xc58
|
|
// MPropertyFriendlyName "HSV Shift Control Point"
|
|
// MDefaultString
|
|
int32_t m_nHSVShiftControlPoint; // 0xc5c
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 480
|
|
class C_INIT_RemapCPtoVector : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point number"
|
|
// MDefaultString
|
|
int32_t m_nCPInput; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vInputMin; // 0x188
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vInputMax; // 0x194
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vOutputMin; // 0x1a0
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
// MVectorIsSometimesCoordinate
|
|
Vector m_vOutputMax; // 0x1ac
|
|
// MPropertyFriendlyName "emitter lifetime start time (seconds)"
|
|
// MDefaultString
|
|
float m_flStartTime; // 0x1b8
|
|
// MPropertyFriendlyName "emitter lifetime end time (seconds)"
|
|
// MDefaultString
|
|
float m_flEndTime; // 0x1bc
|
|
// MPropertyFriendlyName "set value method"
|
|
// MDefaultString
|
|
ParticleSetMethod_t m_nSetMethod; // 0x1c0
|
|
// MPropertyFriendlyName "offset position"
|
|
// MDefaultString
|
|
bool m_bOffset; // 0x1c4
|
|
// MPropertyFriendlyName "accelerate position"
|
|
// MDefaultString
|
|
bool m_bAccelerate; // 0x1c5
|
|
// MPropertyFriendlyName "local space CP"
|
|
// MDefaultString
|
|
int32_t m_nLocalSpaceCP; // 0x1c8
|
|
// MPropertyFriendlyName "remap bias"
|
|
// MDefaultString
|
|
float m_flRemapBias; // 0x1cc
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 448
|
|
class C_OP_TeleportBeam : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Position Control Point"
|
|
// MDefaultString
|
|
int32_t m_nCPPosition; // 0x180
|
|
// MPropertyFriendlyName "Velocity Control Point"
|
|
// MDefaultString
|
|
int32_t m_nCPVelocity; // 0x184
|
|
// MPropertyFriendlyName "Misc Control Point"
|
|
// MDefaultString
|
|
int32_t m_nCPMisc; // 0x188
|
|
// MPropertyFriendlyName "Color Control Point"
|
|
// MDefaultString
|
|
int32_t m_nCPColor; // 0x18c
|
|
// MPropertyFriendlyName "Invalid Color Control Point"
|
|
// MDefaultString
|
|
int32_t m_nCPInvalidColor; // 0x190
|
|
// MPropertyFriendlyName "Extra Arc Data Point"
|
|
// MDefaultString
|
|
int32_t m_nCPExtraArcData; // 0x194
|
|
// MPropertyFriendlyName "Gravity"
|
|
// MDefaultString
|
|
Vector m_vGravity; // 0x198
|
|
// MPropertyFriendlyName "Arc Duration Maximum"
|
|
// MDefaultString
|
|
float m_flArcMaxDuration; // 0x1a4
|
|
// MPropertyFriendlyName "Segment Break"
|
|
// MDefaultString
|
|
float m_flSegmentBreak; // 0x1a8
|
|
// MPropertyFriendlyName "Arc Speed"
|
|
// MDefaultString
|
|
float m_flArcSpeed; // 0x1ac
|
|
// MPropertyFriendlyName "Alpha"
|
|
// MDefaultString
|
|
float m_flAlpha; // 0x1b0
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 416
|
|
class C_OP_TwistAroundAxis : public CParticleFunctionForce, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "amount of force"
|
|
// MDefaultString
|
|
float m_fForceAmount; // 0x180
|
|
// MPropertyFriendlyName "twist axis"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_TwistAxis; // 0x184
|
|
// MPropertyFriendlyName "object local space axis 0/1"
|
|
// MDefaultString
|
|
bool m_bLocalSpace; // 0x190
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x194
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 3008
|
|
class C_INIT_VelocityRandom : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "random speed min"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_fSpeedMin; // 0x188
|
|
// MPropertyFriendlyName "random speed max"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_fSpeedMax; // 0x270
|
|
// MPropertyFriendlyName "speed in local coordinate system min"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CPerParticleVecInput m_LocalCoordinateSystemSpeedMin; // 0x358
|
|
// MPropertyFriendlyName "speed in local coordinate system max"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CPerParticleVecInput m_LocalCoordinateSystemSpeedMax; // 0x788
|
|
// MPropertyFriendlyName "Ignore delta time (RenderTrails)"
|
|
// MDefaultString
|
|
bool m_bIgnoreDT; // 0xbb8
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 416
|
|
class C_OP_PlaneCull : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point for point on plane"
|
|
// MDefaultString
|
|
int32_t m_nPlaneControlPoint; // 0x180
|
|
// MPropertyFriendlyName "plane normal"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecPlaneDirection; // 0x184
|
|
// MPropertyFriendlyName "use local space"
|
|
// MDefaultString
|
|
bool m_bLocalSpace; // 0x190
|
|
// MPropertyFriendlyName "cull plane offset"
|
|
// MDefaultString
|
|
float m_flPlaneOffset; // 0x194
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_OP_RemapCPtoVelocity : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point number"
|
|
// MDefaultString
|
|
int32_t m_nCPInput; // 0x180
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 416
|
|
class C_OP_RemapScalarOnceTimed : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "remap time proportional"
|
|
// MDefaultString
|
|
bool m_bProportional; // 0x180
|
|
// MPropertyFriendlyName "input field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldInput; // 0x184
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x188
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x18c
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x190
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x194
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x198
|
|
// MPropertyFriendlyName "remap time"
|
|
// MDefaultString
|
|
float m_flRemapTime; // 0x19c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 32
|
|
struct ParticleChildrenInfo_t
|
|
{
|
|
public:
|
|
// MPropertySuppressField
|
|
// MDefaultString
|
|
CStrongHandle< InfoForResourceTypeIParticleSystemDefinition > m_ChildRef; // 0x0
|
|
// MPropertyFriendlyName "delay"
|
|
// MDefaultString
|
|
float m_flDelay; // 0x8
|
|
// MPropertyFriendlyName "end cap effect"
|
|
// MDefaultString
|
|
bool m_bEndCap; // 0xe
|
|
// MPropertySuppressField
|
|
// MDefaultString
|
|
bool m_bDisableChild; // 0xf
|
|
// MPropertyFriendlyName "disable at detail levels below"
|
|
// MDefaultString
|
|
ParticleDetailLevel_t m_nDetailLevel; // 0x10
|
|
};
|
|
|
|
// Aligment: 11
|
|
// Size: 4336
|
|
class C_INIT_InitialVelocityNoise : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "absolute value"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecAbsVal; // 0x180
|
|
// MPropertyFriendlyName "invert abs value"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecAbsValInv; // 0x18c
|
|
// MPropertyFriendlyName "spatial coordinate offset"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
CPerParticleVecInput m_vecOffsetLoc; // 0x198
|
|
// MPropertyFriendlyName "time coordinate offset"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flOffset; // 0x5c8
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
CPerParticleVecInput m_vecOutputMin; // 0x6b0
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
CPerParticleVecInput m_vecOutputMax; // 0xae0
|
|
// MPropertyFriendlyName "time noise coordinate scale"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flNoiseScale; // 0xf10
|
|
// MPropertyFriendlyName "spatial noise coordinate scale"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flNoiseScaleLoc; // 0xff8
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x10e0
|
|
// MPropertyFriendlyName "apply velocity in local space (0/1)"
|
|
// MDefaultString
|
|
bool m_bLocalSpace; // 0x10e4
|
|
// MPropertyFriendlyName "ignore delta time"
|
|
// MDefaultString
|
|
bool m_bIgnoreDt; // 0x10e5
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 416
|
|
class C_OP_ConstrainDistance : public CParticleFunctionConstraint, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "minimum distance"
|
|
// MDefaultString
|
|
float m_fMinDistance; // 0x180
|
|
// MPropertyFriendlyName "maximum distance"
|
|
// MDefaultString
|
|
float m_fMaxDistance; // 0x184
|
|
// MPropertyFriendlyName "control point number"
|
|
// MDefaultString
|
|
int32_t m_nControlPointNumber; // 0x188
|
|
// MPropertyFriendlyName "distance scale control point (X/Y = Min/Max)"
|
|
// MDefaultString
|
|
int32_t m_nScaleCP; // 0x18c
|
|
// MPropertyFriendlyName "offset of center"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_CenterOffset; // 0x190
|
|
// MPropertyFriendlyName "global center point"
|
|
// MDefaultString
|
|
bool m_bGlobalCenter; // 0x19c
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 544
|
|
class C_INIT_RtEnvCull : public CParticleFunctionInitializer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "test direction"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecTestDir; // 0x180
|
|
// MPropertyFriendlyName "cull normal"
|
|
// MDefaultString
|
|
// MVectorIsCoordinate
|
|
Vector m_vecTestNormal; // 0x18c
|
|
// MPropertyFriendlyName "use velocity for test direction"
|
|
// MDefaultString
|
|
bool m_bUseVelocity; // 0x198
|
|
// MPropertyFriendlyName "cull on miss"
|
|
// MDefaultString
|
|
bool m_bCullOnMiss; // 0x199
|
|
// MPropertyFriendlyName "velocity test adjust lifespan"
|
|
// MDefaultString
|
|
bool m_bLifeAdjust; // 0x19a
|
|
// MPropertyFriendlyName "ray trace environment name"
|
|
// MDefaultString
|
|
char[128] m_RtEnvName; // 0x19b
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 448
|
|
class C_OP_OscillateScalarSimple : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "oscillation rate"
|
|
// MDefaultString
|
|
float m_Rate; // 0x180
|
|
// MPropertyFriendlyName "oscillation frequency"
|
|
// MDefaultString
|
|
float m_Frequency; // 0x184
|
|
// MPropertyFriendlyName "oscillation field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nField; // 0x188
|
|
// MPropertyFriendlyName "oscillation multiplier"
|
|
// MDefaultString
|
|
float m_flOscMult; // 0x18c
|
|
// MPropertyFriendlyName "oscillation start phase"
|
|
// MDefaultString
|
|
float m_flOscAdd; // 0x190
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
struct ParticlePreviewBodyGroup_t
|
|
{
|
|
public:
|
|
CUtlString m_bodyGroupName; // 0x0
|
|
int32_t m_nValue; // 0x8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 624
|
|
class C_OP_PointVectorAtNextParticle : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x180
|
|
// MPropertyFriendlyName "Interpolation"
|
|
// MDefaultString
|
|
CPerParticleFloatInput m_flInterpolation; // 0x188
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 400
|
|
class C_OP_RemapCPVelocityToVector : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "control point"
|
|
// MDefaultString
|
|
int32_t m_nControlPoint; // 0x180
|
|
// MPropertyFriendlyName "output field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
// MPropertyFriendlyName "scale factor"
|
|
// MDefaultString
|
|
float m_flScale; // 0x188
|
|
// MPropertyFriendlyName "normalize"
|
|
// MDefaultString
|
|
bool m_bNormalize; // 0x18c
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 416
|
|
class C_OP_SetControlPointsToParticle : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "group ID to affect"
|
|
// MDefaultString
|
|
int32_t m_nChildGroupID; // 0x180
|
|
// MPropertyFriendlyName "first control point to set"
|
|
// MDefaultString
|
|
int32_t m_nFirstControlPoint; // 0x184
|
|
// MPropertyFriendlyName "# of control points to set"
|
|
// MDefaultString
|
|
int32_t m_nNumControlPoints; // 0x188
|
|
// MPropertyFriendlyName "first particle to copy"
|
|
// MDefaultString
|
|
int32_t m_nFirstSourcePoint; // 0x18c
|
|
// MPropertyFriendlyName "set orientation"
|
|
// MDefaultString
|
|
bool m_bSetOrientation; // 0x190
|
|
};
|
|
|
|
// Aligment: 18
|
|
// Size: 68
|
|
class CParticleVisibilityInputs
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "visibility camera depth bias"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flCameraBias; // 0x0
|
|
// MPropertyFriendlyName "visibility input minimum"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flInputMin; // 0x4
|
|
// MPropertyFriendlyName "visibility input maximum"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flInputMax; // 0x8
|
|
// MPropertyFriendlyName "visibility alpha scale minimum"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flAlphaScaleMin; // 0xc
|
|
// MPropertyFriendlyName "visibility alpha scale maximum"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flAlphaScaleMax; // 0x10
|
|
// MPropertyFriendlyName "visibility radius scale minimum"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flRadiusScaleMin; // 0x14
|
|
// MPropertyFriendlyName "visibility radius scale maximum"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flRadiusScaleMax; // 0x18
|
|
// MPropertyFriendlyName "visibility radius FOV scale base"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flRadiusScaleFOVBase; // 0x1c
|
|
// MPropertyFriendlyName "visibility proxy radius"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flProxyRadius; // 0x20
|
|
// MPropertyFriendlyName "visibility input distance minimum"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flDistanceInputMin; // 0x24
|
|
// MPropertyFriendlyName "visibility input distance maximum"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flDistanceInputMax; // 0x28
|
|
// MPropertyFriendlyName "visibility input dot minimum"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flDotInputMin; // 0x2c
|
|
// MPropertyFriendlyName "visibility input dot maximum"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flDotInputMax; // 0x30
|
|
// MPropertyFriendlyName "Visibility input dot use CP angles"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
bool m_bDotCPAngles; // 0x34
|
|
// MPropertyFriendlyName "Visibility input dot use Camera angles"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
bool m_bDotCameraAngles; // 0x35
|
|
// MPropertyFriendlyName "visibility unsupported hardware fallback value"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
float m_flNoPixelVisibilityFallback; // 0x38
|
|
// MPropertyFriendlyName "visibility proxy input control point number"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
int32_t m_nCPin; // 0x3c
|
|
// MPropertyFriendlyName "visibility vr camera right eye"
|
|
// MDefaultString
|
|
// MParticleAdvancedField
|
|
bool m_bRightEye; // 0x40
|
|
};
|
|
|
|
// Aligment: 12
|
|
// Size: 768
|
|
class C_OP_RenderSound : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "duration scale"
|
|
// MDefaultString
|
|
float m_flDurationScale; // 0x1d0
|
|
// MPropertyFriendlyName "decibel level scale"
|
|
// MDefaultString
|
|
float m_flSndLvlScale; // 0x1d4
|
|
// MPropertyFriendlyName "pitch scale"
|
|
// MDefaultString
|
|
float m_flPitchScale; // 0x1d8
|
|
// MPropertyFriendlyName "volume scale"
|
|
// MDefaultString
|
|
float m_flVolumeScale; // 0x1dc
|
|
// MPropertyFriendlyName "decibel level field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nSndLvlField; // 0x1e0
|
|
// MPropertyFriendlyName "duration field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nDurationField; // 0x1e4
|
|
// MPropertyFriendlyName "pitch field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nPitchField; // 0x1e8
|
|
// MPropertyFriendlyName "volume field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nVolumeField; // 0x1ec
|
|
// MPropertyFriendlyName "sound channel"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "sound_channel"
|
|
int32_t m_nChannel; // 0x1f0
|
|
// MPropertyFriendlyName "sound control point number"
|
|
// MDefaultString
|
|
int32_t m_nCPReference; // 0x1f4
|
|
// MPropertyFriendlyName "sound"
|
|
// MDefaultString
|
|
// MPropertyAttributeEditor "SoundPicker()"
|
|
char[256] m_pszSoundName; // 0x1f8
|
|
// MPropertyFriendlyName "suppress stop event"
|
|
bool m_bSuppressStopSoundEvent; // 0x2f8
|
|
};
|
|
|
|
// Aligment: 37
|
|
// Size: 5600
|
|
class C_OP_RenderRopes : public CBaseRendererSource2, CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "enable fading and clamping"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
bool m_bEnableFadingAndClamping; // 0xca0
|
|
// MPropertyFriendlyName "minimum visual size"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flMinSize; // 0xca4
|
|
// MPropertyFriendlyName "maximum visual size"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flMaxSize; // 0xca8
|
|
// MPropertyFriendlyName "size at which to start fading"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flStartFadeSize; // 0xcac
|
|
// MPropertyFriendlyName "size at which to fade away"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Fading and culling"
|
|
float m_flEndFadeSize; // 0xcb0
|
|
// MPropertyFriendlyName "amount to taper the width of the trail end by"
|
|
// MDefaultString
|
|
float m_flRadiusTaper; // 0xcb4
|
|
// MPropertyFriendlyName "minium number of quads per render segment"
|
|
// MDefaultString
|
|
int32_t m_nMinTesselation; // 0xcb8
|
|
// MPropertyFriendlyName "maximum number of quads per render segment"
|
|
// MDefaultString
|
|
int32_t m_nMaxTesselation; // 0xcbc
|
|
// MPropertyFriendlyName "tesselation resolution scale factor"
|
|
// MDefaultString
|
|
float m_flTessScale; // 0xcc0
|
|
// MPropertyFriendlyName "texture V World Size"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
CParticleCollectionFloatInput m_flTextureVWorldSize; // 0xcc8
|
|
// MPropertyFriendlyName "texture V Scroll Rate"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
CParticleCollectionFloatInput m_flTextureVScrollRate; // 0xdb0
|
|
// MPropertyFriendlyName "texture V Offset"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
CParticleCollectionFloatInput m_flTextureVOffset; // 0xe98
|
|
// MPropertyFriendlyName "texture V Params CP"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
int32_t m_nTextureVParamsCP; // 0xf80
|
|
// MPropertyFriendlyName "horizontal texture scale"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
float m_flFinalTextureScaleU; // 0xf84
|
|
// MPropertyFriendlyName "vertical texture scale"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
float m_flFinalTextureScaleV; // 0xf88
|
|
// MPropertyFriendlyName "horizontal texture offset"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
float m_flFinalTextureOffsetU; // 0xf8c
|
|
// MPropertyFriendlyName "vertical texture offset"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
float m_flFinalTextureOffsetV; // 0xf90
|
|
// MPropertyFriendlyName "Clamp Non-Sheet texture V coords"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
bool m_bClampV; // 0xf94
|
|
// MPropertyFriendlyName "scale CP start"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
int32_t m_nScaleCP1; // 0xf98
|
|
// MPropertyFriendlyName "scale CP end"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
int32_t m_nScaleCP2; // 0xf9c
|
|
// MPropertyFriendlyName "scale V world size by CP distance"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
float m_flScaleVSizeByControlPointDistance; // 0xfa0
|
|
// MPropertyFriendlyName "scale V scroll rate by CP distance"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
float m_flScaleVScrollByControlPointDistance; // 0xfa4
|
|
// MPropertyFriendlyName "scale V offset by CP distance"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
float m_flScaleVOffsetByControlPointDistance; // 0xfa8
|
|
// MPropertyFriendlyName "Use scalar attribute for texture coordinate"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
bool m_bUseScalarForTextureCoordinate; // 0xfad
|
|
// MPropertyFriendlyName "scalar to use for texture coordinate"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
ParticleAttributeIndex_t m_nScalarFieldForTextureCoordinate; // 0xfb0
|
|
// MPropertyFriendlyName "scale value to map attribute to texture coordinate"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Texture Coordinates"
|
|
float m_flScalarAttributeTextureCoordScale; // 0xfb4
|
|
// MPropertyFriendlyName "orientation_type"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceEnumName
|
|
int32_t m_nOrientationType; // 0xfb8
|
|
// MPropertyFriendlyName "attribute to use for normal"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_vector"
|
|
ParticleAttributeIndex_t m_nVectorFieldForOrientation; // 0xfbc
|
|
// MPropertyFriendlyName "draw as opaque"
|
|
// MDefaultString
|
|
bool m_bDrawAsOpaque; // 0xfc0
|
|
// MPropertyFriendlyName "generate normals for cylinder"
|
|
// MDefaultString
|
|
bool m_bGenerateNormals; // 0xfc1
|
|
// MPropertyFriendlyName "reverse point order"
|
|
// MDefaultString
|
|
bool m_bReverseOrder; // 0xfc2
|
|
// MPropertyFriendlyName "radius scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flRadiusScale; // 0xfc8
|
|
// MPropertyFriendlyName "alpha scale"
|
|
// MDefaultString
|
|
CParticleCollectionFloatInput m_flAlphaScale; // 0x10b0
|
|
// MPropertyFriendlyName "color blend"
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecColorScale; // 0x1198
|
|
// MPropertyFriendlyName "color blend type"
|
|
// MDefaultString
|
|
ParticleColorBlendType_t m_nColorBlendType; // 0x15c8
|
|
// MPropertyFriendlyName "Closed loop"
|
|
// MDefaultString
|
|
bool m_bClosedLoop; // 0x15cc
|
|
// MPropertyFriendlyName "depth comparison bias"
|
|
// MDefaultString
|
|
// MPropertyGroupName "Depth buffer control and effects"
|
|
float m_flDepthBias; // 0x15d0
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 400
|
|
class C_OP_FadeOutSimple : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "proportional fade out time"
|
|
// MDefaultString
|
|
float m_flFadeOutTime; // 0x180
|
|
// MPropertyFriendlyName "alpha field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_alpha"
|
|
ParticleAttributeIndex_t m_nFieldOutput; // 0x184
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 384
|
|
class CParticleFunctionPreEmission : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct CollisionGroupContext_t
|
|
{
|
|
public:
|
|
int32_t m_nCollisionGroupNumber; // 0x0
|
|
ParticleCollisionMode_t m_nCollisionModeInternal; // 0x4
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 416
|
|
class C_OP_RemapSpeedtoCP : public CParticleFunctionPreEmission, CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "input control point"
|
|
// MDefaultString
|
|
int32_t m_nInControlPointNumber; // 0x180
|
|
// MPropertyFriendlyName "output control point"
|
|
// MDefaultString
|
|
int32_t m_nOutControlPointNumber; // 0x184
|
|
// MPropertyFriendlyName "Output field 0-2 X/Y/Z"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "vector_component"
|
|
int32_t m_nField; // 0x188
|
|
// MPropertyFriendlyName "input minimum"
|
|
// MDefaultString
|
|
float m_flInputMin; // 0x18c
|
|
// MPropertyFriendlyName "input maximum"
|
|
// MDefaultString
|
|
float m_flInputMax; // 0x190
|
|
// MPropertyFriendlyName "output minimum"
|
|
// MDefaultString
|
|
float m_flOutputMin; // 0x194
|
|
// MPropertyFriendlyName "output maximum"
|
|
// MDefaultString
|
|
float m_flOutputMax; // 0x198
|
|
// MPropertyFriendlyName "use delta of velocity instead of constant speed"
|
|
// MDefaultString
|
|
bool m_bUseDeltaV; // 0x19c
|
|
};
|
|
|
|
// Aligment: 15
|
|
// Size: 1600
|
|
class C_OP_RenderDeferredLight : public CParticleFunctionRenderer, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "projected texture use alpha test window"
|
|
// MDefaultString
|
|
bool m_bUseAlphaTestWindow; // 0x1d0
|
|
// MPropertyFriendlyName "projected texture light"
|
|
// MDefaultString
|
|
bool m_bUseTexture; // 0x1d1
|
|
// MPropertyFriendlyName "radius scale"
|
|
// MDefaultString
|
|
float m_flRadiusScale; // 0x1d4
|
|
// MPropertyFriendlyName "alpha scale"
|
|
// MDefaultString
|
|
float m_flAlphaScale; // 0x1d8
|
|
// MPropertyFriendlyName "spotlight distance"
|
|
// MDefaultString
|
|
float m_flLightDistance; // 0x1dc
|
|
// MPropertyFriendlyName "light start falloff"
|
|
// MDefaultString
|
|
float m_flStartFalloff; // 0x1e0
|
|
// MPropertyFriendlyName "spotlight distance falloff"
|
|
// MDefaultString
|
|
float m_flDistanceFalloff; // 0x1e4
|
|
// MPropertyFriendlyName "spotlight FoV"
|
|
// MDefaultString
|
|
float m_flSpotFoV; // 0x1e8
|
|
// MPropertyFriendlyName "color blend"
|
|
// MDefaultString
|
|
CParticleCollectionVecInput m_vecColorScale; // 0x1f0
|
|
// MPropertyFriendlyName "color blend type"
|
|
// MDefaultString
|
|
ParticleColorBlendType_t m_nColorBlendType; // 0x620
|
|
// MPropertyFriendlyName "projected texture alpha test point scale field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nAlphaTestPointField; // 0x624
|
|
// MPropertyFriendlyName "projected texture alpha test range scale field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nAlphaTestRangeField; // 0x628
|
|
// MPropertyFriendlyName "projected texture alpha test sharpness scale field"
|
|
// MDefaultString
|
|
// MPropertyAttributeChoiceName "particlefield_scalar"
|
|
ParticleAttributeIndex_t m_nAlphaTestSharpnessField; // 0x62c
|
|
// MPropertyFriendlyName "texture"
|
|
// MPropertyAttributeEditor "AssetBrowse( vtex )"
|
|
CStrongHandle< InfoForResourceTypeCTextureBase > m_hTexture; // 0x630
|
|
// MPropertyFriendlyName "HSV Shift Control Point"
|
|
// MDefaultString
|
|
int32_t m_nHSVShiftControlPoint; // 0x638
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 400
|
|
class C_OP_Decay : public CParticleFunctionOperator, CParticleFunction
|
|
{
|
|
public:
|
|
// MPropertyFriendlyName "Reduce rope popping on decay"
|
|
// MDefaultString
|
|
bool m_bRopeDecay; // 0x180
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 136
|
|
class CNavVolumeSphere : public CNavVolume
|
|
{
|
|
public:
|
|
Vector m_vCenter; // 0x78
|
|
float m_flRadius; // 0x84
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 160
|
|
class CNavVolumeAll : public CNavVolumeVector, CNavVolume
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 96
|
|
class CNetworkVelocityVector
|
|
{
|
|
public:
|
|
// MNetworkBitCount "18"
|
|
// MNetworkMinValue "-4096"
|
|
// MNetworkMaxValue "4096"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "CNetworkVelocityVector"
|
|
CNetworkedQuantizedFloat m_vecX; // 0x18
|
|
// MNetworkBitCount "18"
|
|
// MNetworkMinValue "-4096"
|
|
// MNetworkMaxValue "4096"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "CNetworkVelocityVector"
|
|
CNetworkedQuantizedFloat m_vecY; // 0x30
|
|
// MNetworkBitCount "18"
|
|
// MNetworkMinValue "-4096"
|
|
// MNetworkMaxValue "4096"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "CNetworkVelocityVector"
|
|
CNetworkedQuantizedFloat m_vecZ; // 0x48
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 48
|
|
struct CBaseAnimatingEasingFloat_t
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CUtlString m_GraphParameterName; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flGoal; // 0x28
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 36
|
|
struct hudtextparms_t
|
|
{
|
|
public:
|
|
Color color1; // 0x0
|
|
Color color2; // 0x4
|
|
uint8_t effect; // 0x8
|
|
uint8_t channel; // 0x9
|
|
float x; // 0xc
|
|
float y; // 0x10
|
|
float fadeinTime; // 0x14
|
|
float fadeoutTime; // 0x18
|
|
float holdTime; // 0x1c
|
|
float fxTime; // 0x20
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 64
|
|
struct fogplayerparams_t
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "PlayerFogController"
|
|
CHandle< CFogController > m_hCtrl; // 0x8
|
|
float m_flTransitionTime; // 0xc
|
|
Color m_OldColor; // 0x10
|
|
float m_flOldStart; // 0x14
|
|
float m_flOldEnd; // 0x18
|
|
float m_flOldMaxDensity; // 0x1c
|
|
float m_flOldHDRColorScale; // 0x20
|
|
float m_flOldFarZ; // 0x24
|
|
Color m_NewColor; // 0x28
|
|
float m_flNewStart; // 0x2c
|
|
float m_flNewEnd; // 0x30
|
|
float m_flNewMaxDensity; // 0x34
|
|
float m_flNewHDRColorScale; // 0x38
|
|
float m_flNewFarZ; // 0x3c
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 144
|
|
struct sky3dparams_t
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "12"
|
|
int16_t scale; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkEncoder
|
|
Vector origin; // 0xc
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool bClip3DSkyBoxNearToWorldFar; // 0x18
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float flClip3DSkyBoxNearToWorldFarOffset; // 0x1c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
fogparams_t fog; // 0x20
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CUtlStringToken m_nWorldGroupID; // 0x88
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 472
|
|
class CSequenceTransitioner2
|
|
{
|
|
public:
|
|
CNetworkedSequenceOperation m_currentOp; // 0x8
|
|
float m_flCurrentPlaybackRate; // 0x48
|
|
float m_flCurrentAnimTime; // 0x4c
|
|
TransitioningLayer_t[4] m_transitioningLayers; // 0x50
|
|
CBaseAnimatingController* m_pOwner; // 0x1d0
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 192
|
|
class CNavVolumeBreadthFirstSearch : public CNavVolumeCalculatedVector, CNavVolume
|
|
{
|
|
public:
|
|
Vector m_vStartPos; // 0xa8
|
|
float m_flSearchDist; // 0xb4
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 40
|
|
class CJiggleBones
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 80
|
|
class CNetworkedIKContext
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CUtlVector< CNetworkedIKProceduralTargetContext > m_ProceduralTargetContexts; // 0x8
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 160
|
|
class CNavVolumeCalculatedVector : public CNavVolume
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 24
|
|
struct constraint_breakableparams_t
|
|
{
|
|
public:
|
|
float strength; // 0x0
|
|
float forceLimit; // 0x4
|
|
float torqueLimit; // 0x8
|
|
float32[2] bodyMassScale; // 0xc
|
|
bool isActive; // 0x14
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 224
|
|
class CPlayerLocalData
|
|
{
|
|
public:
|
|
// MNetworkDisable
|
|
// MNetworkChangeAccessorFieldPathIndex
|
|
ChangeAccessorFieldPathIndex_t m_NetworkVar_PathIndex; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint8[32] m_chAreaBits; // 0x18
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint8[24] m_chAreaPortalBits; // 0x38
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
sky3dparams_t m_skybox3d; // 0x50
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
struct ParticleIndex_t
|
|
{
|
|
public:
|
|
int32_t m_Data; // 0x0
|
|
};
|
|
|
|
// Aligment: 19
|
|
// Size: 1160
|
|
class CBaseAnimatingController : public CSkeletonAnimationController
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "baseAnimBaseLayerChanged"
|
|
CNetworkedSequenceOperation m_baseLayer; // 0x18
|
|
// MNetworkEnable
|
|
CAnimGraphNetworkedVariables m_animGraphNetworkedVars; // 0x58
|
|
// MNetworkDisable
|
|
bool m_bSequenceFinished; // 0x190
|
|
// MNetworkDisable
|
|
float m_flGroundSpeed; // 0x194
|
|
// MNetworkDisable
|
|
float m_flLastEventCycle; // 0x198
|
|
// MNetworkDisable
|
|
float m_flLastEventAnimTime; // 0x19c
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "8"
|
|
// MNetworkMinValue "-4"
|
|
// MNetworkMaxValue "12"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkPriority "64"
|
|
// MNetworkChangeCallback "playbackRateChanged"
|
|
CNetworkedQuantizedFloat m_flPlaybackRate; // 0x1a0
|
|
// MNetworkDisable
|
|
float m_flPrevAnimTime; // 0x1b8
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "11"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1"
|
|
// MNetworkUserGroup "m_flPoseParameter"
|
|
// MNetworkChangeCallback "poseParametersChanged"
|
|
float32[24] m_flPoseParameter; // 0x1bc
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "clientSideAnimationChanged"
|
|
bool m_bClientSideAnimation; // 0x21c
|
|
// MNetworkDisable
|
|
bool m_bNetworkedAnimationInputsChanged; // 0x21d
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "3"
|
|
// MNetworkPriority "64"
|
|
// MNetworkChangeCallback "clientSideAnimCycleReset"
|
|
int32_t m_nNewSequenceParity; // 0x220
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "3"
|
|
// MNetworkPriority "64"
|
|
int32_t m_nResetEventsParity; // 0x224
|
|
// MNetworkDisable
|
|
float m_flIKGroundContactTime; // 0x228
|
|
// MNetworkDisable
|
|
float m_flIKGroundMinHeight; // 0x22c
|
|
// MNetworkDisable
|
|
float m_flIKGroundMaxHeight; // 0x230
|
|
// MNetworkDisable
|
|
float m_flIkZAdjustAmount; // 0x234
|
|
// MNetworkDisable
|
|
CSequenceTransitioner2 m_SequenceTransitioner; // 0x260
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "overrideAnimGraphChanged"
|
|
CStrongHandle< InfoForResourceTypeIAnimationGraph > m_hOverrideGraph; // 0x470
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 120
|
|
class CNavVolume
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 15
|
|
// Size: 176
|
|
class CAnimationLayer
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "animationLayerOpChanged"
|
|
CNetworkedSequenceOperation m_op; // 0x18
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "animationLayerOrderChanged"
|
|
int32_t m_nOrder; // 0x58
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "8"
|
|
// MNetworkMinValue "-4"
|
|
// MNetworkMaxValue "12"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkSendProxyRecipientsFilter
|
|
CNetworkedQuantizedFloat m_flPlaybackRate; // 0x60
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkSendProxyRecipientsFilter
|
|
bool m_bLooping; // 0x78
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "3"
|
|
// MNetworkPriority "64"
|
|
// MNetworkChangeCallback "animationLayerCycleReset"
|
|
// MNetworkSendProxyRecipientsFilter
|
|
int32_t m_nNewSequenceParity; // 0x7c
|
|
// MNetworkDisable
|
|
int32_t m_nFlags; // 0x80
|
|
// MNetworkDisable
|
|
bool m_bSequenceFinished; // 0x84
|
|
// MNetworkDisable
|
|
float m_flKillRate; // 0x88
|
|
// MNetworkDisable
|
|
float m_flKillDelay; // 0x8c
|
|
// MNetworkDisable
|
|
float m_flLayerAnimtime; // 0x90
|
|
// MNetworkDisable
|
|
float m_flLayerFadeOuttime; // 0x94
|
|
// MNetworkDisable
|
|
int32_t m_nActivity; // 0x98
|
|
// MNetworkDisable
|
|
int32_t m_nPriority; // 0x9c
|
|
// MNetworkDisable
|
|
float m_flLastEventCycle; // 0xa0
|
|
// MNetworkDisable
|
|
float m_flLastAccess; // 0xa4
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 24
|
|
class Extent
|
|
{
|
|
public:
|
|
Vector lo; // 0x0
|
|
Vector hi; // 0xc
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 12
|
|
class CRandSimTimer : public CSimpleSimTimer
|
|
{
|
|
public:
|
|
float m_minInterval; // 0x4
|
|
float m_maxInterval; // 0x8
|
|
};
|
|
|
|
// Aligment: 24
|
|
// Size: 104
|
|
struct fogparams_t
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkEncoder
|
|
Vector dirPrimary; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
Color colorPrimary; // 0x14
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
Color colorSecondary; // 0x18
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
Color colorPrimaryLerpTo; // 0x1c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
Color colorSecondaryLerpTo; // 0x20
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float start; // 0x24
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float end; // 0x28
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
float farz; // 0x2c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float maxdensity; // 0x30
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float exponent; // 0x34
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float HDRColorScale; // 0x38
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
float skyboxFogFactor; // 0x3c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
float skyboxFogFactorLerpTo; // 0x40
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
float startLerpTo; // 0x44
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
float endLerpTo; // 0x48
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
float maxdensityLerpTo; // 0x4c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
float lerptime; // 0x50
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
float duration; // 0x54
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
float blendtobackground; // 0x58
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "FogController"
|
|
float scattering; // 0x5c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool enable; // 0x60
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool blend; // 0x61
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bNoReflectionFog; // 0x62
|
|
bool m_bPadding; // 0x63
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 576
|
|
class CModelState
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "skeletonModelChanged"
|
|
CStrongHandle< InfoForResourceTypeCModel > m_hModel; // 0xa0
|
|
// MNetworkDisable
|
|
CUtlSymbolLarge m_ModelName; // 0xa8
|
|
// MNetworkEnable
|
|
bool m_bClientClothCreationSuppressed; // 0xe8
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "skeletonMeshGroupMaskChanged"
|
|
uint64_t m_MeshGroupMask; // 0x188
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "skeletonMotionTypeChanged"
|
|
int8_t m_nIdealMotionType; // 0x22a
|
|
// MNetworkDisable
|
|
int8_t m_nForceLOD; // 0x22b
|
|
// MNetworkDisable
|
|
bool m_bIsJiggleBonesEnabled; // 0x22c
|
|
// MNetworkDisable
|
|
int8_t m_nClothUpdateFlags; // 0x22d
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 8
|
|
class CSimTimer : public CSimpleSimTimer
|
|
{
|
|
public:
|
|
float m_interval; // 0x4
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 40
|
|
class CCopyRecipientFilter
|
|
{
|
|
public:
|
|
int32_t m_Flags; // 0x8
|
|
CUtlVector< CEntityIndex > m_Recipients; // 0x10
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 40
|
|
struct TonemapParameters_t
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
float m_flAutoExposureMin; // 0x8
|
|
// MNetworkEnable
|
|
float m_flAutoExposureMax; // 0xc
|
|
// MNetworkEnable
|
|
float m_flExposureCompensationScalar; // 0x10
|
|
// MNetworkEnable
|
|
float m_flTonemapPercentTarget; // 0x14
|
|
// MNetworkEnable
|
|
float m_flTonemapPercentBrightPixels; // 0x18
|
|
// MNetworkEnable
|
|
float m_flTonemapMinAvgLum; // 0x1c
|
|
// MNetworkEnable
|
|
float m_flRate; // 0x20
|
|
// MNetworkEnable
|
|
float m_flAccelerateExposureDown; // 0x24
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 96
|
|
class CGlowProperty
|
|
{
|
|
public:
|
|
Vector m_fGlowColor; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "OnGlowTypeChanged"
|
|
int32_t m_iGlowType; // 0x30
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
int32_t m_nGlowRange; // 0x34
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
int32_t m_nGlowRangeMin; // 0x38
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "OnGlowColorChanged"
|
|
Vector m_glowColorOverride; // 0x3c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bFlashing; // 0x48
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_hMaterial; // 0x50
|
|
bool m_bGlowing; // 0x58
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 144
|
|
class CSoundPatch
|
|
{
|
|
public:
|
|
CSoundEnvelope m_pitch; // 0x8
|
|
CSoundEnvelope m_volume; // 0x18
|
|
float m_shutdownTime; // 0x30
|
|
float m_flLastTime; // 0x34
|
|
CUtlSymbolLarge m_iszSoundScriptName; // 0x38
|
|
CHandle< CBaseEntity > m_hEnt; // 0x40
|
|
CEntityIndex m_soundEntityIndex; // 0x44
|
|
Vector m_soundOrigin; // 0x48
|
|
int32_t m_isPlaying; // 0x54
|
|
CCopyRecipientFilter m_Filter; // 0x58
|
|
float m_flCloseCaptionDuration; // 0x80
|
|
bool m_bUpdatedSoundOrigin; // 0x84
|
|
CUtlSymbolLarge m_iszClassName; // 0x88
|
|
public:
|
|
static int32_t &Get_g_SoundPatchCount() { return *reinterpret_cast<int32_t*>(interfaces::g_schema->FindTypeScopeForModule("!GlobalTypes")->FindDeclaredClass("CSoundPatch")->m_static_fiels[0]->m_instance); }
|
|
};
|
|
|
|
// Aligment: 8
|
|
// Size: 64
|
|
class CNetworkedSequenceOperation
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "13"
|
|
// MNetworkSerializer "minusone"
|
|
// MNetworkChangeCallback "sequenceOpSequenceChanged"
|
|
// MNetworkPriority "64"
|
|
HSequence m_hSequence; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "15"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkPriority "64"
|
|
// MNetworkSendProxyRecipientsFilter
|
|
// MNetworkUserGroup "m_flCycle"
|
|
float m_flPrevCycle; // 0xc
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "15"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkPriority "64"
|
|
// MNetworkSendProxyRecipientsFilter
|
|
// MNetworkUserGroup "m_flCycle"
|
|
// MNetworkChangeCallback "sequenceOpCycleChanged"
|
|
float m_flCycle; // 0x10
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "8"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1"
|
|
// MNetworkEncodeFlags
|
|
CNetworkedQuantizedFloat m_flWeight; // 0x18
|
|
// MNetworkDisable
|
|
bool m_bSequenceChangeNetworked; // 0x30
|
|
// MNetworkDisable
|
|
bool m_bDiscontinuity; // 0x31
|
|
// MNetworkDisable
|
|
float m_flPrevCycleFromDiscontinuity; // 0x34
|
|
// MNetworkDisable
|
|
float m_flPrevCycleForAnimEventDetection; // 0x38
|
|
};
|
|
|
|
// Aligment: 16
|
|
// Size: 96
|
|
class CSceneEventInfo
|
|
{
|
|
public:
|
|
bool m_bStarted; // 0x1c
|
|
int32_t m_iLayer; // 0x20
|
|
int32_t m_iPriority; // 0x24
|
|
HSequence m_hSequence; // 0x28
|
|
bool m_bIsGesture; // 0x2c
|
|
float m_flWeight; // 0x30
|
|
CHandle< CBaseEntity > m_hTarget; // 0x34
|
|
bool m_bIsMoving; // 0x38
|
|
bool m_bHasArrived; // 0x39
|
|
float m_flInitialYaw; // 0x3c
|
|
float m_flTargetYaw; // 0x40
|
|
float m_flFacingYaw; // 0x44
|
|
int32_t m_nType; // 0x48
|
|
float m_flNext; // 0x4c
|
|
bool m_bClientSide; // 0x50
|
|
bool m_bShouldRemove; // 0x51
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 1240
|
|
class CBaseAnimatingOverlayController : public CBaseAnimatingController, CSkeletonAnimationController
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "overlay_vars"
|
|
// MNetworkChangeCallback "OnOverlaysChanged2"
|
|
CUtlVector< CAnimationLayer > m_AnimOverlay; // 0x488
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 24
|
|
struct thinkfunc_t
|
|
{
|
|
public:
|
|
CUtlStringToken m_nContext; // 0x8
|
|
int32_t m_nNextThinkTick; // 0xc
|
|
int32_t m_nLastThinkTick; // 0x10
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 1088
|
|
class CSkeletonInstance : public CGameSceneNode
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
CModelState m_modelState; // 0x100
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "skeletonRenderingEnableChanged"
|
|
bool m_bIsRenderingEnabled; // 0x340
|
|
// MNetworkEnable
|
|
bool m_bIsAnimationEnabled; // 0x341
|
|
// MNetworkEnable
|
|
bool m_bUseParentRenderBounds; // 0x342
|
|
// MNetworkDisable
|
|
bool m_bEnableIK; // 0x343
|
|
// MNetworkDisable
|
|
bitfield:1 m_bDisableSolidCollisionsForHierarchy; // 0x0
|
|
// MNetworkDisable
|
|
bitfield:1 m_bDirtyMotionType; // 0x0
|
|
// MNetworkDisable
|
|
bitfield:1 m_bIsGeneratingLatchedParentSpaceState; // 0x0
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "skeletonMaterialGroupChanged"
|
|
CUtlStringToken m_materialGroup; // 0x348
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "2"
|
|
uint8_t m_nHitboxSet; // 0x34c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flIkMasterBlendValueCache; // 0x398
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "skeletonRagdollPositionChanged"
|
|
CUtlVector< CTransform > m_RagdollTransforms; // 0x3f0
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "skeletonRagdollPositionChanged"
|
|
CUtlVector< CTransform > m_BoneOverrides; // 0x408
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CUtlVector< float32 > m_FlexOverrides; // 0x420
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 8
|
|
class CGameRules
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 96
|
|
class CNetworkOriginQuantizedVector
|
|
{
|
|
public:
|
|
// MNetworkBitCount "19"
|
|
// MNetworkMinValue "-16384"
|
|
// MNetworkMaxValue "16384"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "CNetworkOriginQuantizedVector"
|
|
CNetworkedQuantizedFloat m_vecX; // 0x18
|
|
// MNetworkBitCount "19"
|
|
// MNetworkMinValue "-16384"
|
|
// MNetworkMaxValue "16384"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "CNetworkOriginQuantizedVector"
|
|
CNetworkedQuantizedFloat m_vecY; // 0x30
|
|
// MNetworkBitCount "19"
|
|
// MNetworkMinValue "-16384"
|
|
// MNetworkMaxValue "16384"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "CNetworkOriginQuantizedVector"
|
|
CNetworkedQuantizedFloat m_vecZ; // 0x48
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
class CountdownTimer
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_duration; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_timestamp; // 0xc
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 104
|
|
class CNetworkOriginCellCoordQuantizedVector
|
|
{
|
|
public:
|
|
// MNetworkBitCount "10"
|
|
// MNetworkChangeCallback "OnCellChanged"
|
|
// MNetworkPriority "32"
|
|
// MNetworkSerializer "cellx"
|
|
uint16_t m_cellX; // 0x18
|
|
// MNetworkBitCount "10"
|
|
// MNetworkChangeCallback "OnCellChanged"
|
|
// MNetworkPriority "32"
|
|
// MNetworkSerializer "celly"
|
|
uint16_t m_cellY; // 0x1a
|
|
// MNetworkBitCount "10"
|
|
// MNetworkChangeCallback "OnCellChanged"
|
|
// MNetworkPriority "32"
|
|
// MNetworkSerializer "cellz"
|
|
uint16_t m_cellZ; // 0x1c
|
|
// MNetworkBitCount "3"
|
|
uint16_t m_nOutsideWorld; // 0x1e
|
|
// MNetworkBitCount "15"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1024"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "OnCellChanged"
|
|
// MNetworkPriority "32"
|
|
// MNetworkSerializer "posx"
|
|
CNetworkedQuantizedFloat m_vecX; // 0x20
|
|
// MNetworkBitCount "15"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1024"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "OnCellChanged"
|
|
// MNetworkPriority "32"
|
|
// MNetworkSerializer "posy"
|
|
CNetworkedQuantizedFloat m_vecY; // 0x38
|
|
// MNetworkBitCount "15"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1024"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "OnCellChanged"
|
|
// MNetworkPriority "32"
|
|
// MNetworkSerializer "posz"
|
|
CNetworkedQuantizedFloat m_vecZ; // 0x50
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 56
|
|
struct CBaseAnimatingEasings_t
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CBaseAnimatingEasingFloat_t m_IKMasterBlendAmountEasing; // 0x8
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 40
|
|
class CSequenceTransitioner
|
|
{
|
|
public:
|
|
CUtlVector< CAnimationLayer > m_animationQueue; // 0x0
|
|
bool m_bIsInSimulation; // 0x18
|
|
float m_flSimOrRenderTime; // 0x1c
|
|
float m_flInterpolatedTime; // 0x20
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
class IntervalTimer
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_timestamp; // 0x8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct CEnvWindShared::WindAveEvent_t
|
|
{
|
|
public:
|
|
float m_flStartWindSpeed; // 0x0
|
|
float m_flAveWindSpeed; // 0x4
|
|
};
|
|
|
|
// Aligment: 6
|
|
// Size: 48
|
|
class CPlayerState
|
|
{
|
|
public:
|
|
bool deadflag; // 0x8
|
|
CUtlSymbolLarge netname; // 0x10
|
|
int32_t fixangle; // 0x18
|
|
QAngle anglechange; // 0x1c
|
|
int32_t frags; // 0x28
|
|
int32_t deaths; // 0x2c
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 24
|
|
class CRandStopwatch : public CStopwatchBase, CSimpleSimTimer
|
|
{
|
|
public:
|
|
float m_minInterval; // 0x10
|
|
float m_maxInterval; // 0x14
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 48
|
|
class DataTable
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CUtlVector< uint32 > m_EntityTags; // 0x10
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bPredictable; // 0x28
|
|
};
|
|
|
|
// Aligment: 31
|
|
// Size: 240
|
|
class CGameSceneNode
|
|
{
|
|
public:
|
|
// MNetworkDisable
|
|
CTransform m_nodeToWorld; // 0x10
|
|
// MNetworkDisable
|
|
CEntityInstance* m_pOwner; // 0x30
|
|
// MNetworkDisable
|
|
CGameSceneNode* m_pParent; // 0x38
|
|
// MNetworkDisable
|
|
CGameSceneNode* m_pChild; // 0x40
|
|
// MNetworkDisable
|
|
CGameSceneNode* m_pNextSibling; // 0x48
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkSerializer "gameSceneNode"
|
|
// MNetworkChangeCallback "gameSceneNodeHierarchyParentChanged"
|
|
// MNetworkPriority "64"
|
|
// MNetworkVarEmbeddedFieldOffsetDelta "8"
|
|
CGameSceneNodeHandle m_hParent; // 0x68
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "32"
|
|
// MNetworkPriority "64"
|
|
// MNetworkUserGroup "Origin"
|
|
// MNetworkChangeCallback "gameSceneNodeLocalOriginChanged"
|
|
Vector m_vecOrigin; // 0x78
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkEncoder
|
|
// MNetworkBitCount "32"
|
|
// MNetworkPriority "64"
|
|
// MNetworkChangeCallback "gameSceneNodeLocalAnglesChanged"
|
|
QAngle m_angRotation; // 0x84
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "gameSceneNodeLocalScaleChanged"
|
|
// MNetworkPriority "64"
|
|
float m_flScale; // 0x90
|
|
// MNetworkDisable
|
|
Vector m_vecAbsOrigin; // 0x94
|
|
// MNetworkDisable
|
|
QAngle m_angAbsRotation; // 0xa0
|
|
// MNetworkDisable
|
|
float m_flAbsScale; // 0xac
|
|
// MNetworkDisable
|
|
int16_t m_nParentAttachmentOrBone; // 0xb0
|
|
// MNetworkDisable
|
|
bool m_bDebugAbsOriginChanges; // 0xb2
|
|
// MNetworkDisable
|
|
bool m_bDormant; // 0xb3
|
|
// MNetworkDisable
|
|
bool m_bForceParentToBeNetworked; // 0xb4
|
|
// MNetworkDisable
|
|
bitfield:1 m_bDirtyHierarchy; // 0x0
|
|
// MNetworkDisable
|
|
bitfield:1 m_bNetworkedPositionChanged; // 0x0
|
|
// MNetworkDisable
|
|
bitfield:1 m_bNetworkedAnglesChanged; // 0x0
|
|
// MNetworkDisable
|
|
bitfield:1 m_bNetworkedScaleChanged; // 0x0
|
|
// MNetworkDisable
|
|
bitfield:1 m_bWillBeCallingPostDataUpdate; // 0x0
|
|
// MNetworkDisable
|
|
bitfield:1 m_bNotifyBoneTransformsChanged; // 0x0
|
|
// MNetworkDisable
|
|
bitfield:2 m_nLatchAbsOrigin; // 0x0
|
|
// MNetworkDisable
|
|
bitfield:1 m_bDirtyBoneMergeBoneToRoot; // 0x0
|
|
// MNetworkDisable
|
|
uint8_t m_nHierarchicalDepth; // 0xb7
|
|
// MNetworkDisable
|
|
uint8_t m_nHierarchyType; // 0xb8
|
|
// MNetworkDisable
|
|
uint8_t m_nDoNotSetAnimTimeInInvalidatePhysicsCount; // 0xb9
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CUtlStringToken m_name; // 0xbc
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "gameSceneNodeHierarchyAttachmentChanged"
|
|
CUtlStringToken m_hierarchyAttachName; // 0xd8
|
|
// MNetworkDisable
|
|
float m_flZOffset; // 0xdc
|
|
// MNetworkDisable
|
|
Vector m_vRenderOrigin; // 0xe0
|
|
};
|
|
|
|
// Aligment: 31
|
|
// Size: 656
|
|
class CEnvWindShared
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flStartTime; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint32_t m_iWindSeed; // 0xc
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "10"
|
|
uint16_t m_iMinWind; // 0x10
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "10"
|
|
uint16_t m_iMaxWind; // 0x12
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "14"
|
|
int32_t m_windRadius; // 0x14
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "10"
|
|
uint16_t m_iMinGust; // 0x18
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "10"
|
|
uint16_t m_iMaxGust; // 0x1a
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flMinGustDelay; // 0x1c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flMaxGustDelay; // 0x20
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flGustDuration; // 0x24
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "9"
|
|
uint16_t m_iGustDirChange; // 0x28
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkEncoder
|
|
Vector m_location; // 0x2c
|
|
int32_t m_iszGustSound; // 0x38
|
|
int32_t m_iWindDir; // 0x3c
|
|
float m_flWindSpeed; // 0x40
|
|
Vector m_currentWindVector; // 0x44
|
|
Vector m_CurrentSwayVector; // 0x50
|
|
Vector m_PrevSwayVector; // 0x5c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "9"
|
|
uint16_t m_iInitialWindDir; // 0x68
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flInitialWindSpeed; // 0x6c
|
|
CEntityIOOutput m_OnGustStart; // 0x70
|
|
CEntityIOOutput m_OnGustEnd; // 0x98
|
|
float m_flVariationTime; // 0xc0
|
|
float m_flSwayTime; // 0xc4
|
|
float m_flSimTime; // 0xc8
|
|
float m_flSwitchTime; // 0xcc
|
|
float m_flAveWindSpeed; // 0xd0
|
|
bool m_bGusting; // 0xd4
|
|
float m_flWindAngleVariation; // 0xd8
|
|
float m_flWindSpeedVariation; // 0xdc
|
|
CEntityIndex m_iEntIndex; // 0xe0
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 1
|
|
class CPhysicsComponent
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 320
|
|
class CNetworkTransmitComponent
|
|
{
|
|
public:
|
|
uint8_t m_nTransmitStateOwnedCounter; // 0x12c
|
|
public:
|
|
static int32_t &Get_s_nWatchTransmitEntity() { return *reinterpret_cast<int32_t*>(interfaces::g_schema->FindTypeScopeForModule("!GlobalTypes")->FindDeclaredClass("CNetworkTransmitComponent")->m_static_fiels[0]->m_instance); }
|
|
static bool &Get_s_bUseNetworkVars() { return *reinterpret_cast<bool*>(interfaces::g_schema->FindTypeScopeForModule("!GlobalTypes")->FindDeclaredClass("CNetworkTransmitComponent")->m_static_fiels[1]->m_instance); }
|
|
static bool &Get_s_bNetworkVarPerFieldTracking() { return *reinterpret_cast<bool*>(interfaces::g_schema->FindTypeScopeForModule("!GlobalTypes")->FindDeclaredClass("CNetworkTransmitComponent")->m_static_fiels[2]->m_instance); }
|
|
static bool &Get_s_bNetworkVarValidate() { return *reinterpret_cast<bool*>(interfaces::g_schema->FindTypeScopeForModule("!GlobalTypes")->FindDeclaredClass("CNetworkTransmitComponent")->m_static_fiels[3]->m_instance); }
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 16
|
|
class CGameSceneNodeHandle
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
CEntityHandle m_hOwner; // 0x8
|
|
// MNetworkEnable
|
|
CUtlStringToken m_name; // 0xc
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 160
|
|
class CNavVolumeVector : public CNavVolume
|
|
{
|
|
public:
|
|
bool m_bHasBeenPreFiltered; // 0x80
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
class CStopwatchBase : public CSimpleSimTimer
|
|
{
|
|
public:
|
|
bool m_fIsRunning; // 0xc
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 16
|
|
class CSoundEnvelope
|
|
{
|
|
public:
|
|
float m_current; // 0x0
|
|
float m_target; // 0x4
|
|
float m_rate; // 0x8
|
|
bool m_forceupdate; // 0xc
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 96
|
|
class JiggleData
|
|
{
|
|
public:
|
|
int32_t bone; // 0x0
|
|
int32_t id; // 0x4
|
|
float lastUpdate; // 0x8
|
|
Vector basePos; // 0xc
|
|
Vector baseLastPos; // 0x18
|
|
Vector baseVel; // 0x24
|
|
Vector baseAccel; // 0x30
|
|
Vector tipPos; // 0x3c
|
|
Vector tipVel; // 0x48
|
|
Vector tipAccel; // 0x54
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 96
|
|
struct TransitioningLayer_t
|
|
{
|
|
public:
|
|
CNetworkedSequenceOperation m_op; // 0x8
|
|
float m_flStartAnimTime; // 0x48
|
|
float m_flStartWeight; // 0x4c
|
|
float m_flAnimTime; // 0x50
|
|
int32_t m_nOrder; // 0x54
|
|
float m_flPlaybackRate; // 0x58
|
|
float m_flFadeOutDuration; // 0x5c
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct CEnvWindShared::WindVariationEvent_t
|
|
{
|
|
public:
|
|
float m_flWindAngleVariation; // 0x0
|
|
float m_flWindSpeedVariation; // 0x4
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 24
|
|
class CStopwatch : public CStopwatchBase, CSimpleSimTimer
|
|
{
|
|
public:
|
|
float m_interval; // 0x10
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 48
|
|
class NetField
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "OnDataBlockChanged"
|
|
CUtlBinaryBlock ByteData; // 0x10
|
|
bool Dirty; // 0x28
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 224
|
|
class CNavVolumeMarkupVolume : public CNavVolume
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
class CSkeletonAnimationController
|
|
{
|
|
public:
|
|
// MNetworkDisable
|
|
CSkeletonInstance* m_pSkeletonInstance; // 0x8
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 32
|
|
class CSBox_Gamerules : public CGameRules
|
|
{
|
|
public:
|
|
// MNetworkDisable
|
|
// MNetworkChangeAccessorFieldPathIndex
|
|
CNetworkVarChainer __m_pChainEntity; // 0x8
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 144
|
|
class CNavVolumeSphericalShell : public CNavVolumeSphere, CNavVolume
|
|
{
|
|
public:
|
|
float m_flRadiusInner; // 0x88
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 24
|
|
struct ResponseContext_t
|
|
{
|
|
public:
|
|
CUtlSymbolLarge m_iszName; // 0x0
|
|
CUtlSymbolLarge m_iszValue; // 0x8
|
|
float m_fExpirationTime; // 0x10
|
|
};
|
|
|
|
// Aligment: 20
|
|
// Size: 112
|
|
class CEffectData
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkEncoder
|
|
Vector m_vOrigin; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkEncoder
|
|
Vector m_vStart; // 0x14
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkEncoder
|
|
Vector m_vNormal; // 0x20
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkEncoder
|
|
QAngle m_vAngles; // 0x2c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CEntityHandle m_hEntity; // 0x38
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CEntityHandle m_hOtherEntity; // 0x3c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flScale; // 0x40
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "12"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1023"
|
|
// MNetworkEncodeFlags
|
|
float m_flMagnitude; // 0x44
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "10"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1023"
|
|
// MNetworkEncodeFlags
|
|
float m_flRadius; // 0x48
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CUtlStringToken m_nSurfaceProp; // 0x4c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CWeakHandle< InfoForResourceTypeIParticleSystemDefinition > m_nEffectIndex; // 0x50
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint32_t m_nDamageType; // 0x58
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint16_t m_nMaterial; // 0x5c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint16_t m_nHitBox; // 0x5e
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint8_t m_nColor; // 0x60
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint8_t m_fFlags; // 0x61
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
AttachmentHandle_t m_nAttachmentIndex; // 0x62
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CUtlStringToken m_nAttachmentName; // 0x64
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint16_t m_iEffectName; // 0x68
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint8_t m_nExplosionType; // 0x6a
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 96
|
|
class CNetworkViewOffsetVector
|
|
{
|
|
public:
|
|
// MNetworkBitCount "10"
|
|
// MNetworkMinValue "-64"
|
|
// MNetworkMaxValue "64"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "CNetworkViewOffsetVector"
|
|
CNetworkedQuantizedFloat m_vecX; // 0x18
|
|
// MNetworkBitCount "10"
|
|
// MNetworkMinValue "-64"
|
|
// MNetworkMaxValue "64"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "CNetworkViewOffsetVector"
|
|
CNetworkedQuantizedFloat m_vecY; // 0x30
|
|
// MNetworkBitCount "20"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "128"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkChangeCallback "CNetworkViewOffsetVector"
|
|
CNetworkedQuantizedFloat m_vecZ; // 0x48
|
|
};
|
|
|
|
// Aligment: 21
|
|
// Size: 240
|
|
struct handposepair_t
|
|
{
|
|
public:
|
|
matrix3x4_t[2] m_matHandOffset; // 0x0
|
|
Vector[2] m_vMaxExtentOrigin; // 0x60
|
|
Vector[2] m_vMinExtentOrigin; // 0x78
|
|
Vector[2] m_vRotationAxisEndpoints; // 0x90
|
|
float32[5] m_flHandPoseParams; // 0xa8
|
|
CUtlSymbolLarge m_poseSequenceName; // 0xc0
|
|
int32_t m_nUseRange; // 0xc8
|
|
int32_t m_iBone; // 0xcc
|
|
float m_flUseAnglesRange; // 0xd0
|
|
float m_flPivotMin; // 0xd4
|
|
float m_flPivotMax; // 0xd8
|
|
float m_flRotateMin; // 0xdc
|
|
float m_flRotateMax; // 0xe0
|
|
bool m_bHasExtent; // 0xe4
|
|
bool m_bHasRotation; // 0xe5
|
|
bool m_bAllowFlip; // 0xe6
|
|
bool m_bConformFingers; // 0xe7
|
|
bool m_bSqueezable; // 0xe8
|
|
bool m_bSqueezeTarget; // 0xe9
|
|
bool m_bGlobal; // 0xea
|
|
bool m_bHandPoseEntityData; // 0xeb
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct ClusteredDistributionParams_t
|
|
{
|
|
public:
|
|
float m_flClusterCoverageFraction; // 0x0
|
|
float m_flClusterArea; // 0x4
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 64
|
|
struct constraint_hingeparams_t
|
|
{
|
|
public:
|
|
Vector worldPosition; // 0x0
|
|
Vector worldAxisDirection; // 0xc
|
|
constraint_axislimit_t hingeAxis; // 0x18
|
|
constraint_breakableparams_t constraint; // 0x28
|
|
};
|
|
|
|
// Aligment: 7
|
|
// Size: 616
|
|
class CTimeline : public IntervalTimer
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float32[64] m_flValues; // 0x10
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
int32[64] m_nValueCounts; // 0x110
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
int32_t m_nBucketCount; // 0x210
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flInterval; // 0x214
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flFinalValue; // 0x218
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
TimelineCompression_t m_nCompressionType; // 0x21c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bStopped; // 0x220
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 16
|
|
struct constraint_axislimit_t
|
|
{
|
|
public:
|
|
float flMinRotation; // 0x0
|
|
float flMaxRotation; // 0x4
|
|
float flMotorTargetAngSpeed; // 0x8
|
|
float flMotorMaxTorque; // 0xc
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 4
|
|
class CSimpleSimTimer
|
|
{
|
|
public:
|
|
float m_next; // 0x0
|
|
};
|
|
|
|
// Aligment: 16
|
|
// Size: 216
|
|
class CCollisionProperty
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "OnUpdateOBB"
|
|
Vector m_vecMins; // 0x10
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "OnUpdateOBB"
|
|
Vector m_vecMaxs; // 0x1c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "2"
|
|
// MNetworkChangeCallback "OnUpdateSolidFlags"
|
|
uint8_t m_usSolidFlags; // 0x28
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "OnUpdateSolidType"
|
|
SolidType_t m_nSolidType; // 0x29
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "MarkSurroundingBoundsDirty"
|
|
uint8_t m_triggerBloat; // 0x2a
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "MarkSurroundingBoundsDirty"
|
|
SurroundingBoundsType_t m_nSurroundType; // 0x2b
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bHitboxEnabled; // 0x2c
|
|
float m_flRadius; // 0x30
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "MarkSurroundingBoundsDirty"
|
|
Vector m_vecSpecifiedSurroundingMins; // 0x34
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "MarkSurroundingBoundsDirty"
|
|
Vector m_vecSpecifiedSurroundingMaxs; // 0x40
|
|
Vector m_vecSurroundingMaxs; // 0x4c
|
|
Vector m_vecSurroundingMins; // 0x58
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
Vector m_vCapsuleCenter1; // 0x64
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
Vector m_vCapsuleCenter2; // 0x70
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flCapsuleRadius; // 0x7c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "CollisionAttributeChanged"
|
|
uint8_t m_nCollisionFunctionMask; // 0x80
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 2
|
|
struct ChangeAccessorFieldPathIndex_t
|
|
{
|
|
public:
|
|
int16_t m_Value; // 0x0
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 8
|
|
class IClientAlphaProperty
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 13
|
|
// Size: 48
|
|
class CClientAlphaProperty : public IClientAlphaProperty
|
|
{
|
|
public:
|
|
uint8_t m_nRenderFX; // 0x10
|
|
uint8_t m_nRenderMode; // 0x11
|
|
bitfield:1 m_bAlphaOverride; // 0x0
|
|
bitfield:1 m_bShadowAlphaOverride; // 0x0
|
|
bitfield:6 m_nReserved; // 0x0
|
|
uint8_t m_nAlpha; // 0x13
|
|
uint16_t m_nDesyncOffset; // 0x14
|
|
uint16_t m_nReserved2; // 0x16
|
|
uint16_t m_nDistFadeStart; // 0x18
|
|
uint16_t m_nDistFadeEnd; // 0x1a
|
|
float m_flFadeScale; // 0x1c
|
|
float m_flRenderFxStartTime; // 0x20
|
|
float m_flRenderFxDuration; // 0x24
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 16
|
|
class C_PlayerState
|
|
{
|
|
public:
|
|
bool deadflag; // 0x8
|
|
};
|
|
|
|
// Aligment: 3
|
|
// Size: 32
|
|
class CViewAngleKeyFrame
|
|
{
|
|
public:
|
|
QAngle m_vecAngles; // 0x8
|
|
float m_flTime; // 0x14
|
|
int32_t m_iFlags; // 0x18
|
|
};
|
|
|
|
// Aligment: 14
|
|
// Size: 64
|
|
struct C_fogplayerparams_t
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "PlayerFogController"
|
|
CHandle< C_FogController > m_hCtrl; // 0x8
|
|
float m_flTransitionTime; // 0xc
|
|
Color m_OldColor; // 0x10
|
|
float m_flOldStart; // 0x14
|
|
float m_flOldEnd; // 0x18
|
|
float m_flOldMaxDensity; // 0x1c
|
|
float m_flOldHDRColorScale; // 0x20
|
|
float m_flOldFarZ; // 0x24
|
|
Color m_NewColor; // 0x28
|
|
float m_flNewStart; // 0x2c
|
|
float m_flNewEnd; // 0x30
|
|
float m_flNewMaxDensity; // 0x34
|
|
float m_flNewHDRColorScale; // 0x38
|
|
float m_flNewFarZ; // 0x3c
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 3824
|
|
class C_BaseAnimatingOverlayController : public C_BaseAnimatingController, CSkeletonAnimationController
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkUserGroup "overlay_vars"
|
|
// MNetworkChangeCallback "OnOverlaysChanged2"
|
|
CUtlVector< CAnimationLayer > m_AnimOverlay; // 0xe88
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 1584
|
|
class C_CommandContext
|
|
{
|
|
public:
|
|
bool needsprocessing; // 0x0
|
|
int32_t command_number; // 0x628
|
|
};
|
|
|
|
// Aligment: 30
|
|
// Size: 488
|
|
class CProjectedTextureBase
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
CHandle< C_BaseEntity > m_hTargetEntity; // 0xc
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bState; // 0x10
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bAlwaysUpdate; // 0x11
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flLightFOV; // 0x14
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bEnableShadows; // 0x18
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bSimpleProjection; // 0x19
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bLightOnlyTarget; // 0x1a
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bLightWorld; // 0x1b
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bCameraSpace; // 0x1c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flBrightnessScale; // 0x20
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
Color m_LightColor; // 0x24
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flIntensity; // 0x28
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flLinearAttenuation; // 0x2c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flQuadraticAttenuation; // 0x30
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bVolumetric; // 0x34
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flVolumetricIntensity; // 0x38
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flNoiseStrength; // 0x3c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flFlashlightTime; // 0x40
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint32_t m_nNumPlanes; // 0x44
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flPlaneOffset; // 0x48
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flColorTransitionTime; // 0x4c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flAmbient; // 0x50
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
char[260] m_SpotlightTextureName; // 0x54
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
int32_t m_nSpotlightTextureFrame; // 0x158
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "1"
|
|
uint32_t m_nShadowQuality; // 0x15c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "16"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "500"
|
|
// MNetworkEncodeFlags
|
|
float m_flNearZ; // 0x160
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "18"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1500"
|
|
// MNetworkEncodeFlags
|
|
float m_flFarZ; // 0x164
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flProjectionSize; // 0x168
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flRotation; // 0x16c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
bool m_bFlipHorizontal; // 0x170
|
|
public:
|
|
static float &Get_m_flVisibleBBoxMinHeight() { return *reinterpret_cast<float*>(interfaces::g_schema->FindTypeScopeForModule("!GlobalTypes")->FindDeclaredClass("CProjectedTextureBase")->m_static_fiels[0]->m_instance); }
|
|
};
|
|
|
|
// Aligment: 0
|
|
// Size: 8
|
|
class C_GameRules
|
|
{
|
|
public:
|
|
// <no members described>
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 32
|
|
class C_SBox_Gamerules : public C_GameRules
|
|
{
|
|
public:
|
|
// MNetworkDisable
|
|
// MNetworkChangeAccessorFieldPathIndex
|
|
CNetworkVarChainer __m_pChainEntity; // 0x8
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 32
|
|
class CGlowSprite
|
|
{
|
|
public:
|
|
Vector m_vColor; // 0x0
|
|
float m_flHorzSize; // 0xc
|
|
float m_flVertSize; // 0x10
|
|
CStrongHandle< InfoForResourceTypeIMaterial2 > m_hMaterial; // 0x18
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
class TimedEvent
|
|
{
|
|
public:
|
|
float m_TimeBetweenEvents; // 0x0
|
|
float m_fNextEvent; // 0x4
|
|
};
|
|
|
|
// Aligment: 5
|
|
// Size: 568
|
|
class C_CSequenceTransitioner2
|
|
{
|
|
public:
|
|
CNetworkedSequenceOperation m_currentOp; // 0x8
|
|
float m_flCurrentPlaybackRate; // 0x48
|
|
float m_flCurrentAnimTime; // 0x4c
|
|
TransitioningLayer_t[4] m_transitioningLayers; // 0x50
|
|
C_BaseAnimatingController* m_pOwner; // 0x1d0
|
|
};
|
|
|
|
// Aligment: 23
|
|
// Size: 3720
|
|
class C_BaseAnimatingController : public CSkeletonAnimationController
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "baseAnimBaseLayerChanged"
|
|
CNetworkedSequenceOperation m_baseLayer; // 0x18
|
|
// MNetworkEnable
|
|
CAnimGraphNetworkedVariables m_animGraphNetworkedVars; // 0x58
|
|
// MNetworkDisable
|
|
bool m_bSequenceFinished; // 0xa78
|
|
// MNetworkDisable
|
|
float m_flGroundSpeed; // 0xa7c
|
|
// MNetworkDisable
|
|
float m_flLastEventCycle; // 0xa80
|
|
// MNetworkDisable
|
|
float m_flLastEventAnimTime; // 0xa84
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "8"
|
|
// MNetworkMinValue "-4"
|
|
// MNetworkMaxValue "12"
|
|
// MNetworkEncodeFlags
|
|
// MNetworkPriority "64"
|
|
// MNetworkChangeCallback "playbackRateChanged"
|
|
CNetworkedQuantizedFloat m_flPlaybackRate; // 0xa88
|
|
// MNetworkDisable
|
|
float m_flPrevAnimTime; // 0xaa0
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "11"
|
|
// MNetworkMinValue "0"
|
|
// MNetworkMaxValue "1"
|
|
// MNetworkUserGroup "m_flPoseParameter"
|
|
// MNetworkChangeCallback "poseParametersChanged"
|
|
float32[24] m_flPoseParameter; // 0xaa4
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "clientSideAnimationChanged"
|
|
bool m_bClientSideAnimation; // 0xb04
|
|
// MNetworkDisable
|
|
bool m_bNetworkedAnimationInputsChanged; // 0xb05
|
|
// MNetworkDisable
|
|
uint8_t m_nPrevNewSequenceParity; // 0xb06
|
|
// MNetworkDisable
|
|
uint8_t m_nPrevResetEventsParity; // 0xb07
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "3"
|
|
// MNetworkPriority "64"
|
|
// MNetworkChangeCallback "clientSideAnimCycleReset"
|
|
int32_t m_nNewSequenceParity; // 0xb08
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "3"
|
|
// MNetworkPriority "64"
|
|
int32_t m_nResetEventsParity; // 0xb0c
|
|
// MNetworkDisable
|
|
float m_flIKGroundContactTime; // 0xb10
|
|
// MNetworkDisable
|
|
float m_flIKGroundMinHeight; // 0xb14
|
|
// MNetworkDisable
|
|
float m_flIKGroundMaxHeight; // 0xb18
|
|
// MNetworkDisable
|
|
float m_flIkZAdjustAmount; // 0xb1c
|
|
// MNetworkDisable
|
|
C_CSequenceTransitioner2 m_SequenceTransitioner; // 0xb48
|
|
// MNetworkDisable
|
|
HSequence m_hLastAnimEventSequence; // 0xdc0
|
|
// MNetworkDisable
|
|
uint32_t m_ClientSideAnimationListHandle; // 0xdc4
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkChangeCallback "overrideAnimGraphChanged"
|
|
CStrongHandle< InfoForResourceTypeIAnimationGraph > m_hOverrideGraph; // 0xe70
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 224
|
|
class C_PlayerLocalData
|
|
{
|
|
public:
|
|
// MNetworkDisable
|
|
// MNetworkChangeAccessorFieldPathIndex
|
|
ChangeAccessorFieldPathIndex_t m_NetworkVar_PathIndex; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint8[32] m_chAreaBits; // 0x18
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint8[24] m_chAreaPortalBits; // 0x38
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
sky3dparams_t m_skybox3d; // 0x50
|
|
};
|
|
|
|
// Aligment: 15
|
|
// Size: 208
|
|
class CGlowOverlay
|
|
{
|
|
public:
|
|
Vector m_vPos; // 0x8
|
|
bool m_bDirectional; // 0x14
|
|
Vector m_vDirection; // 0x18
|
|
bool m_bInSky; // 0x24
|
|
float m_skyObstructionScale; // 0x28
|
|
CGlowSprite[4] m_Sprites; // 0x30
|
|
int32_t m_nSprites; // 0xb0
|
|
float m_flProxyRadius; // 0xb4
|
|
float m_flHDRColorScale; // 0xb8
|
|
float m_flGlowObstructionScale; // 0xbc
|
|
bool m_bCacheGlowObstruction; // 0xc0
|
|
bool m_bCacheSkyObstruction; // 0xc1
|
|
int16_t m_bActivated; // 0xc2
|
|
int16_t m_ListIndex; // 0xc4
|
|
int32_t m_queryHandle; // 0xc8
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct C_CEnvWindShared::WindAveEvent_t
|
|
{
|
|
public:
|
|
float m_flStartWindSpeed; // 0x0
|
|
float m_flAveWindSpeed; // 0x4
|
|
};
|
|
|
|
// Aligment: 29
|
|
// Size: 576
|
|
class C_CEnvWindShared
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flStartTime; // 0x8
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
uint32_t m_iWindSeed; // 0xc
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "10"
|
|
uint16_t m_iMinWind; // 0x10
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "10"
|
|
uint16_t m_iMaxWind; // 0x12
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "14"
|
|
int32_t m_windRadius; // 0x14
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "10"
|
|
uint16_t m_iMinGust; // 0x18
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "10"
|
|
uint16_t m_iMaxGust; // 0x1a
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flMinGustDelay; // 0x1c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flMaxGustDelay; // 0x20
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flGustDuration; // 0x24
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "9"
|
|
uint16_t m_iGustDirChange; // 0x28
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkEncoder
|
|
Vector m_location; // 0x2c
|
|
int32_t m_iszGustSound; // 0x38
|
|
int32_t m_iWindDir; // 0x3c
|
|
float m_flWindSpeed; // 0x40
|
|
Vector m_currentWindVector; // 0x44
|
|
Vector m_CurrentSwayVector; // 0x50
|
|
Vector m_PrevSwayVector; // 0x5c
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
// MNetworkBitCount "9"
|
|
uint16_t m_iInitialWindDir; // 0x68
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float m_flInitialWindSpeed; // 0x6c
|
|
float m_flVariationTime; // 0x70
|
|
float m_flSwayTime; // 0x74
|
|
float m_flSimTime; // 0x78
|
|
float m_flSwitchTime; // 0x7c
|
|
float m_flAveWindSpeed; // 0x80
|
|
bool m_bGusting; // 0x84
|
|
float m_flWindAngleVariation; // 0x88
|
|
float m_flWindSpeedVariation; // 0x8c
|
|
CEntityIndex m_iEntIndex; // 0x90
|
|
};
|
|
|
|
// Aligment: 10
|
|
// Size: 160
|
|
class CDecalInfo
|
|
{
|
|
public:
|
|
float m_flAnimationScale; // 0x0
|
|
float m_flAnimationLifeSpan; // 0x4
|
|
float m_flPlaceTime; // 0x8
|
|
float m_flFadeStartTime; // 0xc
|
|
float m_flFadeDuration; // 0x10
|
|
int32_t m_nVBSlot; // 0x14
|
|
int32_t m_nBoneIndex; // 0x18
|
|
CDecalInfo* m_pNext; // 0x28
|
|
CDecalInfo* m_pPrev; // 0x30
|
|
uint64_t m_nDecalMaterialIndex; // 0x98
|
|
};
|
|
|
|
// Aligment: 1
|
|
// Size: 56
|
|
struct PostProcessParameters_t
|
|
{
|
|
public:
|
|
// MNetworkEnable
|
|
// MNetworkEnable
|
|
float32[12] m_flParameters; // 0x8
|
|
};
|
|
|
|
// Aligment: 4
|
|
// Size: 40
|
|
class C_CSequenceTransitioner
|
|
{
|
|
public:
|
|
CUtlVector< CAnimationLayer > m_animationQueue; // 0x0
|
|
bool m_bIsInSimulation; // 0x18
|
|
float m_flSimOrRenderTime; // 0x1c
|
|
float m_flInterpolatedTime; // 0x20
|
|
};
|
|
|
|
// Aligment: 2
|
|
// Size: 8
|
|
struct C_CEnvWindShared::WindVariationEvent_t
|
|
{
|
|
public:
|
|
float m_flWindAngleVariation; // 0x0
|
|
float m_flWindSpeedVariation; // 0x4
|
|
};
|
|
|