CpuParticles2D

public int Amount { get; set; }

Number of particles emitted in one emission cycle.

public Curve AngleCurve { get; set; }

Each particle's rotation will be animated along this Curve. Should be a unit Curve.

public float AngleMax { get; set; }

Maximum initial rotation applied to each particle, in degrees.

public float AngleMin { get; set; }

Minimum equivalent of CpuParticles2D.AngleMax.

public Curve AngularVelocityCurve { get; set; }

Each particle's angular velocity will vary along this Curve. Should be a unit Curve.

public float AngularVelocityMax { get; set; }

Maximum initial angular velocity (rotation speed) applied to each particle in degrees per second.

public float AngularVelocityMin { get; set; }

Minimum equivalent of CpuParticles2D.AngularVelocityMax.

public Curve AnimOffsetCurve { get; set; }

Each particle's animation offset will vary along this Curve. Should be a unit Curve.

public float AnimOffsetMax { get; set; }

Maximum animation offset that corresponds to frame index in the texture. 0 is the first frame, 1 is the last one. See CanvasItemMaterial.ParticlesAnimation.

public float AnimOffsetMin { get; set; }

Minimum equivalent of CpuParticles2D.AnimOffsetMax.

public Curve AnimSpeedCurve { get; set; }

Each particle's animation speed will vary along this Curve. Should be a unit Curve.

public float AnimSpeedMax { get; set; }

Maximum particle animation speed. Animation speed of 1 means that the particles will make full 0 to 1 offset cycle during lifetime, 2 means 2 cycles etc. With animation speed greater than 1, remember to enable CanvasItemMaterial.ParticlesAnimLoop property if you want the animation to repeat.

public float AnimSpeedMin { get; set; }

Minimum equivalent of CpuParticles2D.AnimSpeedMax.

public Color Color { get; set; }

Each particle's initial color. If CpuParticles2D.Texture is defined, it will be multiplied by this color.

public Gradient ColorInitialRamp { get; set; }

Each particle's initial color will vary along this Gradient (multiplied with CpuParticles2D.Color).

public Gradient ColorRamp { get; set; }

Each particle's color will vary along this Gradient over its lifetime (multiplied with CpuParticles2D.Color).

public Curve DampingCurve { get; set; }

Damping will vary along this Curve. Should be a unit Curve.

public float DampingMax { get; set; }

The maximum rate at which particles lose velocity. For example value of 100 means that the particle will go from 100 velocity to 0 in 1 second.

public float DampingMin { get; set; }

Minimum equivalent of CpuParticles2D.DampingMax.

public Vector2 Direction { get; set; }

Unit vector specifying the particles' emission direction.

public CpuParticles2D.DrawOrderEnum DrawOrder { get; set; }

Particle draw order.

public Color[] EmissionColors { get; set; }

Sets the Colors to modulate particles by when using CpuParticles2D.EmissionShapeEnum.Points or CpuParticles2D.EmissionShapeEnum.DirectedPoints.

public Vector2[] EmissionNormals { get; set; }

Sets the direction the particles will be emitted in when using CpuParticles2D.EmissionShapeEnum.DirectedPoints.

public Vector2[] EmissionPoints { get; set; }

Sets the initial positions to spawn particles when using CpuParticles2D.EmissionShapeEnum.Points or CpuParticles2D.EmissionShapeEnum.DirectedPoints.

public Vector2 EmissionRectExtents { get; set; }

The rectangle's extents if CpuParticles2D.EmissionShape is set to CpuParticles2D.EmissionShapeEnum.Rectangle.

public float EmissionRingInnerRadius { get; set; }

The ring's inner radius if CpuParticles2D.EmissionShape is set to CpuParticles2D.EmissionShapeEnum.Ring.

public float EmissionRingRadius { get; set; }

The ring's outer radius if CpuParticles2D.EmissionShape is set to CpuParticles2D.EmissionShapeEnum.Ring.

