GpuParticles3D

public int Amount { get; set; }

Capacity, at least 1. Changing it in the current RenderingDevice implementation frees particle data and resets phase for reallocation. Use AmountRatio for emission fraction without changing capacity. Not an exact visible-particle count.

public float AmountRatio { get; set; }

Emission fraction of allocated Amount; supply 0 to 1. Does not reduce allocated capacity or instantly remove live particles. Birth behavior also depends on the simulation material.

public float CollisionBaseSize { get; set; }

Base particle collision size. Distinct from mesh scale and VisibilityAabb; the material CollisionUseScale controls scale participation. CollisionMode and a GPU-particle collider are required.

public GpuParticles3D.DrawOrderEnum DrawOrder { get; set; }

Particle draw order. Note: GpuParticles3D.DrawOrderEnum.Index is the only option that supports motion vectors for effects like TAA. It is suggested to use this draw order if the particles are opaque to fix ghosting artifacts.

public Mesh DrawPass1 { get; set; }

First drawing-pass mesh. Its surface determines appearance separately from ProcessMaterial. Null hides this pass geometry but does not stop simulation.

public Mesh DrawPass2 { get; set; }

Mesh that is drawn for the second draw pass.

public Mesh DrawPass3 { get; set; }

Mesh that is drawn for the third draw pass.

public Mesh DrawPass4 { get; set; }

Mesh that is drawn for the fourth draw pass.

public int DrawPasses { get; set; }

The number of draw passes when rendering particles.

public bool Emitting { get; set; }

Controls new particle births. False neither removes live particles nor pauses simulation; a one-shot can report false before its effect disappears. Use Restart for a new cycle: repeated true during an active one-shot can cancel its Finished notification.

public float Explosiveness { get; set; }

Birth-interval compression: 0 distributes births through the cycle, 1 concentrates them at the burst start. Does not set travel velocity or ProcessMaterial forces.

public int FixedFps { get; set; }

Fixed simulation-step rate, not a drawing frame-rate limit. A positive value selects steps of 1/FPS. At 0, current RD uses variable delta for ordinary particles, while trails can require an internal fixed step. Defaults to 30; the example explicitly selects 60.

public bool FractDelta { get; set; }

Refines the DELTA fraction for a particle born within a step. This is neither general float precision nor draw interpolation. Current RD applies it during ordinary emission-phase calculation; do not assume identical effects for all manual/sub-emission paths.

public float InterpToEnd { get; set; }

Value supplied to a particle shader as INTERPOLATE_TO_END, clamped to 0–1. Built-in ParticleProcessMaterial uses it in age calculation; a custom ShaderMaterial must apply it explicitly. It is neither Lifetime duration nor Interpolate frame smoothing.

public bool Interpolate { get; set; }

Draw interpolation between simulation steps. It neither replaces FixedFps nor adds process() calls and is distinct from InterpToEnd. Current RD uses it when applying the time remainder to instance data.

public double Lifetime { get; set; }

Lifetime/cycle duration in seconds, strictly greater than zero. Along with Amount and birth timing affects density; not the time until Emitting stops or an exact frame count.

public bool LocalCoords { get; set; }

If true, live particles follow the emitter transform; if false, spawned particles remain in world space as it moves. Choose the space before starting: switching a live effect does not guarantee preserving its appearance.

public bool OneShot { get; set; }

One cycle instead of looping. Finished reports one-shot completion, not every manual stop of a continuous emitter. An explosive cycle can stop spawning before its particles expire.

public double Preprocess { get; set; }

Amount of time to preprocess the particles before animation starts. Lets you start the animation some time after particles have started emitting. Note: This can be very expensive if set to a high number as it requires running the particle shader a number of times equal to the GpuParticles3D.FixedFps (or 30, if GpuParticles3D.FixedFps is 0) for every second. In extreme cases it can even lead to a GPU crash due to the volume of work done in a single frame.

public Material ProcessMaterial { get; set; }

Simulation material, such as ParticleProcessMaterial. Controls behavior rather than the mesh surface. A visible effect separately needs a draw-pass mesh with a surface material.

public float Randomness { get; set; }

Emission randomness ratio.

public uint Seed { get; set; }

Particle random seed. To preserve it across Restart, enable UseFixedSeed or pass keepSeed=true. The seed alone does not fix all simulation conditions and steps.

public double SpeedScale { get; set; }

Simulation progression scale. Zero pauses ordinary progression but does not hide live geometry. Camera motion and transforms with LocalCoords can change the image while paused. Not rendering FPS. 1.0.0 timing limitation: after a long SpeedScale = 0 pause and resuming to 1, the tested one-shot can emit Finished while GPU particles are still visible. The scene timer multiplies accumulated elapsed time by the current speed scale; it is not a GPU-expiry fence. Do not recycle a time-scaled effect from this signal alone. Keeping a simple one-shot at fixed speed avoids this particular pause/resume case; validate a separate lifecycle policy when changing simulation time.

