ParticleProcessMaterial

public Texture2D AlphaCurve { get; set; }

The alpha value of each particle's color will be multiplied by this CurveTexture over its lifetime. Note: ParticleProcessMaterial.AlphaCurve multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.VertexColorUseAsAlbedo must be true. For a ShaderMaterial, ALPHA *= COLOR.a; must be inserted in the shader's fragment() function. Otherwise, ParticleProcessMaterial.AlphaCurve will have no visible effect.

public Texture2D AngleCurve { get; set; }

Each particle's rotation will be animated along this CurveTexture.

public float AngleMax { get; set; }

Maximum initial rotation applied to each particle, in degrees. Only applied when ParticleProcessMaterial.ParticleFlagDisableZ or ParticleProcessMaterial.ParticleFlagRotateY are true or the BaseMaterial3D being used to draw the particle is using BaseMaterial3D.BillboardModeEnum.Particles.

public float AngleMin { get; set; }

Minimum equivalent of ParticleProcessMaterial.AngleMax.

public Texture2D AngularVelocityCurve { get; set; }

Each particle's angular velocity (rotation speed) will vary along this CurveTexture over its lifetime.

public float AngularVelocityMax { get; set; }

Maximum initial angular velocity (rotation speed) applied to each particle in degrees per second. Only applied when ParticleProcessMaterial.ParticleFlagDisableZ or ParticleProcessMaterial.ParticleFlagRotateY are true or the BaseMaterial3D being used to draw the particle is using BaseMaterial3D.BillboardModeEnum.Particles.

public float AngularVelocityMin { get; set; }

Minimum equivalent of ParticleProcessMaterial.AngularVelocityMax.

public Texture2D AnimOffsetCurve { get; set; }

Each particle's animation offset will vary along this CurveTexture.

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 ParticleProcessMaterial.AnimOffsetMax.

public Texture2D AnimSpeedCurve { get; set; }

Each particle's animation speed will vary along this CurveTexture.

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 ParticleProcessMaterial.AnimSpeedMax.

public bool AttractorInteractionEnabled { get; set; }

Allows the material to use GPU-attractor forces. The flag alone is insufficient: an attractor in the same World3D, its region and matching render masks are required. Does not automatically connect Area3D gravity.

public float CollisionBounce { get; set; }

Bounce coefficient for Rigid response. Does not create a gameplay RigidBody for every particle or guarantee physically calibrated behavior.

public float CollisionFriction { get; set; }

Friction coefficient for Rigid response, separate from general motion damping. Not automatically a gameplay physics-body friction material.

public ParticleProcessMaterial.CollisionModeEnum CollisionMode { get; set; }

Response to GPU-particle colliders: Disabled for none, Rigid for material response, HideOnContact to remove visible particles on contact. Ordinary StaticBody is not connected automatically; a particle collider and matching render masks are required.

public bool CollisionUseScale { get; set; }

Allows particle scale to participate in collision-size calculation. Does not change collider geometry or update VisibilityAabb automatically.

public Color Color { get; set; }

Base simulation color, multiplying other color sources including point colors and ramps. Does not replace the surface material. A standard surface needs VertexColorUseAsAlbedo, usually with white albedo, to use particle color.

public Texture2D ColorInitialRamp { get; set; }

Gradient texture for randomized initial color selection in the standard material path. Modulates base Color; differs from ColorRamp sampled over lifetime. The surface material must use vertex color to show the result.

public Texture2D ColorRamp { get; set; }

Color gradient texture over normalized lifetime. Multiplies the base color and other sources. Alpha requires appropriate surface transparency; a simulation ramp alone does not enable alpha blending.

public Texture2D DampingCurve { get; set; }

Damping will vary along this CurveTexture.

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 ParticleProcessMaterial.DampingMax.

public Vector3 Direction { get; set; }

Initial emission direction; supply a nonzero vector. Spread sets angular variation, InitialVelocityMin/Max the initial-speed range. Not the continuous Gravity force.

public Texture2D DirectionalVelocityCurve { get; set; }