public CpuParticles2D.EmissionShapeEnum EmissionShape { get; set; }

Particles will be emitted inside this region.

public float EmissionSphereRadius { get; set; }

The sphere's radius if CpuParticles2D.EmissionShape is set to CpuParticles2D.EmissionShapeEnum.Sphere.

public bool Emitting { get; set; }

Allows new particles to be emitted. false does not delete existing live particles; they remain until their lifetimes end. This is not a full pause or Restart. For OneShot, observe Finished rather than treating Emitting=false as proof that the screen is empty.

public float Explosiveness { get; set; }

How rapidly particles in an emission cycle are emitted. If greater than 0, there will be a gap in emissions before the next cycle begins.

public int FixedFps { get; set; }

The particle system's frame rate is fixed to a value. For example, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the simulation of the particle system itself.

public bool FractDelta { get; set; }

If true, results in fractional delta calculation which has a smoother particles display effect.

public Vector2 Gravity { get; set; }

Gravity applied to every particle.

public Curve HueVariationCurve { get; set; }

Each particle's hue will vary along this Curve. Should be a unit Curve.

public float HueVariationMax { get; set; }

Maximum initial hue variation applied to each particle. It will shift the particle color's hue.

public float HueVariationMin { get; set; }

Minimum equivalent of CpuParticles2D.HueVariationMax.

public float InitialVelocityMax { get; set; }

Maximum initial velocity magnitude for each particle. Direction comes from CpuParticles2D.Direction and CpuParticles2D.Spread.

public float InitialVelocityMin { get; set; }

Minimum equivalent of CpuParticles2D.InitialVelocityMax.

public double Lifetime { get; set; }

Amount of time each particle will exist.

public double LifetimeRandomness { get; set; }

Particle lifetime randomness ratio.

public Curve LinearAccelCurve { get; set; }

Each particle's linear acceleration will vary along this Curve. Should be a unit Curve.

public float LinearAccelMax { get; set; }

Maximum linear acceleration applied to each particle in the direction of motion.

public float LinearAccelMin { get; set; }

Minimum equivalent of CpuParticles2D.LinearAccelMax.

public bool LocalCoords { get; set; }

Selects simulation space. With true, previously emitted particles follow emitter transforms; with false, they remain in world canvas space when the emitter subsequently moves. Choose before starting the effect and account for visibility bounds separately.

public bool OneShot { get; set; }

If true, only one emission cycle occurs. If set true during a cycle, emission will stop at the cycle's end.

public Curve OrbitVelocityCurve { get; set; }

Each particle's orbital velocity will vary along this Curve. Should be a unit Curve.

public float OrbitVelocityMax { get; set; }

Maximum orbital velocity applied to each particle. Makes the particles circle around origin. Specified in number of full rotations around origin per second.

public float OrbitVelocityMin { get; set; }

Minimum equivalent of CpuParticles2D.OrbitVelocityMax.

public bool ParticleFlagAlignY { get; set; }

Align Y axis of particle with the direction of its velocity.

public double Preprocess { get; set; }

Particle system starts as if it had already run for this many seconds.

public Curve RadialAccelCurve { get; set; }

Each particle's radial acceleration will vary along this Curve. Should be a unit Curve.

public float RadialAccelMax { get; set; }

Maximum radial acceleration applied to each particle. Makes particle accelerate away from the origin or towards it if negative.

public float RadialAccelMin { get; set; }

Minimum equivalent of CpuParticles2D.RadialAccelMax.

public float Randomness { get; set; }

Emission lifetime randomness ratio.

public Curve ScaleAmountCurve { get; set; }

Each particle's scale will vary along this Curve. Should be a unit Curve.

public float ScaleAmountMax { get; set; }

Maximum initial scale applied to each particle.

public float ScaleAmountMin { get; set; }

Minimum equivalent of CpuParticles2D.ScaleAmountMax.

public Curve ScaleCurveX { get; set; }

