UnityEngine.ParticleSystemModule

Information about a particle collision.

The Collider for the GameObject struck by the particles.

The Collider or Collider2D for the GameObject struck by the particles.

Intersection point of the collision in world coordinates.

Geometry normal at the intersection point of the collision.

Incident velocity at the intersection point of the collision.

Method extension for Physics in Particle System.

Get the particle collision events for a GameObject. Returns the number of events written to the array.

The GameObject for which to retrieve collision events. Array to write collision events to. The Particle System that owns the potentially colliding particles. The number of collision events.

Get the particle collision events for a GameObject. Returns the number of events written to the array.

The GameObject for which to retrieve collision events. Array to write collision events to. The Particle System that owns the potentially colliding particles. The number of collision events.

Safe array size for use with ParticleSystem.GetCollisionEvents.

Safe array size for use with ParticleSystem.GetTriggerParticles.

Particle system. Type of trigger to return size for. Number of particles with this trigger event type.

Get the particles that met the condition in the particle trigger module. Returns the number of particles written to the array.

Particle system. Type of trigger to return particles for. The array of particles matching the trigger event type. Number of particles with this trigger event type.

Write modified particles back to the Particle System, during a call to OnParticleTrigger.

Particle system. Type of trigger to set particles for. Particle array. Offset into the array, if you only want to write back a subset of the returned particles. Number of particles to write, if you only want to write back a subset of the returned particles.

Write modified particles back to the Particle System, during a call to OnParticleTrigger.

Script interface for ParticleSystem. Unity's powerful and versatile particle system implementation.

Does this system support Automatic Culling?

Script interface for the CollisionModule of a Particle System.

Script interface for the ColorByLifetimeModule of a Particle System.

Script interface for the ColorOverLifetimeModule of a Particle System.

Script interface for the CustomDataModule of a Particle System.

The duration of the Particle System in seconds (Read Only).

Script interface for the EmissionModule of a Particle System.

The rate of particle emission.

When set to false, the Particle System will not emit particles.

Script interface for the ExternalForcesModule of a Particle System.

Script interface for the ForceOverLifetimeModule of a Particle System.

Scale being applied to the gravity defined by Physics.gravity.

Script interface for the InheritVelocityModule of a Particle System.

Determines whether the Particle System is emitting particles. A Particle System may stop emitting when its emission module has finished, it has been paused or if the system has been stopped using ParticleSystem.Stop|Stop with the ParticleSystemStopBehavior.StopEmitting|StopEmitting flag. Resume emitting by calling ParticleSystem.Play|Play.

Determines whether the Particle System is paused.

Determines whether the Particle System is playing.

Determines whether the Particle System is in the stopped state.

Script interface for the Particle System Lifetime By Emitter Speed module.

Script interface for the LightsModule of a Particle System.

Script interface for the LimitVelocityOverLifetimeModule of a Particle System. .

Determines whether the Particle System is looping.

Access the main Particle System settings.

The maximum number of particles to emit.

Script interface for the NoiseModule of a Particle System.

The current number of particles (Read Only). The number doesn't include particles of child Particle Systems

The playback speed of the Particle System. 1 is normal playback speed.

If set to true, the Particle System will automatically start playing on startup.

Does this system support Procedural Simulation?

Override the random seed used for the Particle System emission.

Script interface for the RotationBySpeedModule of a Particle System.

Script interface for the RotationOverLifetimeModule of a Particle System.

The scaling mode applied to particle sizes and positions.

Script interface for the ShapeModule of a Particle System.

This selects the space in which to simulate particles. It can be either world or local space.

Script interface for the SizeBySpeedModule of a Particle System.

Script interface for the SizeOverLifetimeModule of a Particle System.

The initial color of particles when emitted.

Start delay in seconds.

The total lifetime in seconds that particles will have when emitted. When using curves, this value acts as a scale on the curve. This value is set in the particle when it is created by the Particle System.

The initial rotation of particles when emitted. When using curves, this value acts as a scale on the curve.

The initial 3D rotation of particles when emitted. When using curves, this value acts as a scale on the curves.

The initial size of particles when emitted. When using curves, this value acts as a scale on the curve.

The initial speed of particles when emitted. When using curves, this value acts as a scale on the curve.

Script interface for the SubEmittersModule of a Particle System.

Script interface for the TextureSheetAnimationModule of a Particle System.

Playback position in seconds.

Script interface for the TrailsModule of a Particle System.

Script interface for the TriggerModule of a Particle System.

Controls whether the Particle System uses an automatically-generated random number to seed the random number generator.

Script interface for the VelocityOverLifetimeModule of a Particle System.

Ensures that the ParticleSystemJobs.ParticleSystemJobData._axisOfRotations|axisOfRotations particle attribute array is allocated.

Ensures that the ParticleSystemJobs.ParticleSystemJobData.customData1|customData1 and ParticleSystemJobs.ParticleSystemJobData.customData1|customData2 particle attribute arrays are allocated.

The custom data stream to allocate.

Ensures that the ParticleSystemJobs.ParticleSystemJobData._meshIndices|meshIndices particle attribute array is allocated.

Script interface for a Burst.

Specify the number of particles to emit.

Specifies how many times the system should play the burst. Set this to 0 to make it play indefinitely.

The maximum number of particles to emit.

The minimum number of particles to emit.

The probability that the system triggers a burst.

How often to repeat the burst, in seconds.

The time that each burst occurs.

Construct a new Burst with a time and count.

Time to emit the burst. Minimum number of particles to emit. Maximum number of particles to emit. Number of particles to emit. Specifies how many times the system should play the burst. Set this to 0 to make it play indefinitely. How often to repeat the burst, in seconds.

Construct a new Burst with a time and count.

Remove all particles in the Particle System.

Clear all child Particle Systems as well.

Remove all particles in the Particle System.

Clear all child Particle Systems as well.

Script interface for particle Collider data.

Retrieve a specific Collider that a particle iss interacting with.

The index of the particle event. The index of the collider to obtain. The Collider or Collider2D Component that a particle is interacting with.

Returns how how many Colliders a particle is interacting with.

The index of the particle event. The number of Colliders the particle is interacting with.

Script interface for the CollisionMmodule of a Particle System.

How much force is applied to each particle after a collision.

A multiplier for ParticleSystem.CollisionModule._bounce.

How much force is applied to a Collider when hit by particles from this Particle System.

Control which Layers this Particle System collides with.

How much speed does each particle lose after a collision.

Change the dampen multiplier.

Specifies whether the CollisionModule is enabled or disabled.

Allow particles to collide with dynamic colliders when using world collision mode.

Allow particles to collide when inside colliders.

How much a collision reduces a particle's lifetime.

Change the lifetime loss multiplier.

The maximum number of collision shapes Unity considers for particle collisions. It ignores excess shapes. Terrains take priority.

Kill particles whose speed goes above this threshold, after a collision.

The maximum number of planes it is possible to set as colliders.

Kill particles whose speed falls below this threshold, after a collision.

Choose between 2D and 3D world collisions.

Specifies whether the physics system considers the collision angle when it applies forces from particles to Colliders.

Specifies whether the physics system considers particle sizes when it applies forces to Colliders.

Specifies whether the physics system considers particle speeds when it applies forces to Colliders.

Shows the number of planes currently set as Colliders.

Specifies the accuracy of particle collisions against colliders in the Scene.

A multiplier that Unity applies to the size of each particle before collisions are processed.

Send collision callback messages.