A curve that specifies the velocity along each of the axes of the particle system along its lifetime. Note: Animated velocities will not be affected by damping, use ParticleProcessMaterial.VelocityLimitCurve instead.

public float DirectionalVelocityMax { get; set; }

Maximum directional velocity value, which is multiplied by ParticleProcessMaterial.DirectionalVelocityCurve. Note: Animated velocities will not be affected by damping, use ParticleProcessMaterial.VelocityLimitCurve instead.

public float DirectionalVelocityMin { get; set; }

Minimum directional velocity value, which is multiplied by ParticleProcessMaterial.DirectionalVelocityCurve. Note: Animated velocities will not be affected by damping, use ParticleProcessMaterial.VelocityLimitCurve instead.

public Vector3 EmissionBoxExtents { get; set; }

The box's extents if ParticleProcessMaterial.EmissionShape is set to ParticleProcessMaterial.EmissionShapeEnum.Box. Note: ParticleProcessMaterial.EmissionBoxExtents starts from the center point and applies the X, Y, and Z values in both directions. The size is twice the area of the extents.

public Texture2D EmissionColorTexture { get; set; }

Optional valid-point colors using the same layout as EmissionPointTexture. Multiply Color and other color sources rather than replacing them. The mesh material must use particle vertex color to display them.

public Texture2D EmissionCurve { get; set; }

Each particle's color will be multiplied by this CurveTexture over its lifetime. Note: ParticleProcessMaterial.EmissionCurve 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, ParticleProcessMaterial.EmissionCurve will have no visible effect.

public Texture2D EmissionNormalTexture { get; set; }

Matching XYZ normals for DirectedPoints. Use the point texture layout and nonzero, normally unit directions. These are direct signed vectors, not an encoded surface normal map. Orients a frame; the example follows the normal using Direction +Z.

public int EmissionPointCount { get; set; }

Number of valid point-texture samples for Points/DirectedPoints. Use a positive value within actual data, excluding padding. Not the emitter Amount; increasing it does not generate new points.

public Texture2D EmissionPointTexture { get; set; }

XYZ birth positions per texel for Points/DirectedPoints in emitter-local coordinates. Float data preserves negative values; do not apply color sRGB conversion or lossy processing. Points are read row-major; EmissionPointCount specifies valid entries.

public Vector3 EmissionRingAxis { get; set; }

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

public float EmissionRingConeAngle { get; set; }

The angle of the cone when using the emitter ParticleProcessMaterial.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 ParticleProcessMaterial.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 ParticleProcessMaterial.EmissionShapeEnum.Ring.

public float EmissionRingInnerRadius { get; set; }

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

public float EmissionRingRadius { get; set; }

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

public ParticleProcessMaterial.EmissionShapeEnum EmissionShape { get; set; }

Initial-position distribution. Points selects a position from data; DirectedPoints also orients a local frame from a normal. Not the draw mesh or a collider. Texture sampling requires valid data and a positive EmissionPointCount.

public Vector3 EmissionShapeOffset { get; set; }

Local birth-position offset after EmissionShapeScale: position times scale plus offset. Does not move the emitter Entity or command relocation of every live particle.

public Vector3 EmissionShapeScale { get; set; }

Component-wise scale of local birth positions before EmissionShapeOffset. Changes layout, not drawn particle size or VisibilityAabb automatically. Use Scale parameters for geometry size.

public float EmissionSphereRadius { get; set; }

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

public float Flatness { get; set; }

Amount of ParticleProcessMaterial.Spread along the Y axis.

public Vector3 Gravity { get; set; }

Constant acceleration in simulation coordinates. The shown 2D effect uses Vector3(0,90,0), with positive Y pointing down. This is acceleration, not initial velocity; simulation already accounts for elapsed time. A new resource starts with the 3D-oriented value (0,-9.8,0), so configure 2D gravity explicitly.

public Texture2D HueVariationCurve { get; set; }

Each particle's hue will vary along this CurveTexture.

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 ParticleProcessMaterial.HueVariationMax.

public double InheritVelocityRatio { get; set; }

Percentage of the velocity of the respective GpuParticles2D or GpuParticles3D inherited by each particle when spawning.