public EntityPath SubEmitter { get; set; }

Path from this emitter to an existing target GpuParticles3D. Assign after both Entities exist; births also require the primary ProcessMaterial mode. Does not create an Entity per particle. Avoid self-links/cycles; revalidate after hierarchy changes.

public bool TrailEnabled { get; set; }

Enables trail history. Requires compatible mesh poses and UseParticleTrails on the effective surface. The current RenderingDevice rebuilds data when this setting is assigned; do not update it every frame as a cheap animation.

public double TrailLifetime { get; set; }

History duration in seconds, not particle Lifetime or rest-mesh length. Minimum approximately 0.01; the current RD backend caps history at 10 seconds although the scene getter stores the request. Changes rebuild data/phase; account for motion, step and budget.

public GpuParticles3D.TransformAlignEnum TransformAlign { get; set; }

Alignment of the rendered particle transform. YToVelocity is the example starting point for directional geometry/trails. Does not change velocity or guarantee freedom from twisting/flattening on every path.

public RenderingServer.ParticlesTransformAlignAxis TransformAlignAxis { get; set; }

When using transform align local billboard, which axis to use for the billboarding. Supports only X or Y.

public RenderingServer.ParticlesTransformAlignCustomSrc TransformAlignChannelFilter { get; set; }

In the case of billboarded particles, which custom channel to read from to calculate their angle.

public bool UseFixedSeed { get; set; }

Preserves the assigned Seed during ordinary restarts. Helps repeat an effect but does not guarantee bitwise determinism across drivers, time steps or builds.

public Aabb VisibilityAabb { get; set; }

Custom culling bound for the whole emitter. If offscreen, it can hide otherwise visible particles. Not current-frame CaptureAabb, a trajectory clamp or a collider; cover the entire effect and mesh sizes.

public Aabb CaptureAabb();

Reads current active particle bounds. Observing a running effect does not cover all future trajectories or automatically assign VisibilityAabb. GPU readback can have a cost.

public void ConvertFromParticles(Entity particles);

Sets this node's properties to match a given CpuParticles3D node.

public void EmitParticle(Transform3D xform, Vector3 velocity, Color color, Color custom, uint flags);

Requests manual emission of one GPU particle. Flags identify supplied fields; custom start() code must respect RESTART_POSITION/ROT_SCALE/VELOCITY/COLOR/CUSTOM to preserve them. A particle is not a new Entity. Available capacity, ProcessMaterial, draw material and correct bounds are required; the method does not return visibility confirmation.

public int GetAmount();

Returns Amount. Capacity, at least 1. Changing it in the current RenderingDevice implementation frees particle data and resets phase for reallocation. Use AmountRatio for emission fraction without changing capacity. Not an exact visible-particle count.

public float GetAmountRatio();

Returns AmountRatio. Emission fraction of allocated Amount; supply 0 to 1. Does not reduce allocated capacity or instantly remove live particles. Birth behavior also depends on the simulation material.

public Mesh GetDrawPassMesh(int pass);

Returns the Mesh that is drawn at index pass.

public float GetExplosivenessRatio();

Returns Explosiveness. Birth-interval compression: 0 distributes births through the cycle, 1 concentrates them at the burst start. Does not set travel velocity or ProcessMaterial forces.

public int GetFixedFps();

Fixed simulation-step rate, not a drawing frame-rate limit. A positive value selects steps of 1/FPS. At 0, current RD uses variable delta for ordinary particles, while trails can require an internal fixed step. Defaults to 30; the example explicitly selects 60.

public bool GetFractionalDelta();

Refines the DELTA fraction for a particle born within a step. This is neither general float precision nor draw interpolation. Current RD applies it during ordinary emission-phase calculation; do not assume identical effects for all manual/sub-emission paths.

public float GetInterpToEnd();

Value supplied to a particle shader as INTERPOLATE_TO_END, clamped to 0–1. Built-in ParticleProcessMaterial uses it in age calculation; a custom ShaderMaterial must apply it explicitly. It is neither Lifetime duration nor Interpolate frame smoothing.

public bool GetInterpolate();

Draw interpolation between simulation steps. It neither replaces FixedFps nor adds process() calls and is distinct from InterpToEnd. Current RD uses it when applying the time remainder to instance data.

public double GetLifetime();

Returns Lifetime. Lifetime/cycle duration in seconds, strictly greater than zero. Along with Amount and birth timing affects density; not the time until Emitting stops or an exact frame count.

public bool GetOneShot();

Returns OneShot. One cycle instead of looping. Finished reports one-shot completion, not every manual stop of a continuous emitter. An explosive cycle can stop spawning before its particles expire.

public Material GetProcessMaterial();