The type of particle collision to perform.

Size of voxels in the collision cache.

Adds a collision plane to use with this Particle System.

The plane to add.

Get a collision plane associated with this Particle System.

The plane to return. The plane.

Removes a collision plane associated with this Particle System.

The collision plane to remove.

Removes a collision plane associated with this Particle System.

The collision plane to remove.

Set a collision plane to use with this Particle System.

The plane entry to set. The plane to collide particles against.

Script interface for the ColorBySpeedModule of a Particle System.

The gradient that controls the particle colors.

Specifies whether the ColorBySpeedModule is enabled or disabled.

Apply the color gradient between these minimum and maximum speeds.

Script interface for the ColorOverLifetimeModule of a Particle System.

The gradient that controls the particle colors.

Specifies whether the ColorOverLifetimeModule is enabled or disabled.

Script interface for the CustomDataModule of a Particle System.

Specifies whether the CustomDataModule is enabled or disabled.

Get a ParticleSystem.MinMaxGradient, that is being used to generate custom HDR color data.

The name of the custom data stream to retrieve the gradient from. The color gradient being used to generate custom color data.

Find out the type of custom data that is being generated for the chosen data stream.

The name of the custom data stream to query. The type of data being generated for the requested stream.

Get a ParticleSystem.MinMaxCurve, that is being used to generate custom data.

The name of the custom data stream to retrieve the curve from. The component index to retrieve the curve for (0-3, mapping to the xyzw components of a Vector4 or float4). The curve being used to generate custom data.

Query how many ParticleSystem.MinMaxCurve elements are being used to generate this stream of custom data.

The name of the custom data stream to retrieve the curve from. The number of curves.

Set a ParticleSystem.MinMaxGradient, in order to generate custom HDR color data.

The name of the custom data stream to apply the gradient to. The gradient to be used for generating custom color data.

Choose the type of custom data to generate for the chosen data stream.

The name of the custom data stream to enable data generation on. The type of data to generate.

Set a ParticleSystem.MinMaxCurve, in order to generate custom data.

The name of the custom data stream to apply the curve to. The component index to apply the curve to (0-3, mapping to the xyzw components of a Vector4 or float4). The curve to be used for generating custom data.

Specify how many curves are used to generate custom data for this stream.

The name of the custom data stream to apply the curve to. The number of curves to generate data for.

Script interface for the EmissionModule of a Particle System.

The current number of bursts.

Specifies whether the EmissionModule is enabled or disabled.

The rate at which the system spawns new particles.

Change the rate multiplier.

The rate at which the emitter spawns new particles over distance.

Change the rate over distance multiplier.

The rate at which the emitter spawns new particles over time.

Change the rate over time multiplier.

The emission type.

Gets a single burst from the array of bursts.

The index of the burst to retrieve. The burst data at the given index.

Gets the burst array.

Array of bursts to fill. The number of bursts in the array.

Sets a single burst in the array of bursts.

The index of the burst to set. The new burst data to apply to the Particle System.

Sets the burst array.

Array of bursts. Optional array size for if the burst count is less than the array size.

Sets the burst array.

Array of bursts. Optional array size for if the burst count is less than the array size.

Emit count particles immediately.

Number of particles to emit.

Emit a number of particles from script.

Overidden particle properties. Number of particles to emit.

Script interface for Particle System emission parameters.

Override the angular velocity of particles this system emits.

Override the 3D angular velocity of particles this system emits.

When overriding the position of particles, setting this flag to true allows you to retain the influence of the shape module.

Override the axis of rotation of particles this system emits.

Set the index that specifies which Mesh to emit.

Override all the properties of particles this system emits.

Override the position of particles this system emits.

Override the random seed of particles this system emits.

Override the rotation of particles this system emits.

Override the 3D rotation of particles this system emits.

Override the initial color of particles this system emits.

Override the lifetime of particles this system emits.

Override the initial size of particles this system emits.

Override the initial 3D size of particles this system emits.

Override the velocity of particles this system emits.

Reverts angularVelocity and angularVelocity3D back to the values specified in the Inspector.

Revert the axis of rotation back to the value specified in the Inspector.

Revert the Mesh selection back to the default randomized behavior.

Revert the position back to the value specified in the Inspector.

Revert the random seed back to the value specified in the Inspector.

Reverts rotation and rotation3D back to the values specified in the Inspector.

Revert the initial color back to the value specified in the Inspector.

Revert the lifetime back to the value specified in the Inspector.

Revert the initial size back to the value specified in the Inspector.

Revert the velocity back to the value specified in the Inspector.

Script interface for the ExternalForcesModule of a Particle System.

Specifies whether the ExternalForcesModule is enabled or disabled.

The number of Force Fields explicitly provided to the influencers list.

Apply all Force Fields belonging to a matching Layer to this Particle System.

Particle System Force Field Components with a matching Layer affect this Particle System.

Multiplies the magnitude of external forces affecting the particles.

Multiplies the magnitude of applied external forces.

Adds a ParticleSystemForceField to the influencers list.

The Force Field to add to the influencers list.

Gets the ParticleSystemForceField at the given index in the influencers list.

The index to return the chosen Force Field from. The ForceField from the list.

Determines whether any particles are inside the influence of a Force Field.

The Force Field to test. Whether the Force Field affects the Particle System.

Removes every Force Field from the influencers list.

Removes the Force Field from the influencers list at the given index.

The index to remove the chosen Force Field from. The Force Field to remove from the list.

Removes the Force Field from the influencers list at the given index.

The index to remove the chosen Force Field from. The Force Field to remove from the list.

Assigns the Force Field at the given index in the influencers list.

Index to assign the Force Field. Force Field that to assign.

Script interface for the ForceOverLifetimeModule of a Particle System.

Specifies whether the ForceOverLifetimeModule is enabled or disabled.

When randomly selecting values between two curves or constants, this flag causes the system to choose a new random force on each frame.

Specifies whether the modules applies the forces in local or world space.

The curve that defines particle forces in the x-axis.

Defines the x-axis multiplier.

The curve defining particle forces in the y-axis.

Defines the y-axis multiplier.

The curve defining particle forces in the z-axis.

Defines the z-axis multiplier.

Get a stream of custom per-particle data.

The array of per-particle data. Which stream to retrieve the data from. The amount of valid per-particle data.

Gets the particles of this Particle System.

Output particle buffer, containing the current particle state. The number of elements that are read from the Particle System. The offset into the active particle list, from which to copy the particles. The number of particles written to the input particle array (the number of particles currently alive).

Gets the particles of this Particle System.

Returns all the data that relates to the current internal state of the Particle System.

The current internal state of the Particle System.

Returns all the data relating to the current internal state of the Particle System Trails.

The variable to populate with the Trails that currently belong to the Particle System..

If you want to restore the Particle System to its current state in the future, store the Trails this function returns along with ParticleSystem.GetParticles and ParticleSystem.GetPlaybackState. This method allows you to get the trail data without creating any garbage, if you presize the trail data. See Also: Trails, SetTrails, GetPlaybackState.

The current Trails belonging to the Particle System. The number of trails.

The Inherit Velocity Module controls how the velocity of the emitter is transferred to the particles as they are emitted.

Curve to define how much of the emitter velocity the system applies during the lifetime of a particle.

Change the curve multiplier.

Specifies whether the InheritVelocityModule is enabled or disabled.

Specifies how to apply emitter velocity to particles.

Does the Particle System contain any live particles, or will it produce more?