public float InitialVelocityMax { get; set; }

Upper initial linear-speed bound. Coordinate with InitialVelocityMin; subsequent motion also depends on forces and other simulation settings.

public float InitialVelocityMin { get; set; }

Lower initial linear-speed bound. Coordinate with InitialVelocityMax. Equal values fix the initial magnitude, while direction can still have Spread.

public double LifetimeRandomness { get; set; }

Particle lifetime randomness ratio. The equation for the lifetime of a particle is lifetime * (1.0 - randf() * lifetime_randomness). For example, a ParticleProcessMaterial.LifetimeRandomness of 0.4 scales the lifetime between 0.6 to 1.0 of its original value.

public Texture2D LinearAccelCurve { get; set; }

Each particle's linear acceleration will vary along this CurveTexture.

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 ParticleProcessMaterial.LinearAccelMax.

public Texture2D OrbitVelocityCurve { get; set; }

Each particle's orbital velocity will vary along this CurveTexture. Note: For 3D orbital velocity, use a CurveXyzTexture. Note: Animated velocities will not be affected by damping, use ParticleProcessMaterial.VelocityLimitCurve instead.

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. Note: Animated velocities will not be affected by damping, use ParticleProcessMaterial.VelocityLimitCurve instead.

public float OrbitVelocityMin { get; set; }

Minimum equivalent of ParticleProcessMaterial.OrbitVelocityMax. Note: Animated velocities will not be affected by damping, use ParticleProcessMaterial.VelocityLimitCurve instead.

public bool ParticleFlagAlignY { get; set; }

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

public bool ParticleFlagDampingAsFriction { get; set; }

Changes the behavior of the damping properties from a linear deceleration to a deceleration based on speed percentage.

public bool ParticleFlagDisableZ { get; set; }

Constrains particle motion to the XY plane for a 2D effect. The example enables it explicitly before assignment. Editing this flag on a shared resource affects every system using that resource, not just one entity.

public bool ParticleFlagInheritEmitterScale { get; set; }

If true, particles will inherit the scale of the emitter. Note: This has no effect when GpuParticles3D.LocalCoords is true, since particles in local space are already affected by the emitter's scale.

public bool ParticleFlagPreserveColor { get; set; }

If true, preserves the color given by manual emission. To use when using GpuParticles3D.EmitParticle or when working with subemitters.

public bool ParticleFlagRotateY { get; set; }

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

public Texture2D RadialAccelCurve { get; set; }

Each particle's radial acceleration will vary along this CurveTexture.

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 ParticleProcessMaterial.RadialAccelMax.

public Texture2D RadialVelocityCurve { get; set; }

A CurveTexture that defines the velocity over the particle's lifetime away (or toward) the ParticleProcessMaterial.VelocityPivot. Note: Animated velocities will not be affected by damping, use ParticleProcessMaterial.VelocityLimitCurve instead.

public float RadialVelocityMax { get; set; }

Maximum radial velocity applied to each particle. Makes particles move away from the ParticleProcessMaterial.VelocityPivot, or toward it if negative. Note: Animated velocities will not be affected by damping, use ParticleProcessMaterial.VelocityLimitCurve instead.

public float RadialVelocityMin { get; set; }

Minimum radial velocity applied to each particle. Makes particles move away from the ParticleProcessMaterial.VelocityPivot, or toward it if negative. Note: Animated velocities will not be affected by damping, use ParticleProcessMaterial.VelocityLimitCurve instead.

public Vector3 Rotation3DMax { get; set; }

The maximum 3D orientation, in degrees. Works only in 3D and if ParticleProcessMaterial.UseRotation3D is enabled.

public Vector3 Rotation3DMin { get; set; }

The minimum 3D orientation, in degrees. Works only in 3D and if ParticleProcessMaterial.UseRotation3D is enabled.

public Texture2D RotationVelocity3DCurve { get; set; }

Rotation velocity curve over lifetime, per-axis. Enable ParticleProcessMaterial.UseRotationVelocity3D to use this.

public Vector3 RotationVelocity3DMax { get; set; }

