CpuParticles3D

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 angle.

public float AngleMin { get; set; }

Minimum angle.

public Curve AngularVelocityCurve { get; set; }

Each particle's angular velocity (rotation speed) will vary along this Curve over its lifetime. 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 initial angular velocity (rotation speed) applied to each particle in degrees per second.

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.

public float AnimOffsetMin { get; set; }

Minimum animation offset.

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.

public float AnimSpeedMin { get; set; }

Minimum particle animation speed.

public Color Color { get; set; }

Each particle's initial color. Note: CpuParticles3D.Color multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.VertexColorUseAsAlbedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, CpuParticles3D.Color will have no visible effect.

public Gradient ColorInitialRamp { get; set; }

Each particle's initial color will vary along this Gradient (multiplied with CpuParticles3D.Color). Note: CpuParticles3D.ColorInitialRamp multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.VertexColorUseAsAlbedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, CpuParticles3D.ColorInitialRamp will have no visible effect.

public Gradient ColorRamp { get; set; }

Each particle's color will vary along this Gradient over its lifetime (multiplied with CpuParticles3D.Color). Note: CpuParticles3D.ColorRamp multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.VertexColorUseAsAlbedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, CpuParticles3D.ColorRamp will have no visible effect.

public Curve DampingCurve { get; set; }

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

public float DampingMax { get; set; }

Maximum damping.

public float DampingMin { get; set; }

Minimum damping.

public Vector3 Direction { get; set; }

Unit vector specifying the particles' emission direction.

public CpuParticles3D.DrawOrderEnum DrawOrder { get; set; }

Particle draw order.

public Vector3 EmissionBoxExtents { get; set; }

The rectangle's extents if CpuParticles3D.EmissionShape is set to CpuParticles3D.EmissionShapeEnum.Box.

public Color[] EmissionColors { get; set; }

Sets the Colors to modulate particles by when using CpuParticles3D.EmissionShapeEnum.Points or CpuParticles3D.EmissionShapeEnum.DirectedPoints. Note: CpuParticles3D.EmissionColors multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.VertexColorUseAsAlbedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, CpuParticles3D.EmissionColors will have no visible effect.

public Vector3[] EmissionNormals { get; set; }

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

public Vector3[] EmissionPoints { get; set; }

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

public Vector3 EmissionRingAxis { get; set; }

The axis of the ring when using the emitter CpuParticles3D.EmissionShapeEnum.Ring.

public float EmissionRingConeAngle { get; set; }

The angle of the cone when using the emitter CpuParticles3D.EmissionShapeEnum.Ring. The default angle of 90 degrees results in a ring, while an angle of 0 degrees results in a cone. Intermediate values will result in a ring where one end is larger than the other. Note: Depending on CpuParticles3D.EmissionRingHeight, the angle may be clamped if the ring's end is reached to form a perfect cone.

public float EmissionRingHeight { get; set; }

The height of the ring when using the emitter CpuParticles3D.EmissionShapeEnum.Ring.

public float EmissionRingInnerRadius { get; set; }

The inner radius of the ring when using the emitter CpuParticles3D.EmissionShapeEnum.Ring.

public float EmissionRingRadius { get; set; }

The radius of the ring when using the emitter CpuParticles3D.EmissionShapeEnum.Ring.

public CpuParticles3D.EmissionShapeEnum EmissionShape { get; set; }

Particles will be emitted inside this region.

public float EmissionSphereRadius { get; set; }

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

public bool Emitting { get; set; }

If true, particles are being emitted. CpuParticles3D.Emitting can be used to start and stop particles from emitting. However, if CpuParticles3D.OneShot is true setting CpuParticles3D.Emitting to true will not restart the emission cycle until after all active particles finish processing. You can use the CpuParticles3D.Finished signal to be notified once all active particles finish processing.

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 particle system itself.

public float Flatness { get; set; }

Amount of CpuParticles3D.Spread in Y/Z plane. A value of 1 restricts particles to X/Z plane.

public bool FractDelta { get; set; }

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

public Vector3 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 hue variation.

public float HueVariationMin { get; set; }

Minimum hue variation.

public float InitialVelocityMax { get; set; }

Maximum value of the initial velocity.

public float InitialVelocityMin { get; set; }

Minimum value of the initial velocity.

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.

public float LinearAccelMin { get; set; }

Minimum linear acceleration.

public bool LocalCoords { get; set; }

If true, particles use the parent node's coordinate space (known as local coordinates). This will cause particles to move and rotate along the CpuParticles3D node (and its parents) when it is moved or rotated. If false, particles use global coordinates; they will not move or rotate along the CpuParticles3D node (and its parents) when it is moved or rotated.

public Mesh Mesh { get; set; }

The Mesh used for each particle. If null, particles will be spheres.

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 orbit velocity.

public float OrbitVelocityMin { get; set; }

Minimum orbit velocity.

public bool ParticleFlagAlignY { get; set; }

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

public bool ParticleFlagDisableZ { get; set; }

If true, particles will not move on the Z axis.

public bool ParticleFlagRotateY { get; set; }

If true, particles rotate around Y axis by CpuParticles3D.AngleMin.

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.

public float RadialAccelMin { get; set; }

Minimum radial acceleration.

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 scale.

public float ScaleAmountMin { get; set; }

Minimum scale.

public Curve ScaleCurveX { get; set; }

Curve for the scale over life, along the x axis.

public Curve ScaleCurveY { get; set; }

Curve for the scale over life, along the y axis.

public Curve ScaleCurveZ { get; set; }

Curve for the scale over life, along the z axis.

public uint Seed { get; set; }

Sets the random seed used by the particle system. Only effective if CpuParticles3D.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 set to true, three different scale curves can be specified, one per scale axis.

public float Spread { get; set; }

Each particle's initial direction range from +spread to -spread degrees. Applied to X/Z plane and Y/Z planes.

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 tangent acceleration.

public float TangentialAccelMin { get; set; }

Minimum tangent acceleration.

public bool UseFixedSeed { get; set; }

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

public Aabb VisibilityAabb { get; set; }

The Aabb that determines the node's region which needs to be visible on screen for the particle system to be active. Grow the box if particles suddenly appear/disappear when the node enters/exits the screen. The Aabb can be grown via code or with the Particles → Generate AABB editor tool.

public Aabb CaptureAabb();

Returns the axis-aligned bounding box that contains all the particles that are active in the current frame.

public void ConvertFromParticles(Entity particles);

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

public Curve GetParamCurve(CpuParticles3D.Parameter param);

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

public float GetParamMax(CpuParticles3D.Parameter param);

Returns the maximum value range for the given parameter.

public float GetParamMin(CpuParticles3D.Parameter param);

Returns the minimum value range for the given parameter.

public bool GetParticleFlag(CpuParticles3D.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 CpuParticles3D.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 CpuParticles3D.SpeedScale set to 0.0, this is useful to be able to seek a particle system timeline.

public void Restart();

Restarts the particle emitter. If keep_seed is true, the current random seed will be preserved. Useful for seeking and playback.

public void Restart(bool keepSeed = false);

Restarts the particle emitter. If keep_seed is true, the current random seed will be preserved. Useful for seeking and playback.

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

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

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

Sets the maximum value for the given parameter.

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

Sets the minimum value for the given parameter.

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

Enables or disables the given particle flag.

public event Action Finished;

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