Check all child Particle Systems as well. True if the Particle System contains live particles or is still creating new particles. False if the Particle System has stopped emitting particles and all particles are dead.

Does the Particle System contain any live particles, or will it produce more?

The Lifetime By Emitter Speed Module controls the initial lifetime of each particle based on the speed of the emitter when the particle was spawned.

Use this curve to define which value to multiply the start lifetime of a particle with, based on the speed of the emitter when the particle is spawned.

Use this property to change the curve multiplier.

Use this property to enable or disable the LifetimeByEmitterSpeed module.

Control the start lifetime multiplier between these minimum and maximum speeds of the emitter.

Access the ParticleSystem Lights Module.

Toggle whether the system multiplies the particle alpha by the light intensity when it computes the final light intensity.

Specifies whether the LightsModule is enabled or disabled.

Define a curve to apply custom intensity scaling to particle Lights.

Intensity multiplier.

Select what Light Prefab you want to base your particle lights on.

Set a limit on how many Lights this Module can create.

Define a curve to apply custom range scaling to particle Lights.

Range multiplier.

Choose what proportion of particles receive a dynamic light.

Toggle whether the system multiplies the particle size by the light range to determine the final light range.

Toggle whether the particle lights multiply their color by the particle color.

Randomly assign Lights to new particles based on ParticleSystem.LightsModule.ratio.

Script interface for the Limit Velocity Over Lifetime module.

Controls how much this module dampens particle velocities that exceed the velocity limit.

Controls the amount of drag that this modules applies to the particle velocities.

Specifies the drag multiplier.

Specifies whether the LimitForceOverLifetimeModule is enabled or disabled.

Maximum velocity curve, when not using one curve per axis.

Change the limit multiplier.

Maximum velocity curve for the x-axis.

Change the limit multiplier on the x-axis.

Maximum velocity curve for the y-axis.

Change the limit multiplier on the y-axis.

Maximum velocity curve for the z-axis.

Change the limit multiplier on the z-axis.

Adjust the amount of drag this module applies to particles, based on their sizes.

Adjust the amount of drag this module applies to particles, based on their speeds.

Set the velocity limit on each axis separately. This module uses ParticleSystem.LimitVelocityOverLifetimeModule._drag to dampen a particle's velocity if the velocity exceeds this value.

Specifies if the velocity limits are in local space (rotated with the transform) or world space.

Script interface for the MainModule of a Particle System.

Configure whether the Particle System will still be simulated each frame, when it is offscreen.

Simulate particles relative to a custom transform component.

The duration of the Particle System in seconds.

The current Particle System velocity.

Control how the Particle System calculates its velocity, when moving in the world.

Makes some particles spin in the opposite direction.

A scale that this Particle System applies to gravity, defined by Physics.gravity.

Change the gravity multiplier.

Specifies whether the Particle System is looping.

The maximum number of particles to emit.

If set to true, the Particle System automatically begins to play on startup.

If ParticleSystem.MainModule._loop is true, when you enable this property, the Particle System looks like it has already simulated for one loop when first becoming visible.

Cause some particles to spin in the opposite direction.

When ParticleSystem.MainModule.ringBufferMode is set to loop, this value defines the proportion of the particle life that loops.

Configure the Particle System to not kill its particles when their lifetimes are exceeded.

Control how the Particle System applies its Transform component to the particles it emits.

This selects the space in which to simulate particles. It can be either world or local space.

Override the default playback speed of the Particle System.

The initial color of particles when the Particle System first spawns them.

Start delay in seconds.

A multiplier for ParticleSystem.MainModule._startDelay in seconds.

The total lifetime in seconds that each new particle has.

A multiplier for ParticleSystem.MainModule._startLifetime.

The initial rotation of particles when the Particle System first spawns them.

A flag to enable 3D particle rotation.

A multiplier for ParticleSystem.MainModule._startRotation.

The initial rotation of particles around the x-axis when emitted.

The initial rotation multiplier of particles around the x-axis when the Particle System first spawns them.

The initial rotation of particles around the y-axis when the Particle System first spawns them.

The initial rotation multiplier of particles around the y-axis when the Particle System first spawns them..

The initial rotation of particles around the z-axis when the Particle System first spawns them

The initial rotation multiplier of particles around the z-axis when the Particle System first spawns them.

The initial size of particles when the Particle System first spawns them.

A flag to enable specifying particle size individually for each axis.

A multiplier for the initial size of particles when the Particle System first spawns them.

The initial size of particles along the x-axis when the Particle System first spawns them.

A multiplier for ParticleSystem.MainModule._startSizeX.

The initial size of particles along the y-axis when the Particle System first spawns them.

A multiplier for ParticleSystem.MainModule._startSizeY.

The initial size of particles along the z-axis when the Particle System first spawns them.

A multiplier for ParticleSystem.MainModule._startSizeZ.

The initial speed of particles when the Particle System first spawns them.

A multiplier for ParticleSystem.MainModule._startSpeed.

Select whether to Disable or Destroy the GameObject, or to call the MonoBehaviour.OnParticleSystemStopped script Callback, when the Particle System stops and all particles have died.

When true, use the unscaled delta time to simulate the Particle System. Otherwise, use the scaled delta time.

Script interface for a Min-Max Curve.

Set the constant value.

Set a constant for the upper bound.

Set a constant for the lower bound.

Set the curve.

Set a curve for the upper bound.

Set a curve for the lower bound.

Set a multiplier to apply to the curves.

Set the mode that the min-max curve uses to evaluate values.

A single constant value for the entire curve.

Constant value.

Use one curve when evaluating numbers along this Min-Max curve.

A multiplier to apply to the curve. A single curve to evaluate against.

Randomly select values based on the interval between the minimum and maximum curves.

A multiplier to apply to the curves. The curve describing the minimum values to be evaluated. The curve describing the maximum values to be evaluated.

Randomly select values based on the interval between the minimum and maximum constants.

The constant describing the minimum values to be evaluated. The constant describing the maximum values to be evaluated.

Manually query the curve to calculate values based on what mode it is in.

Normalized time (in the range 0 - 1, where 1 represents 100%) at which to evaluate the curve. This is valid when ParticleSystem.MinMaxCurve.mode is set to ParticleSystemCurveMode.Curve or ParticleSystemCurveMode.TwoCurves. Blend between the two curves/constants (Valid when ParticleSystem.MinMaxCurve.mode is set to ParticleSystemCurveMode.TwoConstants or ParticleSystemCurveMode.TwoCurves). Calculated curve/constant value.

Manually query the curve to calculate values based on what mode it is in.

Script interface for a Min-Max Gradient.

Set a constant color.

Set a constant color for the upper bound.

Set a constant color for the lower bound.

Set the gradient.

Set a gradient for the upper bound.

Set a gradient for the lower bound.

Set the mode that the Min-Max Gradient uses to evaluate colors.

A single constant color for the entire gradient.

Constant color.

Use one gradient when evaluating numbers along this Min-Max Gradient.

A single gradient for evaluating against.

Randomly select colors based on the interval between the minimum and maximum constants.

The constant color describing the minimum colors to be evaluated. The constant color describing the maximum colors to be evaluated.

Randomly select colors based on the interval between the minimum and maximum gradients.

The gradient describing the minimum colors to be evaluated. The gradient describing the maximum colors to be evaluated.

Manually query the gradient to calculate colors based on what mode it is in.