Maximum 3D rotation velocity on the particle's local axis. Enable ParticleProcessMaterial.UseRotationVelocity3D to use this.

public Vector3 RotationVelocity3DMin { get; set; }

Minimum 3D rotation velocity on the particle's local axis. Enable ParticleProcessMaterial.UseRotationVelocity3D to use this.

public Vector2 Scale { get; set; }

Base particle scale range as a Vector2 minimum/maximum pair. Does not change the birth-position distribution controlled by EmissionShapeScale. Final size also depends on ScaleCurve and the drawing path.

public Vector3 Scale3DMax { get; set; }

The maximum value of the random scale vector for each particle. Works only if ParticleProcessMaterial.UseScale3D is enabled.

public Vector3 Scale3DMin { get; set; }

The minimum value of the random scale vector for each particle. Works only if ParticleProcessMaterial.UseScale3D is enabled.

public Texture2D ScaleCurve { get; set; }

Curve texture multiplying base scale over normalized lifetime. An ordinary CurveTexture at constant 0.5 in the example reduces base scale 2 to 1. Do not infer that all other properties apply curves multiplicatively.

public float ScaleMax { get; set; }

Upper base particle-geometry scale bound. Coordinate with ScaleMin; the result depends on ScaleCurve, transforms and surface billboard mode. Keep Size is not a universal prerequisite for scaling.

public float ScaleMin { get; set; }

Lower base particle-geometry scale bound. Matching ScaleMax removes this random range, not other variation sources. ScaleCurve multiplies the resulting scale; EmissionShapeScale instead changes birth positions.

public Texture2D ScaleOverVelocityCurve { get; set; }

Either a CurveTexture or a CurveXyzTexture that scales each particle based on its velocity.

public float ScaleOverVelocityMax { get; set; }

Maximum velocity value reference for ParticleProcessMaterial.ScaleOverVelocityCurve. ParticleProcessMaterial.ScaleOverVelocityCurve will be interpolated between ParticleProcessMaterial.ScaleOverVelocityMin and ParticleProcessMaterial.ScaleOverVelocityMax.

public float ScaleOverVelocityMin { get; set; }

Minimum velocity value reference for ParticleProcessMaterial.ScaleOverVelocityCurve. ParticleProcessMaterial.ScaleOverVelocityCurve will be interpolated between ParticleProcessMaterial.ScaleOverVelocityMin and ParticleProcessMaterial.ScaleOverVelocityMax.

public float Spread { get; set; }

Initial-direction spread in degrees. Not emitter Randomness, which changes birth timing, or the initial-speed range.

public int SubEmitterAmountAtCollision { get; set; }

Requested target births for a qualifying primary-particle contact in AtCollision. Without working CollisionMode/GPU collider setup the trigger is not established. Not gameplay physics signals.

public int SubEmitterAmountAtEnd { get; set; }

Requested target births at each primary particle end-of-life event in AtEnd. A visible second stage does not imply a new Entity; target capacity remains separate.

public int SubEmitterAmountAtStart { get; set; }

Requested target births per primary-particle birth event in AtStart. Not a global count for the whole system; target Amount and other limits still apply.

public double SubEmitterFrequency { get; set; }

Constant frequency in Hz for an active primary particle. Supply a finite positive number: the setter passes its reciprocal interval to the shader. Simulation steps constrain execution; not an exact arbitrary-frequency guarantee independent of FPS.

public bool SubEmitterKeepVelocity { get; set; }

Forwards primary velocity in the target birth request. In the current shader path, forwarded velocity can replace target initial-velocity initialization; do not assume simple addition of all target settings.

public ParticleProcessMaterial.SubEmitterModeEnum SubEmitterMode { get; set; }

Birth trigger for the assigned GpuParticles3D.SubEmitter: Disabled, Constant, AtStart, AtEnd or AtCollision. A mode without a valid link is insufficient. AtCollision requires GPU collision; Compatibility does not support active modes in current code.

public Texture2D TangentialAccelCurve { get; set; }

Each particle's tangential acceleration will vary along this CurveTexture.

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 ParticleProcessMaterial.TangentialAccelMax.

