ParticleModule.h

Go to the documentation of this file.

struct FloatArray
{
    void add(number elem);

    void remove(number index);

    void clear();

    number size();

    number get(number n);

    void set(number n, number value);
};

struct RawDistribution
{
    number Type;
    number Op;
    number NumElements;
    number ChunkSize;
    FloatArray LookupTable;
    number TimeScale;
    number StartTime;
};

struct RawDistributionFloat : public RawDistribution
{
};

struct RawDistributionVector : public RawDistribution
{
};

struct Object
{
    string getName();
    string getClassName();
    string getFullName();
};

struct ParticleModule : public Object
{
    boolean bSpawnModule;
    boolean bUpdateModule;
    boolean bFinalUpdateModule;
    boolean bCurvesAsColor;
    boolean b3DDrawMode;
    boolean bSupported3DDrawMode;
    boolean bEnabled;
    boolean bEditable;
    boolean LODDuplicate;
    boolean bSupportsRandomSeed;
    boolean bRequiresLoopingNotification;
    number LODValidity;
    Color ModuleEditorColor;
};

struct ParticleModuleAccelerationBase : public ParticleModule
{
    boolean bAlwaysInWorldSpace;
};

struct ParticleModuleAcceleration : public ParticleModuleAccelerationBase
{
    RawDistributionVector Acceleration;
    boolean bApplyOwnerScale;
};

struct ParticleModuleAccelerationOverLifetime : public ParticleModuleAccelerationBase
{
    RawDistributionVector AccelOverLife;
};

struct ParticleModuleAttractorBase : public ParticleModule
{
};

struct ParticleModuleAttractorLine : public ParticleModuleAttractorBase
{
    Vector EndPoint0;
    Vector EndPoint1;
    RawDistributionFloat Range;
    RawDistributionFloat Strength;
};

struct ParticleModuleAttractorParticle : public ParticleModuleAttractorBase
{
    Name EmitterName;
    RawDistributionFloat Range;
    boolean bStrengthByDistance;
    boolean bAffectBaseVelocity;
    boolean bRenewSource;
    boolean bInheritSourceVel;
    RawDistributionFloat Strength;
    number SelectionMethod;
    number LastSelIndex;
};

struct ParticleModuleAttractorPoint : public ParticleModuleAttractorBase
{
    RawDistributionVector Position;
    RawDistributionFloat Range;
    RawDistributionFloat Strength;
    boolean StrengthByDistance;
    boolean bAffectBaseVelocity;
    boolean bOverrideVelocity;
    boolean bUseWorldSpacePosition;
};

struct ParticleModuleBeamBase : public ParticleModule
{
};

struct ParticleModuleBeamModifier : public ParticleModuleBeamBase
{
    number ModifierType;
    BeamModifierOptions PositionOptions;
    RawDistributionVector Position;
    BeamModifierOptions TangentOptions;
    RawDistributionVector Tangent;
    boolean bAbsoluteTangent;
    BeamModifierOptions StrengthOptions;
    RawDistributionFloat Strength;
};

struct ParticleModuleBeamNoise : public ParticleModuleBeamBase
{
    boolean bLowFreq_Enabled;
    boolean bNRScaleEmitterTime;
    boolean bSmooth;
    boolean bNoiseLock;
    boolean bOscillate;
    boolean bUseNoiseTangents;
    boolean bTargetNoise;
    boolean bApplyNoiseScale;
    number Frequency;
    number Frequency_LowRange;
    RawDistributionVector NoiseRange;
    RawDistributionFloat NoiseRangeScale;
    RawDistributionVector NoiseSpeed;
    number NoiseLockRadius;
    number NoiseLockTime;
    number NoiseTension;
    RawDistributionFloat NoiseTangentStrength;
    number NoiseTessellation;
    number FrequencyDistance;
    RawDistributionFloat NoiseScale;
};

struct ParticleModuleBeamSource : public ParticleModuleBeamBase
{
    number SourceMethod;
    number SourceTangentMethod;
    Name SourceName;
    boolean bSourceAbsolute;
    boolean bLockSource;
    boolean bLockSourceTangent;
    boolean bLockSourceStength;
    RawDistributionVector Source;
    RawDistributionVector SourceTangent;
    RawDistributionFloat SourceStrength;
};

struct ParticleModuleBeamTarget : public ParticleModuleBeamBase
{
    number TargetMethod;
    number TargetTangentMethod;
    Name TargetName;
    RawDistributionVector Target;
    boolean bTargetAbsolute;
    boolean bLockTarget;
    boolean bLockTargetTangent;
    boolean bLockTargetStength;
    RawDistributionVector TargetTangent;
    RawDistributionFloat TargetStrength;
    number LockRadius;
};

struct ParticleModuleCameraBase : public ParticleModule
{
};

struct ParticleModuleCameraOffset : public ParticleModuleCameraBase
{
    RawDistributionFloat CameraOffset;
    boolean bSpawnTimeOnly;
    number UpdateMethod;
};

struct ParticleModuleCollisionBase : public ParticleModule
{
};