Each particle's horizontal scale will vary along this Curve. Should be a unit Curve. CpuParticles2D.SplitScale must be enabled.

public Curve ScaleCurveY { get; set; }

Each particle's vertical scale will vary along this Curve. Should be a unit Curve. CpuParticles2D.SplitScale must be enabled.

public uint Seed { get; set; }

Sets the random seed used by the particle system. Only effective if CpuParticles2D.UseFixedSeed is true.

public double SpeedScale { get; set; }

Particle system's running speed scaling ratio. A value of 0 can be used to pause the particles.

public bool SplitScale { get; set; }

If true, the scale curve will be split into x and y components. See CpuParticles2D.ScaleCurveX and CpuParticles2D.ScaleCurveY.

public float Spread { get; set; }

Each particle's initial direction range from +spread to -spread degrees.

public Curve TangentialAccelCurve { get; set; }

Each particle's tangential acceleration will vary along this Curve. Should be a unit Curve.

public float TangentialAccelMax { get; set; }

Maximum tangential acceleration applied to each particle. Tangential acceleration is perpendicular to the particle's velocity giving the particles a swirling motion.

public float TangentialAccelMin { get; set; }

Minimum equivalent of CpuParticles2D.TangentialAccelMax.

public Texture2D Texture { get; set; }

Particle texture. If null, particles will be squares.

public bool UseFixedSeed { get; set; }

If true, particles will use the same seed for every simulation using the seed defined in CpuParticles2D.Seed. This is useful for situations where the visual outcome should be consistent across replays, for example when using Movie Maker mode.

public void ConvertFromParticles(Entity particles);

Sets this node's properties to match a given GpuParticles2D node with an assigned ParticleProcessMaterial.

public Curve GetParamCurve(CpuParticles2D.Parameter param);

Returns the Curve of the parameter specified by CpuParticles2D.Parameter.

public float GetParamMax(CpuParticles2D.Parameter param);

Returns the maximum value range for the given parameter.

public float GetParamMin(CpuParticles2D.Parameter param);

Returns the minimum value range for the given parameter.

public bool GetParticleFlag(CpuParticles2D.ParticleFlags particleFlag);

Returns the enabled state of the given particle flag.

public void RequestParticlesProcess(float processTime);

Requests the particles to process for extra process time during a single frame. process_time defines the time that the particles will process while emitting is on. process_time_residual defines the time that particles will process with emitting turned off for the simulation. When combined with CpuParticles2D.SpeedScale set to 0.0, this is useful to be able to seek a particle system timeline.

public void RequestParticlesProcess(float processTime, float processTimeResidual = 0f);

Requests the particles to process for extra process time during a single frame. process_time defines the time that the particles will process while emitting is on. process_time_residual defines the time that particles will process with emitting turned off for the simulation. When combined with CpuParticles2D.SpeedScale set to 0.0, this is useful to be able to seek a particle system timeline.

public void Restart();

Restarts the particle system. Use Restart(bool keepSeed) for explicit seed control. Restart differs from merely setting Emitting=true and begins the effect again.

public void Restart(bool keepSeed = false);

Resets simulation state and enables emission. Seed is retained when keepSeed=true or UseFixedSeed=true; a new random value is selected only when both are false. The image changes after processing/rendering a frame.

public void SetParamCurve(CpuParticles2D.Parameter param, Curve curve);

Sets the Curve of the parameter specified by CpuParticles2D.Parameter. Should be a unit Curve.

public void SetParamMax(CpuParticles2D.Parameter param, float value);

Sets the maximum value for the given parameter.

public void SetParamMin(CpuParticles2D.Parameter param, float value);

Sets the minimum value for the given parameter.

public void SetParticleFlag(CpuParticles2D.ParticleFlags particleFlag, bool enable);

Enables or disables the given particle flag.

public event Action Finished;

Emitted when all active particles have finished processing. When CpuParticles2D.OneShot is disabled, particles will process continuously, so this is never emitted.