Normalized time (in the range 0 - 1, where 1 represents 100%) at which to evaluate the gradient. This is valid when ParticleSystem.MinMaxGradient.mode is set to ParticleSystemGradientMode.Gradient or ParticleSystemGradientMode.TwoGradients. Blend between the two gradients/colors (Valid when ParticleSystem.MinMaxGradient.mode is set to ParticleSystemGradientMode.TwoColors or ParticleSystemGradientMode.TwoGradients). Calculated gradient/color value.

Manually query the gradient to calculate colors based on what mode it is in.

Script interface for the NoiseModule.

Higher frequency noise reduces the strength by a proportional amount, if enabled.

Specifies whether the the NoiseModule is enabled or disabled.

Low values create soft, smooth noise, and high values create rapidly changing noise.

Layers of noise that combine to produce final noise.

When combining each octave, scale the intensity by this amount.

When combining each octave, zoom in by this amount.

How much the noise affects the particle positions.

Generate 1D, 2D or 3D noise.

Define how the noise values are remapped.

Enable remapping of the final noise values, allowing for noise values to be translated into different values.

Remap multiplier.

Define how the noise values are remapped on the x-axis, when using the ParticleSystem.NoiseModule.separateAxes option.

x-axis remap multiplier.

Define how the noise values are remapped on the y-axis, when using the ParticleSystem.NoiseModule.separateAxes option.

y-axis remap multiplier.

Define how the noise values are remapped on the z-axis, when using the ParticleSystem.NoiseModule.separateAxes option.

z-axis remap multiplier.

How much the noise affects the particle rotation, in degrees per second.

Scroll the noise map over the Particle System.

Scroll speed multiplier.

Control the noise separately for each axis.

How much the noise affects the particle sizes, applied as a multiplier on the size of each particle.

How strong the overall noise effect is.

Strength multiplier.

Define the strength of the effect on the x-axis, when using the ParticleSystem.NoiseModule.separateAxes option.

x-axis strength multiplier.

Define the strength of the effect on the y-axis, when using the ParticleSystem.NoiseModule.separateAxes option.

y-axis strength multiplier.

Define the strength of the effect on the z-axis, when using the ParticleSystem.NoiseModule.separateAxes option.

z-axis strength multiplier.

Script interface for a Particle.

The angular velocity of the particle.

The 3D angular velocity of the particle.

The animated velocity of the particle.

Mesh particles rotate around this axis.

The lifetime of the particle.

The position of the particle.

The random seed of the particle.

The random value of the particle.

The remaining lifetime of the particle.

The rotation of the particle.

The 3D rotation of the particle.

The initial color of the particle. The current color of the particle is calculated procedurally based on this value and the active color modules.

The starting lifetime of the particle.

The initial size of the particle. The current size of the particle is calculated procedurally based on this value and the active size modules.

The initial 3D size of the particle. The current size of the particle is calculated procedurally based on this value and the active size modules.

The total velocity of the particle.

The velocity of the particle, measured in units per second.

Calculate the current color of the particle by applying the relevant curves to its startColor property.

The Particle System from which this particle was emitted. Current color.

Calculate the current size of the particle by applying the relevant curves to its startSize property.

The Particle System from which this particle was emitted. Current size.

Calculate the current 3D size of the particle by applying the relevant curves to its startSize3D property.

The Particle System from which this particle was emitted. Current size.

Calculate the Mesh index of the particle, used for choosing which Mesh a particle is rendered with.

The Particle System from which this particle was emitted. The index of the mesh used for rendering the particle.

Sets the Mesh index of the particle, used for choosing which Mesh a particle is rendered with.

The Mesh index.

Pauses the system so no new particles are emitted and the existing particles are not updated.

Pause all child Particle Systems as well.

Pauses the system so no new particles are emitted and the existing particles are not updated.

Pause all child Particle Systems as well.

Starts the Particle System.

Play all child Particle Systems as well.

Starts the Particle System.

Play all child Particle Systems as well.

Script interface for storing the particle playback state.

Reset the cache of reserved graphics memory used for efficient rendering of Particle Systems.

Script interface for the RotationBySpeedModule.

ESpecifies whether the RotationBySpeedModule is enabled or disabled.

Set the minimum and maximum speeds that this module applies the rotation curve between.

Set the rotation by speed on each axis separately.

Rotation by speed curve for the x-axis.

Speed multiplier along the x-axis.

Rotation by speed curve for the y-axis.

Speed multiplier along the y-axis.

Rotation by speed curve for the z-axis.

Speed multiplier along the z-axis.

Script interface for the RotationOverLifetimeModule.

Specifies whether the RotationOverLifetimeModule is enabled or disabled.

Set the rotation over lifetime on each axis separately.

Rotation over lifetime curve for the x-axis.

Rotation multiplier around the x-axis.

Rotation over lifetime curve for the y-axis.

Rotation multiplier around the y-axis.

Rotation over lifetime curve for the z-axis.

Rotation multiplier around the z-axis.

Set a stream of custom per-particle data.

The array of per-particle data. Which stream to assign the data to.

Limits the amount of graphics memory Unity reserves for efficient rendering of Particle Systems.

The maximum number of cached vertex buffers. The maximum number of cached index buffers.

Sets the particles of this Particle System.

Input particle buffer, containing the desired particle state. The number of elements in the particles array that is written to the Particle System. The offset into the destination particle list, to assign these particles.

Sets the particles of this Particle System.

Use this method with the results of an earlier call to ParticleSystem.GetPlaybackState, in order to restore the Particle System to the state stored in the playbackState object.

The PlaybackState to apply to the Particle System.

Use this method with the results of an earlier call to ParticleSystem.GetTrails, in order to restore the Particle System to the state stored in the Trails object.

The Trails to apply to the Particle System.

Script interface for the ShapeModule.

Align particles based on their initial direction of travel.

Angle of the cone to emit particles from.

Angle of the circle arc to emit particles from.

The mode that Unity uses to generate particles around the arc.

In animated modes, this determines how quickly the particle emission position moves around the arc.

A multiplier of the arc speed of the particle emission shape.

Control the gap between particle emission points around the arc.

Scale of the box to emit particles from.

Thickness of the box to emit particles from.

The thickness of the Donut shape to emit particles from.

Specifies whether the ShapeModule is enabled or disabled.

Length of the cone to emit particles from.

Mesh to emit particles from.

Emit particles from a single Material of a Mesh.

MeshRenderer to emit particles from.

Apply a scaling factor to the Mesh that emits the particles.

Where on the Mesh to emit particles from.

The mode to use to generate particles on a Mesh.

In animated modes, this determines how quickly the particle emission position moves across the Mesh.

A multiplier of the Mesh spawn speed.

Control the gap between particle emission points across the Mesh.

Move particles away from the surface of the source Mesh.

Apply an offset to the position from which the system emits particles.

Radius of the shape to emit particles from.

The mode to use to generate particles along the radius.

In animated modes, this determines how quickly the particle emission position moves along the radius.

A multiplier of the radius speed of the particle emission shape.

Control the gap between particle emission points along the radius.

Radius thickness of the shape's edge from which to emit particles.

Randomizes the starting direction of particles.

Randomizes the starting position of particles.

Apply a rotation to the shape from which the system emits particles.

Apply scale to the shape from which the system emits particles.

The type of shape to emit particles from.

SkinnedMeshRenderer to emit particles from.

Makes particles move in a spherical direction from their starting point.

Sprite to emit particles from.

SpriteRenderer to emit particles from.

Specifies a Texture to tint the particle's start colors.