Returns ProcessMaterial. Simulation material, such as ParticleProcessMaterial. Controls behavior rather than the mesh surface. A visible effect separately needs a draw-pass mesh with a surface material.

public uint GetSeed();

Returns Seed. Particle random seed. To preserve it across Restart, enable UseFixedSeed or pass keepSeed=true. The seed alone does not fix all simulation conditions and steps.

public double GetSpeedScale();

Returns SpeedScale. Simulation progression scale. Zero pauses ordinary progression but does not hide live geometry. Camera motion and transforms with LocalCoords can change the image while paused. Not rendering FPS. 1.0.0 timing limitation: after a long SpeedScale = 0 pause and resuming to 1, the tested one-shot can emit Finished while GPU particles are still visible. The scene timer multiplies accumulated elapsed time by the current speed scale; it is not a GPU-expiry fence. Do not recycle a time-scaled effect from this signal alone. Keeping a simple one-shot at fixed speed avoids this particular pause/resume case; validate a separate lifecycle policy when changing simulation time.

public EntityPath GetSubEmitter();

Returns SubEmitter. Path from this emitter to an existing target GpuParticles3D. Assign after both Entities exist; births also require the primary ProcessMaterial mode. Does not create an Entity per particle. Avoid self-links/cycles; revalidate after hierarchy changes.

public double GetTrailLifetime();

Returns TrailLifetime. History duration in seconds, not particle Lifetime or rest-mesh length. Minimum approximately 0.01; the current RD backend caps history at 10 seconds although the scene getter stores the request. Changes rebuild data/phase; account for motion, step and budget.

public GpuParticles3D.TransformAlignEnum GetTransformAlign();

Returns TransformAlign. Alignment of the rendered particle transform. YToVelocity is the example starting point for directional geometry/trails. Does not change velocity or guarantee freedom from twisting/flattening on every path.

public bool GetUseFixedSeed();

Returns UseFixedSeed. Preserves the assigned Seed during ordinary restarts. Helps repeat an effect but does not guarantee bitwise determinism across drivers, time steps or builds.

public bool GetUseLocalCoordinates();

Returns LocalCoords. If true, live particles follow the emitter transform; if false, spawned particles remain in world space as it moves. Choose the space before starting: switching a live effect does not guarantee preserving its appearance.

public Aabb GetVisibilityAabb();

Returns VisibilityAabb. Custom culling bound for the whole emitter. If offscreen, it can hide otherwise visible particles. Not current-frame CaptureAabb, a trajectory clamp or a collider; cover the entire effect and mesh sizes.

public bool IsEmitting();

Returns Emitting. Controls new particle births. False neither removes live particles nor pauses simulation; a one-shot can report false before its effect disappears. Use Restart for a new cycle: repeated true during an active one-shot can cancel its Finished notification.

public bool IsTrailEnabled();

Returns TrailEnabled. Enables trail history. Requires compatible mesh poses and UseParticleTrails on the effective surface. The current RenderingDevice rebuilds data when this setting is assigned; do not update it every frame as a cheap animation.

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

public void Restart();

Clears/restarts the cycle and enables emission. Can deliberately interrupt a live effect: waiting for Finished before every call is not required. A new seed is chosen only without UseFixedSeed and without keepSeed.

public void Restart(bool keepSeed = false);

Clears/restarts the cycle and enables emission. Can deliberately interrupt a live effect: waiting for Finished before every call is not required. A new seed is chosen only without UseFixedSeed and without keepSeed.

public void SetAmount(int amount);

Sets Amount. Capacity, at least 1. Changing it in the current RenderingDevice implementation frees particle data and resets phase for reallocation. Use AmountRatio for emission fraction without changing capacity. Not an exact visible-particle count.

public void SetAmountRatio(float ratio);

Sets AmountRatio. Emission fraction of allocated Amount; supply 0 to 1. Does not reduce allocated capacity or instantly remove live particles. Birth behavior also depends on the simulation material.

public void SetDrawPassMesh(int pass, Mesh mesh);

Sets the Mesh that is drawn at index pass.

public void SetEmitting(bool emitting);

Sets Emitting. Controls new particle births. False neither removes live particles nor pauses simulation; a one-shot can report false before its effect disappears. Use Restart for a new cycle: repeated true during an active one-shot can cancel its Finished notification.

public void SetExplosivenessRatio(float ratio);

Sets Explosiveness. Birth-interval compression: 0 distributes births through the cycle, 1 concentrates them at the burst start. Does not set travel velocity or ProcessMaterial forces.

public void SetFixedFps(int fps);

Fixed simulation-step rate, not a drawing frame-rate limit. A positive value selects steps of 1/FPS. At 0, current RD uses variable delta for ordinary particles, while trails can require an internal fixed step. Defaults to 30; the example explicitly selects 60.