public bool TurbulenceEnabled { get; set; }

Enables the procedural turbulence field that redirects GPU particle motion. It does not itself supply initial speed; birth displacement is configured separately.

public Vector2 TurbulenceInfluence { get; set; }

Range of steering influence: X is the minimum and Y the maximum. The per-particle value is multiplied by TurbulenceInfluenceOverLife and clamped to 0–1 for steering; this range does not disable birth displacement.

public float TurbulenceInfluenceMax { get; set; }

Upper bound of the per-particle steering influence. Equal Min and Max remove variation from this setting; greater influence does not guarantee greater speed.

public float TurbulenceInfluenceMin { get; set; }

Lower bound of the per-particle steering influence. Zero Min and Max suppress steering, but do not suppress TurbulenceInitialDisplacement.

public Texture2D TurbulenceInfluenceOverLife { get; set; }

Texture multiplier for steering influence over normalized particle age: X=0 at birth, X=1 at death; the red channel is sampled. With no texture the multiplier is 1. A zero curve suppresses steering, but not birth displacement.

public Vector2 TurbulenceInitialDisplacement { get; set; }

Range of one-time birth displacement: X is the minimum and Y the maximum. The offset follows the noise-derived direction, is not a velocity, and can apply with zero ongoing steering influence.

public float TurbulenceInitialDisplacementMax { get; set; }

Upper bound of the one-time birth displacement along the noise-derived direction. Zero Min and Max disable this offset without disabling steering.

public float TurbulenceInitialDisplacementMin { get; set; }

Lower bound of the one-time birth displacement along the noise-derived direction. Used with turbulence enabled; it does not supply ongoing motion.

public float TurbulenceNoiseScale { get; set; }

Nonlinear control of spatial noise detail. It is neither a distance in meters nor a direct spatial frequency; tune it against the trajectory while keeping other settings fixed.

public Vector3 TurbulenceNoiseSpeed { get; set; }

Motion of the noise field over time, not particle velocity. For a static field, use Vector3.Zero and also set TurbulenceNoiseSpeedRandom to zero.

public float TurbulenceNoiseSpeedRandom { get; set; }

Time variation in the procedural noise additional coordinate. A nonzero value can animate the field even when TurbulenceNoiseSpeed is Vector3.Zero.

public float TurbulenceNoiseStrength { get; set; }

Contrast and directional detail of the procedural noise. This is not a direct particle force or speed; increasing it does not guarantee acceleration.

public bool UseRotation3D { get; set; }

Enable the usage of ParticleProcessMaterial.Rotation3DMin and ParticleProcessMaterial.Rotation3DMax.

public bool UseRotationVelocity3D { get; set; }

Enable 3D rotation velocity.

public bool UseScale3D { get; set; }

Enable the usage of ParticleProcessMaterial.Scale3DMin and ParticleProcessMaterial.Scale3DMax.

public Texture2D VelocityLimitCurve { get; set; }

A CurveTexture that defines the maximum velocity of a particle during its lifetime.

public Vector3 VelocityPivot { get; set; }

A pivot point used to calculate radial and orbital velocity of particles.

public ParticleProcessMaterial.CollisionModeEnum GetCollisionMode();

Returns CollisionMode. Response to GPU-particle colliders: Disabled for none, Rigid for material response, HideOnContact to remove visible particles on contact. Ordinary StaticBody is not connected automatically; a particle collider and matching render masks are required.

public Color GetColor();

Returns Color. Base simulation color, multiplying other color sources including point colors and ramps. Does not replace the surface material. A standard surface needs VertexColorUseAsAlbedo, usually with white albedo, to use particle color.

public Texture2D GetEmissionColorTexture();

Returns EmissionColorTexture. Optional valid-point colors using the same layout as EmissionPointTexture. Multiply Color and other color sources rather than replacing them. The mesh material must use particle vertex color to display them.

public Texture2D GetEmissionNormalTexture();

Returns EmissionNormalTexture. Matching XYZ normals for DirectedPoints. Use the point texture layout and nonzero, normally unit directions. These are direct signed vectors, not an encoded surface normal map. Orients a frame; the example follows the normal using Direction +Z.