struct ParticleModuleCollision : public ParticleModuleCollisionBase
{
    RawDistributionVector DampingFactor;
    RawDistributionVector DampingFactorRotation;
    RawDistributionFloat MaxCollisions;
    number CollisionCompletionOption;
    boolean bApplyPhysics;
    boolean bPawnsDoNotDecrementCount;
    boolean bOnlyVerticalNormalsDecrementCount;
    boolean bDropDetail;
    RawDistributionFloat ParticleMass;
    number DirScalar;
    number VerticalFudgeFactor;
    RawDistributionFloat DelayAmount;
};

struct ParticleModuleColorBase : public ParticleModule
{
};

struct ParticleModuleColor : public ParticleModuleColorBase
{
    RawDistributionVector StartColor;
    RawDistributionFloat StartAlpha;
    boolean bClampAlpha;
};

struct ParticleModuleColor_Seeded : public ParticleModuleColor
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleColorByParameter : public ParticleModuleColorBase
{
    Name ColorParam;
    Color DefaultColor;
};

struct ParticleModuleColorOverLife : public ParticleModuleColorBase
{
    RawDistributionVector ColorOverLife;
    RawDistributionFloat AlphaOverLife;
    boolean bClampAlpha;
};

struct ParticleModuleColorScaleOverDensity : public ParticleModuleColorBase
{
    RawDistributionVector ColorScaleOverDensity;
    RawDistributionFloat AlphaScaleOverDensity;
};

struct ParticleModuleColorScaleOverLife : public ParticleModuleColorBase
{
    RawDistributionVector ColorScaleOverLife;
    RawDistributionFloat AlphaScaleOverLife;
    boolean bEmitterTime;
};

struct ParticleModuleEventBase : public ParticleModule
{
};

struct ParticleModuleEventGenerator : public ParticleModuleEventBase
{
    TArray< struct FParticleEvent_GenerateInfo > Events;
};

struct ParticleModuleEventReceiverBase : public ParticleModuleEventBase
{
    number EventGeneratorType;
    Name EventName;
};

struct ParticleModuleEventReceiverKillParticles : public ParticleModuleEventReceiverBase
{
    boolean bStopSpawning;
};

struct ParticleModuleEventReceiverSpawn : public ParticleModuleEventReceiverBase
{
    RawDistributionFloat SpawnCount;
    boolean bUseParticleTime;
    boolean bUsePSysLocation;
    boolean bInheritVelocity;
    RawDistributionVector InheritVelocityScale;
};

struct ParticleModuleKillBase : public ParticleModule
{
};

struct ParticleModuleKillBox : public ParticleModuleKillBase
{
    RawDistributionVector LowerLeftCorner;
    RawDistributionVector UpperRightCorner;
    boolean bAbsolute;
    boolean bKillInside;
};

struct ParticleModuleKillHeight : public ParticleModuleKillBase
{
    RawDistributionFloat Height;
    boolean bAbsolute;
    boolean bFloor;
    boolean bApplyPSysScale;
};

struct ParticleModuleLifetimeBase : public ParticleModule
{
};

struct ParticleModuleLifetime : public ParticleModuleLifetimeBase
{
    RawDistributionFloat Lifetime;
};

struct ParticleModuleLifetime_Seeded : public ParticleModuleLifetime
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleLocationBase : public ParticleModule
{
};

struct ParticleModuleLocation : public ParticleModuleLocationBase
{
    RawDistributionVector StartLocation;
};

struct ParticleModuleLocation_Seeded : public ParticleModuleLocation
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleLocationBoneSocket : public ParticleModuleLocationBase
{
    number SourceType;
    number SelectionMethod;
    Vector UniversalOffset;
    TArray< struct FLocationBoneSocketInfo > SourceLocations;
    boolean bUpdatePositionEachFrame;
    boolean bOrientMeshEmitters;
    Name SkelMeshActorParamName;
    class USkeletalMesh* EditorSkelMesh;
};

struct ParticleModuleLocationDirect : public ParticleModuleLocationBase
{
    RawDistributionVector Location;
    RawDistributionVector LocationOffset;
    RawDistributionVector ScaleFactor;
    RawDistributionVector Direction;
};

struct ParticleModuleLocationEmitter : public ParticleModuleLocationBase
{
    Name EmitterName;
    number SelectionMethod;
    boolean InheritSourceVelocity;
    boolean bInheritSourceRotation;
    number InheritSourceVelocityScale;
    number InheritSourceRotationScale;
};

struct ParticleModuleLocationEmitterDirect : public ParticleModuleLocationBase
{
    Name EmitterName;
};

struct ParticleModuleLocationPrimitiveBase : public ParticleModuleLocationBase
{
    boolean Positive_X;
    boolean Positive_Y;
    boolean Positive_Z;
    boolean Negative_X;
    boolean Negative_Y;
    boolean Negative_Z;
    boolean SurfaceOnly;
    boolean Velocity;
    RawDistributionFloat VelocityScale;
    RawDistributionVector StartLocation;
};

struct ParticleModuleLocationPrimitiveCylinder : public ParticleModuleLocationPrimitiveBase
{
    boolean RadialVelocity;
    RawDistributionFloat StartRadius;
    RawDistributionFloat StartHeight;
    number HeightAxis;
};