When enabled, the system applies the alpha channel of the Texture to the particle alpha when the particle spawns.

When enabled, the system takes four neighboring samples from the Texture then combines them to give the final particle value.

Selects which channel of the Texture to use for discarding particles.

Discards particles when they spawn on an area of the Texture with a value lower than this threshold.

When enabled, the system applies the RGB channels of the Texture to the particle color when the particle spawns.

When using a Mesh as a source shape type, this option controls which UV channel on the Mesh to use for reading the source Texture.

Modulate the particle colors with the vertex colors, or the Material color if no vertex colors exist.

Emit particles from a single Material, or the whole Mesh.

Fast-forwards the Particle System by simulating particles over the given period of time, then pauses it.

Time period in seconds to advance the ParticleSystem simulation by. If restart is true, the ParticleSystem will be reset to 0 time, and then advanced by this value. If restart is false, the ParticleSystem simulation will be advanced in time from its current state by this value. Fast-forward all child Particle Systems as well. Restart and start from the beginning. Only update the system at fixed intervals, based on the value in "Fixed Time" in the Time options.

Fast-forwards the Particle System by simulating particles over the given period of time, then pauses it.

Script interface for the SizeBySpeedModule.

Specifies whether the SizeBySpeedModule is enabled or disabled.

Set the minimum and maximum speed that this modules applies the size curve between.

Set the size by speed on each axis separately.

Curve to control particle size based on speed.

A multiplier for ParticleSystem.SizeBySpeedModule._size.

Size by speed curve for the x-axis.

Size multiplier along the x-axis.

Size by speed curve for the y-axis.

Size multiplier along the y-axis.

Size by speed curve for the z-axis.

Size multiplier along the z-axis.

Script interface for the SizeOverLifetimeModule.

Specifies whether the SizeOverLifetimeModule is enabled or disabled.

Set the size over lifetime on each axis separately.

Curve to control particle size based on lifetime.

A multiplier for ParticleSystem.SizeOverLifetimeModule._size.

Size over lifetime curve for the x-axis.

Size multiplier along the x-axis.

Size over lifetime curve for the y-axis.

Size multiplier along the y-axis.

Size over lifetime curve for the z-axis.

Size multiplier along the z-axis.

Stops playing the Particle System using the supplied stop behaviour.

Stop all child Particle Systems as well. Stop emitting or stop emitting and clear the system.

Stops playing the Particle System using the supplied stop behaviour.

Stop all child Particle Systems as well. Stop emitting or stop emitting and clear the system.

Stops playing the Particle System using the supplied stop behaviour.

Stop all child Particle Systems as well. Stop emitting or stop emitting and clear the system.

Script interface for the SubEmittersModule.

Sub-Particle System which spawns at the locations of the birth of the particles from the parent system.

Sub-Particle System which spawns at the locations of the collision of the particles from the parent system.

Sub-Particle System which spawns at the locations of the death of the particles from the parent system.

Sub-Particle System to spawn on death of the parent system's particles.

Specifies whether the SubEmittersModule is enabled or disabled.

The total number of sub-emitters.

Add a new sub-emitter.

The sub-emitter to add. The event that creates new particles. The properties of the new particles. The probability that the sub-emitter emits particles. Accepts values from 0 to 1, where 0 is never and 1 is always.

Add a new sub-emitter.

Gets the probability that the sub-emitter emits particles.

The index of the sub-emitter. The emission probability for the sub-emitter

Gets the properties of the sub-emitter at the given index.

The index of the sub-emitter. The properties of the sub-emitter at the index.

Gets the sub-emitter Particle System at the given index.

The index of the desired sub-emitter. The sub-emitter at the index.

Gets the type of the sub-emitter at the given index.

The index of the desired sub-emitter. The type of sub-emitter at the index.

Removes a sub-emitter from the given index in the array.

The index from which to remove a sub-emitter.

Removes a sub-emitter from the given index in the array.

The sub-emitter to remove.

Sets the probability that the sub-emitter emits particles.

The index of the sub-emitter you want to modify. The probability value.

Sets the properties of the sub-emitter at the given index.

The index of the sub-emitter you want to modify. The new properties to assign to this sub-emitter.

Sets the Particle System to use as the sub-emitter at the given index.

The index of the sub-emitter you want to modify. The Particle System to use as the sub-emitter at the specified index.

Sets the type of the sub-emitter at the given index.

The index of the sub-emitter you want to modify. The new spawning type to assign to this sub-emitter.

Script interface for the TextureSheetAnimationModule.

Specifies the animation type.

Specifies how many times the animation loops during the lifetime of the particle.

Specifies whether the TextureSheetAnimationModule is enabled or disabled.

Flip the U coordinate on particles, causing them to appear mirrored horizontally.

Flip the V coordinate on particles, causing them to appear mirrored vertically.

Control how quickly the animation plays.

A curve to control which frame of the Texture sheet animation to play.

The frame over time mutiplier.

Select whether the animated Texture information comes from a grid of frames on a single Texture, or from a list of Sprite objects.

Defines the tiling of the Texture in the x-axis.

Defines the tiling of the texture in the y-axis.

Explicitly select which row of the Texture sheet to use. The system uses this property when ParticleSystem.TextureSheetAnimationModule.rowMode is set to Custom.

Select how particles choose which row of a Texture Sheet Animation to use.

Specify how particle speeds are mapped to the animation frames.

The total number of sprites.

Define a random starting frame for the Texture sheet animation.

The starting frame multiplier.

Select whether the system bases the playback on mapping a curve to the lifetime of each particle, by using the particle speeds, or if playback simply uses a constant frames per second.

Use a random row of the Texture sheet for each particle emitted.

Choose which UV channels receive Texture animation.

Add a new Sprite.

The Sprite to be added.

Get the Sprite at the given index.

The index of the desired Sprite. The Sprite being requested.

Remove a Sprite from the given index in the array.

The index from which to remove a Sprite.

Set the Sprite at the given index.

The index of the Sprite being modified. The Sprite being assigned.

Script interface for the TrailsModule.

Adds an extra position to each ribbon, connecting it to the location of the Transform Component.

The gradient that controls the trail colors during the lifetime of the attached particle.

The gradient that controls the trail colors over the length of the trail.

Specifies whether trails disappear immediately when their owning particle dies. When false, each trail persists until all its points have naturally expired, based on its lifetime.

Specifies whether the TrailModule is enabled or disabled.

Configures the trails to generate Normals and Tangents. With this data, Scene lighting can affect the trails via Normal Maps and the Unity Standard Shader, or your own custom-built Shaders.

Toggle whether the trail inherits the particle color as its starting color.

The curve describing the trail lifetime, throughout the lifetime of the particle.

A multiplier for ParticleSystem.TrailModule._lifetime.

Set the minimum distance each trail can travel before the system adds a new vertex to it.

Choose how the system generates the particle trails.

Choose what proportion of particles receive a trail.

Select how many lines to create through the Particle System.

Apply a shadow bias to prevent self-shadowing artifacts. The specified value is the proportion of the trail width at each segment.

Set whether the particle size acts as a multiplier on top of the trail lifetime.

Set whether the particle size acts as a multiplier on top of the trail width.

Specifies whether, if you use this system as a sub-emitter, ribbons connect particles from each parent particle independently.

Choose whether the U coordinate of the trail Texture is tiled or stretched.

The curve describing the width of each trail point.

A multiplier for ParticleSystem.TrailModule._widthOverTrail.