public int GetEmissionPointCount();

Returns EmissionPointCount. Number of valid point-texture samples for Points/DirectedPoints. Use a positive value within actual data, excluding padding. Not the emitter Amount; increasing it does not generate new points.

public Texture2D GetEmissionPointTexture();

Returns EmissionPointTexture. XYZ birth positions per texel for Points/DirectedPoints in emitter-local coordinates. Float data preserves negative values; do not apply color sRGB conversion or lossy processing. Points are read row-major; EmissionPointCount specifies valid entries.

public ParticleProcessMaterial.EmissionShapeEnum GetEmissionShape();

Returns EmissionShape. Initial-position distribution. Points selects a position from data; DirectedPoints also orients a local frame from a normal. Not the draw mesh or a collider. Texture sampling requires valid data and a positive EmissionPointCount.

public Vector3 GetEmissionShapeOffset();

Returns EmissionShapeOffset. Local birth-position offset after EmissionShapeScale: position times scale plus offset. Does not move the emitter Entity or command relocation of every live particle.

public Vector3 GetEmissionShapeScale();

Returns EmissionShapeScale. Component-wise scale of local birth positions before EmissionShapeOffset. Changes layout, not drawn particle size or VisibilityAabb automatically. Use Scale parameters for geometry size.

public Vector2 GetParam(ParticleProcessMaterial.Parameter param);

Returns the minimum and maximum values of the given param as a vector. The x component of the returned vector corresponds to minimum and the y component corresponds to maximum.

public float GetParamMax(ParticleProcessMaterial.Parameter param);

Returns the maximum value range for the given parameter.

public float GetParamMin(ParticleProcessMaterial.Parameter param);

Returns the minimum value range for the given parameter.

public Texture2D GetParamTexture(ParticleProcessMaterial.Parameter param);

Returns the Texture2D used by the specified parameter.

public bool GetParticleFlag(ParticleProcessMaterial.ParticleFlags particleFlag);

Returns true if the specified particle flag is enabled.

public int GetSubEmitterAmountAtCollision();

Returns SubEmitterAmountAtCollision. Requested target births for a qualifying primary-particle contact in AtCollision. Without working CollisionMode/GPU collider setup the trigger is not established. Not gameplay physics signals.

public int GetSubEmitterAmountAtEnd();

Returns SubEmitterAmountAtEnd. Requested target births at each primary particle end-of-life event in AtEnd. A visible second stage does not imply a new Entity; target capacity remains separate.

public int GetSubEmitterAmountAtStart();

Returns SubEmitterAmountAtStart. Requested target births per primary-particle birth event in AtStart. Not a global count for the whole system; target Amount and other limits still apply.

public double GetSubEmitterFrequency();

Returns SubEmitterFrequency. Constant frequency in Hz for an active primary particle. Supply a finite positive number: the setter passes its reciprocal interval to the shader. Simulation steps constrain execution; not an exact arbitrary-frequency guarantee independent of FPS.

public bool GetSubEmitterKeepVelocity();

Returns SubEmitterKeepVelocity. Forwards primary velocity in the target birth request. In the current shader path, forwarded velocity can replace target initial-velocity initialization; do not assume simple addition of all target settings.

public ParticleProcessMaterial.SubEmitterModeEnum GetSubEmitterMode();

Returns SubEmitterMode. Birth trigger for the assigned GpuParticles3D.SubEmitter: Disabled, Constant, AtStart, AtEnd or AtCollision. A mode without a valid link is insufficient. AtCollision requires GPU collision; Compatibility does not support active modes in current code.

public bool GetTurbulenceEnabled();

Returns the stored setting. Enables the procedural turbulence field that redirects GPU particle motion. It does not itself supply initial speed; birth displacement is configured separately.

public float GetTurbulenceNoiseScale();

Returns the stored setting. Nonlinear control of spatial noise detail. It is neither a distance in meters nor a direct spatial frequency; tune it against the trajectory while keeping other settings fixed.

public Vector3 GetTurbulenceNoiseSpeed();