struct ParticleModuleLocationPrimitiveCylinder_Seeded : public ParticleModuleLocationPrimitiveCylinder
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleLocationPrimitiveSphere : public ParticleModuleLocationPrimitiveBase
{
    RawDistributionFloat StartRadius;
};

struct ParticleModuleLocationPrimitiveSphere_Seeded : public ParticleModuleLocationPrimitiveSphere
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleSourceMovement : public ParticleModuleLocationBase
{
    RawDistributionVector SourceMovementScale;
};

struct ParticleModuleMaterialBase : public ParticleModule
{
};

struct ParticleModuleMaterialByParameter : public ParticleModuleMaterialBase
{
    TArray< struct FName > MaterialParameters;
    TArray< class UMaterialInterface* > DefaultMaterials;
};

struct ParticleModuleMeshMaterial : public ParticleModuleMaterialBase
{
    TArray< class UMaterialInterface* > MeshMaterials;
};

struct ParticleModuleOrbitBase : public ParticleModule
{
    boolean bUseEmitterTime;
};

struct ParticleModuleOrbit : public ParticleModuleOrbitBase
{
    number ChainMode;
    RawDistributionVector OffsetAmount;
    OrbitOptions OffsetOptions;
    RawDistributionVector RotationAmount;
    OrbitOptions RotationOptions;
    RawDistributionVector RotationRateAmount;
    OrbitOptions RotationRateOptions;
};

struct ParticleModuleOrientationBase : public ParticleModule
{
};

struct ParticleModuleOrientationAxisLock : public ParticleModuleOrientationBase
{
    number LockAxisFlags;
};

struct ParticleModuleParameterBase : public ParticleModule
{
};

struct ParticleModuleParameterDynamic : public ParticleModuleParameterBase
{
    TArray< struct FEmitterDynamicParameter > DynamicParams;
};

struct ParticleModuleParameterDynamic_Seeded : public ParticleModuleParameterDynamic
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleRequired : public ParticleModule
{
    class UMaterialInterface* Material;
    number ScreenAlignment;
    number SortMode;
    number ParticleBurstMethod;
    number InterpolationMethod;
    number EmitterNormalsMode;
    boolean bUseLocalSpace;
    boolean bKillOnDeactivate;
    boolean bKillOnCompleted;
    boolean bRequiresSorting;
    boolean bUseLegacyEmitterTime;
    boolean bEmitterDurationUseRange;
    boolean bDurationRecalcEachLoop;
    boolean bEmitterDelayUseRange;
    boolean bDelayFirstLoopOnly;
    boolean bScaleUV;
    boolean bDirectUV;
    boolean bUseMaxDrawCount;
    number EmitterDuration;
    number EmitterDurationLow;
    number EmitterLoops;
    RawDistributionFloat SpawnRate;
    TArray< struct FParticleBurst > BurstList;
    number EmitterDelay;
    number EmitterDelayLow;
    number SubImages_Horizontal;
    number SubImages_Vertical;
    number RandomImageTime;
    number RandomImageChanges;
    number MaxDrawCount;
    number DownsampleThresholdScreenFraction;
    Vector NormalsSphereCenter;
    Vector NormalsCylinderDirection;
};

struct ParticleModuleRotationBase : public ParticleModule
{
};

struct ParticleModuleMeshRotation : public ParticleModuleRotationBase
{
    RawDistributionVector StartRotation;
    boolean bInheritParent;
};

struct ParticleModuleMeshRotation_Seeded : public ParticleModuleMeshRotation
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleRotation : public ParticleModuleRotationBase
{
    RawDistributionFloat StartRotation;
};

struct ParticleModuleRotation_Seeded : public ParticleModuleRotation
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleRotationOverLifetime : public ParticleModuleRotationBase
{
    RawDistributionFloat RotationOverLife;
    boolean Scale;
};

struct ParticleModuleRotationRateBase : public ParticleModule
{
};

struct ParticleModuleMeshRotationRate : public ParticleModuleRotationRateBase
{
    RawDistributionVector StartRotationRate;
};

struct ParticleModuleMeshRotationRate_Seeded : public ParticleModuleMeshRotationRate
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleMeshRotationRateMultiplyLife : public ParticleModuleRotationRateBase
{
    RawDistributionVector LifeMultiplier;
};

struct ParticleModuleMeshRotationRateOverLife : public ParticleModuleRotationRateBase
{
    RawDistributionVector RotRate;
    boolean bScaleRotRate;
};

struct ParticleModuleRotationRate : public ParticleModuleRotationRateBase
{
    RawDistributionFloat StartRotationRate;
};

struct ParticleModuleRotationRate_Seeded : public ParticleModuleRotationRate
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleRotationRateMultiplyLife : public ParticleModuleRotationRateBase
{
    RawDistributionFloat LifeMultiplier;
};

struct ParticleModuleSizeBase : public ParticleModule
{
};

struct ParticleModuleSize : public ParticleModuleSizeBase
{
    RawDistributionVector StartSize;
};