Drop new trail points in world space, regardless of Particle System Simulation Space.

Script interface for storing the particle trail data.

Reserve memory for the particle trail data.

Script interface for the TriggerModule.

Indicates the number of collision shapes attached to this Particle System trigger.

Determines whether collider information is available when calling ParticleSystem::GetTriggerParticles.

Specifies whether the TriggerModule is enabled or disabled.

Choose what action to perform when particles enter the trigger volume.

Choose what action to perform when particles leave the trigger volume.

Choose what action to perform when particles are inside the trigger volume.

The maximum number of collision shapes that can be attached to this Particle System trigger.

Choose what action to perform when particles are outside the trigger volume.

A multiplier Unity applies to the size of each particle before it processes overlaps.

Adds a Collision shape associated with this Particle System trigger.

The Collider to associate with this trigger.

Gets a collision shape associated with this Particle System trigger.

The Collider to return. The Collider at the given index.

Removes a collision shape associated with this Particle System trigger.

The Collider to remove.

Removes a collision shape associated with this Particle System trigger.

The Collider to remove.

Sets a Collision shape associated with this Particle System trigger.

The Collider entry to assign. The Collider to associate with this trigger.

Triggers the specified sub emitter on all particles of the Particle System.

Index of the sub emitter to trigger.

Triggers the specified sub emitter on the specified particle(s) of the Particle System.

Index of the sub emitter to trigger. Triggers the sub emtter on a single particle. Triggers the sub emtter on a list of particles.

Triggers the specified sub emitter on the specified particle(s) of the Particle System.

Index of the sub emitter to trigger. Triggers the sub emtter on a single particle. Triggers the sub emtter on a list of particles.

Script interface for the VelocityOverLifetimeModule.

Specifies whether the VelocityOverLifetimeModule is enabled or disabled.

Specify a custom center of rotation for the orbital and radial velocities.

A multiplier for _orbitalOffsetX.

Specify a custom center of rotation for the orbital and radial velocities.

A multiplier for _orbitalOffsetY.

Specify a custom center of rotation for the orbital and radial velocities.

A multiplier for _orbitalOffsetY.

Curve to control particle speed based on lifetime, around the x-axis.

Speed multiplier along the x-axis.

Curve to control particle speed based on lifetime, around the y-axis.

Speed multiplier along the y-axis.

Curve to control particle speed based on lifetime, around the z-axis.

Speed multiplier along the z-axis.

Curve to control particle speed based on lifetime, away from a center position.

A multiplier for ParticleSystem.VelocityOverLifetimeModule._radial.

Specifies if the velocities are in local space (rotated with the transform) or world space.

Curve to control particle speed based on lifetime, without affecting the direction of the particles.

A multiplier for ParticleSystem.VelocityOverLifetimeModule._speedModifier.

Curve to control particle speed based on lifetime, on the x-axis.

A multiplier for ParticleSystem.VelocityOverLifetimeModule._x

Curve to control particle speed based on lifetime, on the y-axis.

A multiplier for ParticleSystem.VelocityOverLifetimeModule._y.

Curve to control particle speed based on lifetime, on the z-axis.

A multiplier for ParticleSystem.VelocityOverLifetimeModule._z.

The animation mode.

Use a regular grid to construct a sequence of animation frames.

Use a list of sprites to construct a sequence of animation frames.

The mode used for selecting rows of an animation in the Texture Sheet Animation Module.

Use a specific row for all particles.

Use the mesh index as the row, so that meshes can be mapped to specific animation frames.

Use a random row for each particle.

Control how animation frames are selected.

Select animation frames sequentially at a constant rate of the specified frames per second.

Select animation frames based on the particle ages.

Select animation frames based on the particle speeds.

The animation type.

Animate a single row in the sheet from left to right.

Animate over the whole texture sheet from left to right, top to bottom.

Whether collider information is available when using the ParticleSystem::GetTriggerParticles method.

ParticleSystem::GetTriggerParticles returns all colliders that each particle is interacting with.

ParticleSystem::GetTriggerParticles does not return any information about which colliders each particle is interacting with.

ParticleSystem::GetTriggerParticles may only return one collider that each particle is interacting with.

Whether to use 2D or 3D colliders for particle collisions.

Use 2D colliders to collide particles against.

Use 3D colliders to collide particles against.

Quality of world collisions. Medium and low quality are approximate and may leak particles.

The most accurate world collisions.

Fastest and most approximate world collisions.

Approximate world collisions.

The type of collisions to use for a given Particle System.

Collide with a list of planes.

Collide with the world geometry.

The action to perform when the Particle System is offscreen.

Continue simulating the Particle System when it is offscreen.

For looping effects, the simulation is paused when offscreen, and for one-shot effects, the simulation will continue playing.

Pause the Particle System simulation when it is offscreen.

Pause the Particle System simulation when it is offscreen, and perform an extra simulation when the system comes back onscreen, creating the impression that it was never paused.

The particle curve mode.

Use a single constant for the ParticleSystem.MinMaxCurve.

Use a single curve for the ParticleSystem.MinMaxCurve.

Use a random value between 2 constants for the ParticleSystem.MinMaxCurve.

Use a random value between 2 curves for the ParticleSystem.MinMaxCurve.

Which stream of custom particle data to set.

The first stream of custom per-particle data.

The second stream of custom per-particle data.

Which mode CustomDataModule uses to generate its data.

Generate data using ParticleSystem.MinMaxGradient.

Don't generate any data.

Generate data using ParticleSystem.MinMaxCurve.

The mode in which particles are emitted.

Emit when emitter moves.

Emit over time.

Control how a Particle System calculates its velocity.

When the Particle System calculates its velocity, it instead uses the custom value set in ParticleSystem.MainModule.emitterVelocity.

Calculate the Particle System velocity by using a Rigidbody or Rigidbody2D component, if one exists on the GameObject.

Calculate the Particle System velocity by using the Transform component.

Script interface for Particle System Force Fields.

Apply a linear force along the local X axis to particles within the volume of the Force Field.

Apply a linear force along the local Y axis to particles within the volume of the Force Field.

Apply a linear force along the local Z axis to particles within the volume of the Force Field.

Apply drag to particles within the volume of the Force Field.

Determines the size of the shape used for influencing particles.

Apply gravity to particles within the volume of the Force Field.

When using the gravity force, set this value between 0 and 1 to control the focal point of the gravity effect.

Describes the length of the Cylinder when using the Cylinder Force Field shape to influence particles.

When using Drag, the drag strength will be multiplied by the size of the particles if this toggle is enabled.

When using Drag, the drag strength will be multiplied by the speed of the particles if this toggle is enabled.

Controls how strongly particles are dragged into the vortex motion.

Apply randomness to the Force Field axis that particles will travel around.

The speed at which particles are propelled around a vortex.

Selects the type of shape used for influencing particles.

Setting a value greater than 0 creates a hollow Force Field shape. This will cause particles to not be affected by the Force Field when closer to the center of the volume than the startRange property.

Apply forces to particles within the volume of the Force Field, by using a 3D texture containing vector field data.

Controls how strongly particles are dragged into the vector field motion.

The speed at which particles are propelled through the vector field.

The type of shape used for influencing particles in the Force Field Component.

Influence particles inside a box shape.

Influence particles inside a cylinder shape.

Influence particles inside a hemisphere shape.

Influence particles inside a sphere shape.

The particle GameObject filtering mode that specifies which objects are used by specific Particle System modules.

Include objects based on a layer mask, where all objects that match the mask are included.