Returns the stored setting. Motion of the noise field over time, not particle velocity. For a static field, use Vector3.Zero and also set TurbulenceNoiseSpeedRandom to zero.

public float GetTurbulenceNoiseSpeedRandom();

Returns the stored setting. Time variation in the procedural noise additional coordinate. A nonzero value can animate the field even when TurbulenceNoiseSpeed is Vector3.Zero.

public float GetTurbulenceNoiseStrength();

Returns the stored setting. Contrast and directional detail of the procedural noise. This is not a direct particle force or speed; increasing it does not guarantee acceleration.

public bool IsAttractorInteractionEnabled();

Returns AttractorInteractionEnabled. Allows the material to use GPU-attractor forces. The flag alone is insufficient: an attractor in the same World3D, its region and matching render masks are required. Does not automatically connect Area3D gravity.

public void SetAttractorInteractionEnabled(bool enabled);

Sets AttractorInteractionEnabled. Allows the material to use GPU-attractor forces. The flag alone is insufficient: an attractor in the same World3D, its region and matching render masks are required. Does not automatically connect Area3D gravity.

public void SetCollisionMode(ParticleProcessMaterial.CollisionModeEnum mode);

Sets CollisionMode. Response to GPU-particle colliders: Disabled for none, Rigid for material response, HideOnContact to remove visible particles on contact. Ordinary StaticBody is not connected automatically; a particle collider and matching render masks are required.

public void SetColor(Color color);

Sets Color. Base simulation color, multiplying other color sources including point colors and ramps. Does not replace the surface material. A standard surface needs VertexColorUseAsAlbedo, usually with white albedo, to use particle color.

public void SetEmissionColorTexture(Texture2D texture);

Sets EmissionColorTexture. Optional valid-point colors using the same layout as EmissionPointTexture. Multiply Color and other color sources rather than replacing them. The mesh material must use particle vertex color to display them.

public void SetEmissionNormalTexture(Texture2D texture);

Sets EmissionNormalTexture. Matching XYZ normals for DirectedPoints. Use the point texture layout and nonzero, normally unit directions. These are direct signed vectors, not an encoded surface normal map. Orients a frame; the example follows the normal using Direction +Z.

public void SetEmissionPointCount(int pointCount);

Sets EmissionPointCount. Number of valid point-texture samples for Points/DirectedPoints. Use a positive value within actual data, excluding padding. Not the emitter Amount; increasing it does not generate new points.

public void SetEmissionPointTexture(Texture2D texture);

Sets EmissionPointTexture. XYZ birth positions per texel for Points/DirectedPoints in emitter-local coordinates. Float data preserves negative values; do not apply color sRGB conversion or lossy processing. Points are read row-major; EmissionPointCount specifies valid entries.

public void SetEmissionShape(ParticleProcessMaterial.EmissionShapeEnum shape);

Sets EmissionShape. Initial-position distribution. Points selects a position from data; DirectedPoints also orients a local frame from a normal. Not the draw mesh or a collider. Texture sampling requires valid data and a positive EmissionPointCount.

public void SetEmissionShapeOffset(Vector3 emissionShapeOffset);

Sets EmissionShapeOffset. Local birth-position offset after EmissionShapeScale: position times scale plus offset. Does not move the emitter Entity or command relocation of every live particle.

public void SetEmissionShapeScale(Vector3 emissionShapeScale);

Sets EmissionShapeScale. Component-wise scale of local birth positions before EmissionShapeOffset. Changes layout, not drawn particle size or VisibilityAabb automatically. Use Scale parameters for geometry size.

public void SetParam(ParticleProcessMaterial.Parameter param, Vector2 value);

Sets the minimum and maximum values of the given param. The x component of the argument vector corresponds to minimum and the y component corresponds to maximum.

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

Sets the maximum value range for the given parameter.

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

Sets the minimum value range for the given parameter.

public void SetParamTexture(ParticleProcessMaterial.Parameter param, Texture2D texture);

Sets the Texture2D for the specified ParticleProcessMaterial.Parameter.

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

Sets the particle_flag to enable.