struct ParticleModuleSize_Seeded : public ParticleModuleSize
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleSizeMultiplyLife : public ParticleModuleSizeBase
{
    RawDistributionVector LifeMultiplier;
    boolean MultiplyX;
    boolean MultiplyY;
    boolean MultiplyZ;
};

struct ParticleModuleSizeMultiplyVelocity : public ParticleModuleSizeBase
{
    RawDistributionVector VelocityMultiplier;
    boolean MultiplyX;
    boolean MultiplyY;
    boolean MultiplyZ;
};

struct ParticleModuleSizeScale : public ParticleModuleSizeBase
{
    RawDistributionVector SizeScale;
    boolean EnableX;
    boolean EnableY;
    boolean EnableZ;
};

struct ParticleModuleSizeScaleByTime : public ParticleModuleSizeBase
{
    RawDistributionVector SizeScaleByTime;
    boolean bEnableX;
    boolean bEnableY;
    boolean bEnableZ;
};

struct ParticleModuleSpawnBase : public ParticleModule
{
    boolean bProcessSpawnRate;
    boolean bProcessBurstList;
};

struct ParticleModuleSpawn : public ParticleModuleSpawnBase
{
    RawDistributionFloat Rate;
    RawDistributionFloat RateScale;
    number ParticleBurstMethod;
    TArray< struct FParticleBurst > BurstList;
};

struct ParticleModuleSpawnPerUnit : public ParticleModuleSpawnBase
{
    number UnitScalar;
    RawDistributionFloat SpawnPerUnit;
    boolean bIgnoreSpawnRateWhenMoving;
    boolean bIgnoreMovementAlongX;
    boolean bIgnoreMovementAlongY;
    boolean bIgnoreMovementAlongZ;
    number MovementTolerance;
};

struct ParticleModuleStoreSpawnTimeBase : public ParticleModule
{
};

struct ParticleModuleStoreSpawnTime : public ParticleModuleStoreSpawnTimeBase
{
};

struct ParticleModuleSubUVBase : public ParticleModule
{
};

struct ParticleModuleSubUV : public ParticleModuleSubUVBase
{
    RawDistributionFloat SubImageIndex;
};

struct ParticleModuleSubUVMovie : public ParticleModuleSubUV
{
    boolean bUseEmitterTime;
    RawDistributionFloat FrameRate;
    number StartingFrame;
};

struct ParticleModuleSubUVDirect : public ParticleModuleSubUVBase
{
    RawDistributionVector SubUVPosition;
    RawDistributionVector SubUVSize;
};

struct ParticleModuleSubUVSelect : public ParticleModuleSubUVBase
{
    RawDistributionVector SubImageSelect;
};

struct ParticleModuleTrailBase : public ParticleModule
{
};

struct ParticleModuleTrailSource : public ParticleModuleTrailBase
{
    number SourceMethod;
    number SelectionMethod;
    Name SourceName;
    RawDistributionFloat SourceStrength;
    boolean bLockSourceStength;
    boolean bInheritRotation;
    number SourceOffsetCount;
    TArray< struct FVector > SourceOffsetDefaults;
};

struct ParticleModuleTrailSpawn : public ParticleModuleTrailBase
{
    class UDistributionFloatParticleParameter* SpawnDistanceMap;
    number MinSpawnVelocity;
};

struct ParticleModuleTrailTaper : public ParticleModuleTrailBase
{
    number TaperMethod;
    RawDistributionFloat TaperFactor;
};

struct ParticleModuleTypeDataBase : public ParticleModule
{
};

struct ParticleModuleTypeDataAnimTrail : public ParticleModuleTypeDataBase
{
    Name ControlEdgeName;
    number SheetsPerTrail;
    boolean bDeadTrailsOnDeactivate;
    boolean bClipSourceSegement;
    boolean bEnablePreviousTangentRecalculation;
    boolean bTangentRecalculationEveryFrame;
    boolean bRenderGeometry;
    boolean bRenderSpawnPoints;
    boolean bRenderTangents;
    boolean bRenderTessellation;
    number TilingDistance;
    number DistanceTessellationStepSize;
    number TangentTessellationScalar;
};

struct ParticleModuleTypeDataApex : public ParticleModuleTypeDataBase
{
    class UApexGenericAsset* ApexIOFX;
    class UApexGenericAsset* ApexEmitter;
};

struct ParticleModuleTypeDataBeam : public ParticleModuleTypeDataBase
{
    number BeamMethod;
    number EndPointMethod;
    RawDistributionFloat Distance;
    RawDistributionVector EndPoint;
    number TessellationFactor;
    RawDistributionFloat EmitterStrength;
    RawDistributionFloat TargetStrength;
    RawDistributionVector EndPointDirection;
    number TextureTile;
    boolean RenderGeometry;
    boolean RenderDirectLine;
    boolean RenderLines;
    boolean RenderTessellation;
};