Include objects based on both a layer mask and an explicitly provided list.

Include objects based on an explicitly provided list.

The particle gradient mode.

Use a single color for the ParticleSystem.MinMaxGradient.

Use a single color gradient for the ParticleSystem.MinMaxGradient.

Define a list of colors in the ParticleSystem.MinMaxGradient, to be chosen from at random.

Use a random value between 2 colors for the ParticleSystem.MinMaxGradient.

Use a random value between 2 color gradients for the ParticleSystem.MinMaxGradient.

How to apply emitter velocity to particles.

Each particle's velocity is set to the emitter's current velocity value, every frame.

Each particle inherits the emitter's velocity on the frame when it was initially emitted.

Inherit from this interface to implement a Particle System job.

Implement this method to access and modify particle properties.

Contains the particle properties.

Inherit from this interface to implement a Particle System job.

Implement this method to access and modify particle properties.

Contains the particle properties. The index of the current particle.

Inherit from this interface to implement a Particle System job.

Implement this method to access and modify particle properties.

Contains the particle properties. The first particle index that this job should process. The number of particles that this job should process.

This struct specifies all the per-particle data.

Specifies how long each particle has been alive.

Specifies an axis of rotation for each particles, in radians.

Specifies the number of particles alive in the Particle System.

This array contains the custom data values when you use a CustomDataModule, or when you call SetCustomParticleData.

The lifetime of each particle, stored as 1.0f / lifetime.

Specifies a mesh index for each particle.

The position of each particle.

The random seed assigned to each particle.

The angular velocity of each particle.

The rotation of each particle.

The size of each particle.

The initial color of each particle.

The velocity of each particle.

A container to hold x, y, and z-axis data for particles.

The x-axis value for each particle.

The y-axis value for each particle.

The z-axis value for each particle.

A container to hold 4 arrays of data for particles.

The w-axis value for each particle.

The x-axis value for each particle.

The y-axis value for each particle.

The z-axis value for each particle.

Sets which method Unity uses to randomly assign Meshes to particles.

Use per-Mesh weights to make some Meshes appear more often than others. A higher weight value increases the chance of choosing the associated Mesh.

Use a uniform random value to give each Mesh an equal chance to appear.

The mesh emission type.

Emit from the edges of the mesh.

Emit from the surface of the mesh.

Emit from the vertices of the mesh.

The quality of the generated noise.

High quality 3D noise.

Low quality 1D noise.

Medium quality 2D noise.

What action to perform when the particle trigger module passes a test.

Send the OnParticleTrigger command to the Particle System's script.

Do nothing.

Kill all particles that pass this test.

Use this class to render particles on to the screen.

The number of currently active custom vertex streams.

Control the direction that particles face.

Allow billboard particles to roll around their z-axis.

How much do the particles stretch depending on the Camera's speed.

Enables GPU Instancing on platforms that support it.

Flip a percentage of the particles, along each axis.

Enables freeform stretching behavior.

How much are the particles stretched in their direction of motion, defined as the length of the particle compared to its width.

Specifies how the Particle System Renderer interacts with SpriteMask.

Clamp the maximum particle size.

The Mesh that the particle uses instead of a billboarded Texture.

The number of Meshes the system uses for particle rendering.

Specifies how the system randomly assigns meshes to particles.

Clamp the minimum particle size.

Specifies how much a billboard particle orients its normals towards the Camera.

Modify the pivot point used for rotating particles.

Specifies how the system draws particles.

Rotate the particles based on the direction they are stretched in. This is added on top of other particle rotation.

Apply a shadow bias to prevent self-shadowing artifacts. The specified value is the proportion of the particle size.

Biases Particle System sorting amongst other transparencies.

Specifies how to sort particles within a system.

Determines whether the Particle System can be rendered using GPU Instancing.

Set the Material that the TrailModule uses to attach trails to particles.

Specifies how much particles stretch depending on their velocity.

Query whether the Particle System Renderer uses a particular set of vertex streams.

Streams to query. true if the queried streams are enabled. Returns false otherwise.

Creates a snapshot of ParticleSystemRenderer and stores it in mesh.

A static Mesh to receive the snapshot of the particles. The Camera used to determine which way camera-space particles face. Specifies whether to include the rotation and scale of the Transform in the baked Mesh.

Creates a snapshot of ParticleSystemRenderer and stores it in mesh.

Creates a snapshot of ParticleSystem Trails and stores them in mesh.

A static Mesh to receive the snapshot of the particle trails. The Camera used to determine which way camera-space trails face. Specifies whether to include the rotation and scale of the Transform in the baked Mesh.

Creates a snapshot of ParticleSystem Trails and stores them in mesh.

Disable a set of vertex Shader streams on the Particle System Renderer. The position stream is always enabled, and any attempts to remove it are ignored.

Streams to disable.

Enable a set of vertex Shader streams on the Particle System renderer.

Streams to enable.

Queries which Vertex Shader streams are enabled on the ParticleSystemRenderer.

The array of streams to populate.

Queries whether the Particle System renderer uses a particular set of vertex streams.

Streams to query. The subset of the queried streams that are actually enabled.

Gets the array of Meshes to use when selecting particle meshes.

An array this function populates with the list of Meshes the ParticleSystemRenderer uses for particle Mesh selection. If the array is smaller than the number of Meshes, this function cannot populate it with every Mesh. If the array is larger than the number of Meshes, this function ignores indices greater than the number of Meshes. Use ParticleSystemRenderer.meshCount to get the number of Meshes the ParticleSystemRenderer has. The number of Meshes this function wrote to the destination array.

Gets the array of Mesh weightings to use when randomly selecting particle meshes.

An array this function populates with the list of Mesh weightings the ParticleSystemRenderer uses for particle Mesh selection. If the array is smaller than the number of weights, this function cannot populate it with every weight. If the array is larger than the number of weights, this function ignores indices greater than the number of weights. Use ParticleSystemRenderer.meshCount to get the number of Meshes, and thus weights, the ParticleSystemRenderer has. The number of weights this function wrote to the destination array.

Enables a set of vertex Shader streams on the ParticleSystemRenderer.

The new array of enabled vertex streams.

Sets the Meshes that the ParticleSystemRenderer uses to display particles when the ParticleSystemRenderer.renderMode is set to ParticleSystemRenderMode.Mesh.

The array of Meshes to use. The number of elements from the Mesh array to apply.

Sets the Meshes that the ParticleSystemRenderer uses to display particles when the ParticleSystemRenderer.renderMode is set to ParticleSystemRenderMode.Mesh.

The array of Meshes to use. The number of elements from the Mesh array to apply.

Sets the weights that the ParticleSystemRenderer uses to assign Meshes to particles.

The array of weights to use. The number of elements from the weighting array to apply.

Sets the weights that the ParticleSystemRenderer uses to assign Meshes to particles.

The array of weights to use. The number of elements from the weighting array to apply.

The rendering mode for particle systems.

Render particles as billboards facing the active camera. (Default)

Render particles as billboards always facing up along the y-Axis.

Render particles as meshes.

Do not render particles.

Stretch particles in the direction of motion.

Render particles as billboards always facing the player, but not pitching along the x-Axis.

How particles are aligned when rendered.

Particles face the eye position.

Particles align with their local transform.

Particles are aligned to their direction of travel.

Particles face the camera plane.

Particles align with the world.

Control how particles are removed from the Particle System.

Particles are removed when their age exceeds their lifetime.