public void SetFractionalDelta(bool enable);

Refines the DELTA fraction for a particle born within a step. This is neither general float precision nor draw interpolation. Current RD applies it during ordinary emission-phase calculation; do not assume identical effects for all manual/sub-emission paths.

public void SetInterpToEnd(float interp);

Value supplied to a particle shader as INTERPOLATE_TO_END, clamped to 0–1. Built-in ParticleProcessMaterial uses it in age calculation; a custom ShaderMaterial must apply it explicitly. It is neither Lifetime duration nor Interpolate frame smoothing.

public void SetInterpolate(bool enable);

Draw interpolation between simulation steps. It neither replaces FixedFps nor adds process() calls and is distinct from InterpToEnd. Current RD uses it when applying the time remainder to instance data.

public void SetLifetime(double secs);

Sets Lifetime. Lifetime/cycle duration in seconds, strictly greater than zero. Along with Amount and birth timing affects density; not the time until Emitting stops or an exact frame count.

public void SetOneShot(bool enable);

Sets OneShot. One cycle instead of looping. Finished reports one-shot completion, not every manual stop of a continuous emitter. An explosive cycle can stop spawning before its particles expire.

public void SetProcessMaterial(Material material);

Sets ProcessMaterial. Simulation material, such as ParticleProcessMaterial. Controls behavior rather than the mesh surface. A visible effect separately needs a draw-pass mesh with a surface material.

public void SetSeed(uint seed);

Sets Seed. Particle random seed. To preserve it across Restart, enable UseFixedSeed or pass keepSeed=true. The seed alone does not fix all simulation conditions and steps.

public void SetSpeedScale(double scale);

Sets SpeedScale. Simulation progression scale. Zero pauses ordinary progression but does not hide live geometry. Camera motion and transforms with LocalCoords can change the image while paused. Not rendering FPS. 1.0.0 timing limitation: after a long SpeedScale = 0 pause and resuming to 1, the tested one-shot can emit Finished while GPU particles are still visible. The scene timer multiplies accumulated elapsed time by the current speed scale; it is not a GPU-expiry fence. Do not recycle a time-scaled effect from this signal alone. Keeping a simple one-shot at fixed speed avoids this particular pause/resume case; validate a separate lifecycle policy when changing simulation time.

public void SetSubEmitter(EntityPath path);

Sets SubEmitter. Path from this emitter to an existing target GpuParticles3D. Assign after both Entities exist; births also require the primary ProcessMaterial mode. Does not create an Entity per particle. Avoid self-links/cycles; revalidate after hierarchy changes.

public void SetTrailEnabled(bool enabled);

Sets TrailEnabled. Enables trail history. Requires compatible mesh poses and UseParticleTrails on the effective surface. The current RenderingDevice rebuilds data when this setting is assigned; do not update it every frame as a cheap animation.

public void SetTrailLifetime(double secs);

Sets TrailLifetime. History duration in seconds, not particle Lifetime or rest-mesh length. Minimum approximately 0.01; the current RD backend caps history at 10 seconds although the scene getter stores the request. Changes rebuild data/phase; account for motion, step and budget.

public void SetTransformAlign(GpuParticles3D.TransformAlignEnum align);

Sets TransformAlign. Alignment of the rendered particle transform. YToVelocity is the example starting point for directional geometry/trails. Does not change velocity or guarantee freedom from twisting/flattening on every path.

public void SetUseFixedSeed(bool useFixedSeed);

Sets UseFixedSeed. Preserves the assigned Seed during ordinary restarts. Helps repeat an effect but does not guarantee bitwise determinism across drivers, time steps or builds.

public void SetUseLocalCoordinates(bool enable);

Sets LocalCoords. If true, live particles follow the emitter transform; if false, spawned particles remain in world space as it moves. Choose the space before starting: switching a live effect does not guarantee preserving its appearance.

public void SetVisibilityAabb(Aabb aabb);

Sets VisibilityAabb. Custom culling bound for the whole emitter. If offscreen, it can hide otherwise visible particles. Not current-frame CaptureAabb, a trajectory clamp or a collider; cover the entire effect and mesh sizes.

public event Action Finished;

One-shot cycle completion. Connect before triggering. Not a general disappearance event after manually stopping a continuous emitter; repeated Emitting=true during an active one-shot can cancel the notification. 1.0.0 timing limitation: after a long SpeedScale = 0 pause and resuming to 1, the tested one-shot can emit Finished while GPU particles are still visible. The scene timer multiplies accumulated elapsed time by the current speed scale; it is not a GPU-expiry fence. Do not recycle a time-scaled effect from this signal alone. Keeping a simple one-shot at fixed speed avoids this particular pause/resume case; validate a separate lifecycle policy when changing simulation time.

public const long MaxDrawPasses = 4;

Maximum number of draw passes supported.