struct ParticleModuleTypeDataBeam2 : public ParticleModuleTypeDataBase
{
    number BeamMethod;
    number TaperMethod;
    number TextureTile;
    number TextureTileDistance;
    number Sheets;
    number MaxBeamCount;
    number Speed;
    number InterpolationPoints;
    boolean bAlwaysOn;
    boolean RenderGeometry;
    boolean RenderDirectLine;
    boolean RenderLines;
    boolean RenderTessellation;
    number UpVectorStepSize;
    Name BranchParentName;
    RawDistributionFloat Distance;
    RawDistributionFloat TaperFactor;
    RawDistributionFloat TaperScale;
};

struct ParticleModuleTypeDataMesh : public ParticleModuleTypeDataBase
{
    class UStaticMesh* Mesh;
    boolean CastShadows;
    boolean DoCollisions;
    boolean bAllowMotionBlur;
    boolean bOverrideMaterial;
    boolean bCameraFacing;
    boolean bApplyParticleRotationAsSpin;
    number MeshAlignment;
    number AxisLockOption;
    number CameraFacingUpAxisOption;
    number CameraFacingOption;
    number Pitch;
    number Roll;
    number Yaw;
};

struct ParticleModuleTypeDataMeshPhysX : public ParticleModuleTypeDataMesh
{
    class UPhysXParticleSystem* PhysXParSys;
    number PhysXRotationMethod;
    number FluidRotationCoefficient;
    Pointer RenderInstance;
    PhysXEmitterVerticalLodProperties VerticalLod;
};

struct ParticleModuleTypeDataPhysX : public ParticleModuleTypeDataBase
{
    class UPhysXParticleSystem* PhysXParSys;
    PhysXEmitterVerticalLodProperties VerticalLod;
};

struct ParticleModuleTypeDataRibbon : public ParticleModuleTypeDataBase
{
    number MaxTessellationBetweenParticles;
    number SheetsPerTrail;
    number MaxTrailCount;
    number MaxParticleInTrailCount;
    boolean bDeadTrailsOnDeactivate;
    boolean bDeadTrailsOnSourceLoss;
    boolean bClipSourceSegement;
    boolean bEnablePreviousTangentRecalculation;
    boolean bTangentRecalculationEveryFrame;
    boolean bRenderGeometry;
    boolean bRenderSpawnPoints;
    boolean bRenderTangents;
    boolean bRenderTessellation;
    number RenderAxis;
    number TangentSpawningScalar;
    number TilingDistance;
    number DistanceTessellationStepSize;
    number TangentTessellationScalar;
};

struct ParticleModuleTypeDataTrail : public ParticleModuleTypeDataBase
{
    boolean RenderGeometry;
    boolean RenderLines;
    boolean RenderTessellation;
    boolean Tapered;
    boolean SpawnByDistance;
    number TessellationFactor;
    RawDistributionFloat Tension;
    Vector SpawnDistance;
};

struct ParticleModuleTypeDataTrail2 : public ParticleModuleTypeDataBase
{
    number TessellationFactor;
    number TessellationFactorDistance;
    number TessellationStrength;
    number TextureTile;
    number Sheets;
    number MaxTrailCount;
    number MaxParticleInTrailCount;
    boolean bClipSourceSegement;
    boolean bClearTangents;
    boolean RenderGeometry;
    boolean RenderDirectLine;
    boolean RenderLines;
    boolean RenderTessellation;
};

struct ParticleModuleUberBase : public ParticleModule
{
    TArray< struct FName > RequiredModules;
};

struct ParticleModuleUberLTISIVCL : public ParticleModuleUberBase
{
    RawDistributionFloat Lifetime;
    RawDistributionVector StartSize;
    RawDistributionVector StartVelocity;
    RawDistributionFloat StartVelocityRadial;
    RawDistributionVector ColorOverLife;
    RawDistributionFloat AlphaOverLife;
};

struct ParticleModuleUberLTISIVCLIL : public ParticleModuleUberBase
{
    RawDistributionFloat Lifetime;
    RawDistributionVector StartSize;
    RawDistributionVector StartVelocity;
    RawDistributionFloat StartVelocityRadial;
    RawDistributionVector ColorOverLife;
    RawDistributionFloat AlphaOverLife;
    RawDistributionVector StartLocation;
};

struct ParticleModuleUberLTISIVCLILIRSSBLIRR : public ParticleModuleUberBase
{
    RawDistributionFloat Lifetime;
    RawDistributionVector StartSize;
    RawDistributionVector StartVelocity;
    RawDistributionFloat StartVelocityRadial;
    RawDistributionVector ColorOverLife;
    RawDistributionFloat AlphaOverLife;
    RawDistributionVector StartLocation;
    RawDistributionFloat StartRotation;
    RawDistributionVector SizeLifeMultiplier;
    boolean SizeMultiplyX;
    boolean SizeMultiplyY;
    boolean SizeMultiplyZ;
    RawDistributionFloat StartRotationRate;
};