Particle ages loop until they need to be removed. Particles are removed when creating new particles would exceed the Max Particles property.

Particle ages pause at the end of their lifetime until they need to be removed. Particles are removed when creating new particles would exceed the Max Particles property.

Control how particle systems apply transform scale.

Scale the Particle System using the entire transform hierarchy.

Scale the Particle System using only its own transform scale. (Ignores parent scale).

Only apply transform scale to the shape component, which controls where particles are spawned, but does not affect their size or movement.

The mode used to generate new points in a shape.

Distribute new particles around the shape evenly.

Animate the emission point around the shape.

Animate the emission point around the shape, alternating between clockwise and counter-clockwise directions.

Generate points randomly. (Default)

The texture channel.

The alpha channel.

The blue channel.

The green channel.

The red channel.

The emission shape.

Emit from the volume of a box.

Emit from the edges of a box.

Emit from the surface of a box.

Emit from a circle.

Emit from the edge of a circle.

Emit from the base of a cone.

Emit from the base surface of a cone.

Emit from a cone.

Emit from the surface of a cone.

Emit from a Donut.

Emit from a half-sphere.

Emit from the surface of a half-sphere.

Emit from a mesh.

Emit from a mesh renderer.

Emit from a rectangle.

Emit from an edge.

Emit from a skinned mesh renderer.

Emit from a sphere.

Emit from the surface of a sphere.

Emit from a sprite.

Emit from a sprite renderer.

The space to simulate particles in.

Simulate particles relative to a custom transform component, defined by ParticleSystem.MainModule.customSimulationSpace.

Simulate particles in local space.

Simulate particles in world space.

The sorting mode for particle systems.

Sort based on depth from the camera plane.

Sort based on distance to the camera position. For orthographic cameras, this mode is the same as sorting by depth.

No sorting.

Sort the oldest particles to the front.

Sort the youngest particles to the front.

The action to perform when the Particle System stops.

Call MonoBehaviour.OnParticleSystemStopped on all scripts attached to the same GameObject.

Destroy the GameObject containing the Particle System.

Disable the GameObject containing the Particle System.

Do nothing.

The behavior to apply when calling ParticleSystem.Stop|Stop.

Stops Particle System emitting any further particles. All existing particles will remain until they expire.

Stops Particle System emitting and removes all existing emitted particles.

The properties of sub-emitter particles.

When spawning new particles, multiply the start color by the color of the parent particles.

When spawning new particles, use the duration and age properties from the parent system, when sampling MainModule curves in the Sub-Emitter.

When spawning new particles, inherit all available properties from the parent particles.

New particles will have a shorter lifespan, the closer their parent particles are to death.

When spawning new particles, do not inherit any properties from the parent particles.

When spawning new particles, add the start rotation to the rotation of the parent particles.

When spawning new particles, multiply the start size by the size of the parent particles.

The events that cause new particles to be spawned.

Spawns new particles when particles from the parent system are born.

Spawns new particles when particles from the parent system collide with something.

Spawns new particles when particles from the parent system die.

Spawns new particles when triggered from script using ParticleSystem.TriggerSubEmitter.

Spawns new particles when particles from the parent system pass conditions in the Trigger Module.

Choose how Particle Trails are generated.

Makes a trail behind each particle as the particle moves.

Draws a line between each particle, connecting the youngest particle to the oldest.

Choose how textures are applied to Particle Trails.

Map the texture once along the entire length of the trail, assuming all vertices are evenly spaced.

Repeat the texture along the trail, repeating at a rate of once per trail segment. To adjust the tiling rate, use Material.SetTextureScale.

Map the texture once along the entire length of the trail.

Repeat the texture along the trail. To set the tiling rate, use Material.SetTextureScale.

The different types of particle triggers.

Trigger when particles enter the collision volume.

Trigger when particles leave the collision volume.

Trigger when particles are inside the collision volume.

Trigger when particles are outside the collision volume.

All possible Particle System vertex shader inputs.

The normalized age of each particle, from 0 to 1.

The amount to blend between animated texture frames, from 0 to 1.

The current animation frame index of each particle.

The center position of the entire particle, in world space.

The color of each particle.

One custom value for each particle, defined by the Custom Data Module, or ParticleSystem.SetCustomParticleData.

Two custom values for each particle, defined by the Custom Data Module, or ParticleSystem.SetCustomParticleData.

Three custom values for each particle, defined by the Custom Data Module, or ParticleSystem.SetCustomParticleData.

Four custom values for each particle, defined by the Custom Data Module, or ParticleSystem.SetCustomParticleData.

One custom value for each particle, defined by the Custom Data Module, or ParticleSystem.SetCustomParticleData.

Two custom values for each particle, defined by the Custom Data Module, or ParticleSystem.SetCustomParticleData.

Three custom values for each particle, defined by the Custom Data Module, or ParticleSystem.SetCustomParticleData.

Four custom values for each particle, defined by the Custom Data Module, or ParticleSystem.SetCustomParticleData.

The reciprocal of the starting lifetime, in seconds (1.0f / startLifetime).

The index of the mesh used by the current particle.

The X axis noise on the current frame.

The X and Y axis noise on the current frame.

The 3D noise on the current frame.

The accumulated X axis noise, over the lifetime of the particle.

The accumulated X and Y axis noise, over the lifetime of the particle.

The accumulated 3D noise, over the lifetime of the particle.

The vertex normal of each particle.

The position of each particle vertex, in world space.

The Z axis rotation of each particle.

The 3D rotation of each particle.

The Z axis rotational speed of each particle.

The 3D rotational speed of each particle.

The X axis size of each particle.

The X and Y axis sizes of each particle.

The 3D size of each particle.

The speed of each particle, calculated by taking the magnitude of the velocity.

A random number for each particle, which remains constant during their lifetime.

Two random numbers for each particle, which remain constant during their lifetime.

Three random numbers for each particle, which remain constant during their lifetime.

Four random numbers for each particle, which remain constant during their lifetime.

The tangent vector for each particle (for normal mapping).

The first UV stream of each particle.

The second UV stream of each particle.

The third UV stream of each particle (only for meshes).

The fourth UV stream of each particle (only for meshes).

A random number for each particle, which changes during their lifetime.

Two random numbers for each particle, which change during their lifetime.

Three random numbers for each particle, which change during their lifetime.

Four random numbers for each particle, which change during their lifetime.

The velocity of each particle, in world space.

The vertex ID of each particle.

All possible Particle System vertex shader inputs.

A mask with all vertex streams enabled.

The center position of each particle, with the vertex ID of each particle, from 0-3, stored in the w component.

The color of each particle.

The first stream of custom data, supplied from script.

The second stream of custom data, supplied from script.

Alive time as a 0-1 value in the X component, and Total Lifetime in the Y component. To get the current particle age, simply multiply X by Y.

A mask with no vertex streams enabled.

The normal of each particle.

The world space position of each particle.

4 random numbers. The first 3 are deterministic and assigned once when each particle is born, but the 4th value will change during the lifetime of the particle.

The rotation of each particle.

The size of each particle.

Tangent vectors for normal mapping.

The texture coordinates of each particle.

With the TextureSheetAnimationModule enabled, this contains the UVs for the second texture frame, the blend factor for each particle, and the raw frame, allowing for blending of frames.

The 3D velocity of each particle.

A flag representing each UV channel.

First UV channel.

Second UV channel.

Third UV channel.

Fourth UV channel.

The ParticleSystem module implements Unity's Particle System.