struct ParticleModuleUberRainDrops : public ParticleModuleUberBase
{
    number LifetimeMin;
    number LifetimeMax;
    Vector StartSizeMin;
    Vector StartSizeMax;
    Vector StartVelocityMin;
    Vector StartVelocityMax;
    number StartVelocityRadialMin;
    number StartVelocityRadialMax;
    Vector ColorOverLife;
    number AlphaOverLife;
    boolean bIsUsingCylinder;
    boolean bPositive_X;
    boolean bPositive_Y;
    boolean bPositive_Z;
    boolean bNegative_X;
    boolean bNegative_Y;
    boolean bNegative_Z;
    boolean bSurfaceOnly;
    boolean bVelocity;
    boolean bRadialVelocity;
    number PC_VelocityScale;
    Vector PC_StartLocation;
    number PC_StartRadius;
    number PC_StartHeight;
    number PC_HeightAxis;
    Vector StartLocationMin;
    Vector StartLocationMax;
};

struct ParticleModuleUberRainImpacts : public ParticleModuleUberBase
{
    RawDistributionFloat Lifetime;
    RawDistributionVector StartSize;
    RawDistributionVector StartRotation;
    boolean bInheritParent;
    boolean MultiplyX;
    boolean MultiplyY;
    boolean MultiplyZ;
    boolean bIsUsingCylinder;
    boolean bPositive_X;
    boolean bPositive_Y;
    boolean bPositive_Z;
    boolean bNegative_X;
    boolean bNegative_Y;
    boolean bNegative_Z;
    boolean bSurfaceOnly;
    boolean bVelocity;
    boolean bRadialVelocity;
    RawDistributionVector LifeMultiplier;
    RawDistributionFloat PC_VelocityScale;
    RawDistributionVector PC_StartLocation;
    RawDistributionFloat PC_StartRadius;
    RawDistributionFloat PC_StartHeight;
    number PC_HeightAxis;
    RawDistributionVector ColorOverLife;
    RawDistributionFloat AlphaOverLife;
};

struct ParticleModuleUberRainSplashA : public ParticleModuleUberBase
{
    RawDistributionFloat Lifetime;
    RawDistributionVector StartSize;
    RawDistributionVector StartRotation;
    boolean bInheritParent;
    boolean MultiplyX;
    boolean MultiplyY;
    boolean MultiplyZ;
    RawDistributionVector LifeMultiplier;
    RawDistributionVector ColorOverLife;
    RawDistributionFloat AlphaOverLife;
};

struct ParticleModuleUberRainSplashB : public ParticleModuleUberBase
{
    RawDistributionFloat Lifetime;
    RawDistributionVector StartSize;
    RawDistributionVector ColorOverLife;
    RawDistributionFloat AlphaOverLife;
    RawDistributionVector LifeMultiplier;
    boolean MultiplyX;
    boolean MultiplyY;
    boolean MultiplyZ;
    RawDistributionFloat StartRotationRate;
};

struct ParticleModuleVelocityBase : public ParticleModule
{
    boolean bInWorldSpace;
    boolean bApplyOwnerScale;
};

struct ParticleModuleVelocity : public ParticleModuleVelocityBase
{
    RawDistributionVector StartVelocity;
    RawDistributionFloat StartVelocityRadial;
};

struct ParticleModuleVelocity_Seeded : public ParticleModuleVelocity
{
    ParticleRandomSeedInfo RandomSeedInfo;
};

struct ParticleModuleVelocityInheritParent : public ParticleModuleVelocityBase
{
    RawDistributionVector Scale;
};

struct ParticleModuleVelocityOverLifetime : public ParticleModuleVelocityBase
{
    RawDistributionVector VelOverLife;
    boolean Absolute;
};

namespace cast
{
    ParticleModuleAccelerationBase ParticleModuleAccelerationBase(ParticleModule mod);

    ParticleModuleAcceleration ParticleModuleAcceleration(ParticleModule mod);

    ParticleModuleAccelerationOverLifetime ParticleModuleAccelerationOverLifetime(ParticleModule mod);

    ParticleModuleAttractorBase ParticleModuleAttractorBase(ParticleModule mod);

    ParticleModuleAttractorLine ParticleModuleAttractorLine(ParticleModule mod);

    ParticleModuleAttractorParticle ParticleModuleAttractorParticle(ParticleModule mod);

    ParticleModuleAttractorPoint ParticleModuleAttractorPoint(ParticleModule mod);

    ParticleModuleBeamBase ParticleModuleBeamBase(ParticleModule mod);

    ParticleModuleBeamModifier ParticleModuleBeamModifier(ParticleModule mod);

    ParticleModuleBeamNoise ParticleModuleBeamNoise(ParticleModule mod);

    ParticleModuleBeamSource ParticleModuleBeamSource(ParticleModule mod);

    ParticleModuleBeamTarget ParticleModuleBeamTarget(ParticleModule mod);

    ParticleModuleCameraBase ParticleModuleCameraBase(ParticleModule mod);

    ParticleModuleCameraOffset ParticleModuleCameraOffset(ParticleModule mod);

    ParticleModuleCollisionBase ParticleModuleCollisionBase(ParticleModule mod);

    ParticleModuleCollision ParticleModuleCollision(ParticleModule mod);

    ParticleModuleColorBase ParticleModuleColorBase(ParticleModule mod);

    ParticleModuleColor ParticleModuleColor(ParticleModule mod);

    ParticleModuleColor_Seeded ParticleModuleColor_Seeded(ParticleModule mod);

    ParticleModuleColorByParameter ParticleModuleColorByParameter(ParticleModule mod);

    ParticleModuleColorOverLife ParticleModuleColorOverLife(ParticleModule mod);

    ParticleModuleColorScaleOverDensity ParticleModuleColorScaleOverDensity(ParticleModule mod);

    ParticleModuleColorScaleOverLife ParticleModuleColorScaleOverLife(ParticleModule mod);

    ParticleModuleEventBase ParticleModuleEventBase(ParticleModule mod);

    ParticleModuleEventGenerator ParticleModuleEventGenerator(ParticleModule mod);

    ParticleModuleEventReceiverBase ParticleModuleEventReceiverBase(ParticleModule mod);

    ParticleModuleEventReceiverKillParticles ParticleModuleEventReceiverKillParticles(ParticleModule mod);

    ParticleModuleEventReceiverSpawn ParticleModuleEventReceiverSpawn(ParticleModule mod);

    ParticleModuleKillBase ParticleModuleKillBase(ParticleModule mod);

    ParticleModuleKillBox ParticleModuleKillBox(ParticleModule mod);

    ParticleModuleKillHeight ParticleModuleKillHeight(ParticleModule mod);

    ParticleModuleLifetimeBase ParticleModuleLifetimeBase(ParticleModule mod);

    ParticleModuleLifetime ParticleModuleLifetime(ParticleModule mod);

    ParticleModuleLifetime_Seeded ParticleModuleLifetime_Seeded(ParticleModule mod);

    ParticleModuleLocationBase ParticleModuleLocationBase(ParticleModule mod);

    ParticleModuleLocation ParticleModuleLocation(ParticleModule mod);

    ParticleModuleLocation_Seeded ParticleModuleLocation_Seeded(ParticleModule mod);

    ParticleModuleLocationBoneSocket ParticleModuleLocationBoneSocket(ParticleModule mod);

    ParticleModuleLocationDirect ParticleModuleLocationDirect(ParticleModule mod);

    ParticleModuleLocationEmitter ParticleModuleLocationEmitter(ParticleModule mod);

    ParticleModuleLocationEmitterDirect ParticleModuleLocationEmitterDirect(ParticleModule mod);

    ParticleModuleLocationPrimitiveBase ParticleModuleLocationPrimitiveBase(ParticleModule mod);

    ParticleModuleLocationPrimitiveCylinder ParticleModuleLocationPrimitiveCylinder(ParticleModule mod);

    ParticleModuleLocationPrimitiveCylinder_Seeded ParticleModuleLocationPrimitiveCylinder_Seeded(ParticleModule mod);

    ParticleModuleLocationPrimitiveSphere ParticleModuleLocationPrimitiveSphere(ParticleModule mod);

    ParticleModuleLocationPrimitiveSphere_Seeded ParticleModuleLocationPrimitiveSphere_Seeded(ParticleModule mod);

    ParticleModuleSourceMovement ParticleModuleSourceMovement(ParticleModule mod);

    ParticleModuleMaterialBase ParticleModuleMaterialBase(ParticleModule mod);

    ParticleModuleMaterialByParameter ParticleModuleMaterialByParameter(ParticleModule mod);

    ParticleModuleMeshMaterial ParticleModuleMeshMaterial(ParticleModule mod);

    ParticleModuleOrbitBase ParticleModuleOrbitBase(ParticleModule mod);

    ParticleModuleOrbit ParticleModuleOrbit(ParticleModule mod);

    ParticleModuleOrientationBase ParticleModuleOrientationBase(ParticleModule mod);

    ParticleModuleOrientationAxisLock ParticleModuleOrientationAxisLock(ParticleModule mod);

    ParticleModuleParameterBase ParticleModuleParameterBase(ParticleModule mod);

    ParticleModuleParameterDynamic ParticleModuleParameterDynamic(ParticleModule mod);

    ParticleModuleParameterDynamic_Seeded ParticleModuleParameterDynamic_Seeded(ParticleModule mod);

    ParticleModuleRequired ParticleModuleRequired(ParticleModule mod);

    ParticleModuleRotationBase ParticleModuleRotationBase(ParticleModule mod);

    ParticleModuleMeshRotation ParticleModuleMeshRotation(ParticleModule mod);

    ParticleModuleMeshRotation_Seeded ParticleModuleMeshRotation_Seeded(ParticleModule mod);

    ParticleModuleRotation ParticleModuleRotation(ParticleModule mod);

    ParticleModuleRotation_Seeded ParticleModuleRotation_Seeded(ParticleModule mod);

    ParticleModuleRotationOverLifetime ParticleModuleRotationOverLifetime(ParticleModule mod);

    ParticleModuleRotationRateBase ParticleModuleRotationRateBase(ParticleModule mod);

    ParticleModuleMeshRotationRate ParticleModuleMeshRotationRate(ParticleModule mod);

    ParticleModuleMeshRotationRate_Seeded ParticleModuleMeshRotationRate_Seeded(ParticleModule mod);

    ParticleModuleMeshRotationRateMultiplyLife ParticleModuleMeshRotationRateMultiplyLife(ParticleModule mod);

    ParticleModuleMeshRotationRateOverLife ParticleModuleMeshRotationRateOverLife(ParticleModule mod);

    ParticleModuleRotationRate ParticleModuleRotationRate(ParticleModule mod);

    ParticleModuleRotationRate_Seeded ParticleModuleRotationRate_Seeded(ParticleModule mod);

    ParticleModuleRotationRateMultiplyLife ParticleModuleRotationRateMultiplyLife(ParticleModule mod);

    ParticleModuleSizeBase ParticleModuleSizeBase(ParticleModule mod);

    ParticleModuleSize ParticleModuleSize(ParticleModule mod);

    ParticleModuleSize_Seeded ParticleModuleSize_Seeded(ParticleModule mod);

    ParticleModuleSizeMultiplyLife ParticleModuleSizeMultiplyLife(ParticleModule mod);

    ParticleModuleSizeMultiplyVelocity ParticleModuleSizeMultiplyVelocity(ParticleModule mod);

    ParticleModuleSizeScale ParticleModuleSizeScale(ParticleModule mod);

    ParticleModuleSizeScaleByTime ParticleModuleSizeScaleByTime(ParticleModule mod);

    ParticleModuleSpawnBase ParticleModuleSpawnBase(ParticleModule mod);

    ParticleModuleSpawn ParticleModuleSpawn(ParticleModule mod);

    ParticleModuleSpawnPerUnit ParticleModuleSpawnPerUnit(ParticleModule mod);

    ParticleModuleStoreSpawnTimeBase ParticleModuleStoreSpawnTimeBase(ParticleModule mod);

    ParticleModuleStoreSpawnTime ParticleModuleStoreSpawnTime(ParticleModule mod);

    ParticleModuleSubUVBase ParticleModuleSubUVBase(ParticleModule mod);

    ParticleModuleSubUV ParticleModuleSubUV(ParticleModule mod);

    ParticleModuleSubUVMovie ParticleModuleSubUVMovie(ParticleModule mod);

    ParticleModuleSubUVDirect ParticleModuleSubUVDirect(ParticleModule mod);

    ParticleModuleSubUVSelect ParticleModuleSubUVSelect(ParticleModule mod);

    ParticleModuleTrailBase ParticleModuleTrailBase(ParticleModule mod);

    ParticleModuleTrailSource ParticleModuleTrailSource(ParticleModule mod);

    ParticleModuleTrailSpawn ParticleModuleTrailSpawn(ParticleModule mod);

    ParticleModuleTrailTaper ParticleModuleTrailTaper(ParticleModule mod);

    ParticleModuleTypeDataBase ParticleModuleTypeDataBase(ParticleModule mod);

    ParticleModuleTypeDataAnimTrail ParticleModuleTypeDataAnimTrail(ParticleModule mod);

    ParticleModuleTypeDataApex ParticleModuleTypeDataApex(ParticleModule mod);

    ParticleModuleTypeDataBeam ParticleModuleTypeDataBeam(ParticleModule mod);

    ParticleModuleTypeDataBeam2 ParticleModuleTypeDataBeam2(ParticleModule mod);

    ParticleModuleTypeDataMesh ParticleModuleTypeDataMesh(ParticleModule mod);

    ParticleModuleTypeDataMeshPhysX ParticleModuleTypeDataMeshPhysX(ParticleModule mod);

    ParticleModuleTypeDataPhysX ParticleModuleTypeDataPhysX(ParticleModule mod);

    ParticleModuleTypeDataRibbon ParticleModuleTypeDataRibbon(ParticleModule mod);

    ParticleModuleTypeDataTrail ParticleModuleTypeDataTrail(ParticleModule mod);

    ParticleModuleTypeDataTrail2 ParticleModuleTypeDataTrail2(ParticleModule mod);

    ParticleModuleUberBase ParticleModuleUberBase(ParticleModule mod);

    ParticleModuleUberLTISIVCL ParticleModuleUberLTISIVCL(ParticleModule mod);

    ParticleModuleUberLTISIVCLIL ParticleModuleUberLTISIVCLIL(ParticleModule mod);

    ParticleModuleUberLTISIVCLILIRSSBLIRR ParticleModuleUberLTISIVCLILIRSSBLIRR(ParticleModule mod);

    ParticleModuleUberRainDrops ParticleModuleUberRainDrops(ParticleModule mod);

    ParticleModuleUberRainImpacts ParticleModuleUberRainImpacts(ParticleModule mod);

    ParticleModuleUberRainSplashA ParticleModuleUberRainSplashA(ParticleModule mod);

    ParticleModuleUberRainSplashB ParticleModuleUberRainSplashB(ParticleModule mod);

    ParticleModuleVelocityBase ParticleModuleVelocityBase(ParticleModule mod);

    ParticleModuleVelocity ParticleModuleVelocity(ParticleModule mod);

    ParticleModuleVelocity_Seeded ParticleModuleVelocity_Seeded(ParticleModule mod);

    ParticleModuleVelocityInheritParent ParticleModuleVelocityInheritParent(ParticleModule mod);

    ParticleModuleVelocityOverLifetime ParticleModuleVelocityOverLifetime(ParticleModule mod);
};