A ParticleSystem object allows you to place in space and control at runtime the properties of an existing ParticleNetwork Asset.

To understand how the system works; the connected ParticleNetwork will dictate how each particle will behave and the particle system (the object) will control wherein space particles will be emitted.

By using this approach a particle system will have to choose a SystemType based on the way the particle network will be used; this system type will allow you to either share, localize or duplicate the ParticleNetwork Particles, behaviors and properties.

There are basically three ways the connected ParticleNetwork can be used by an active particle system. kDiscrete; which will create a full copy of the network and force the particle system to run a full update independently.

kTemplate which simply reuses the existing particle network as it is for the current system; particles are updated once per frame and positioned in space for each system using it. As a result, this type allows randomness only at a particle level on a particle system basis.

And finally, kInstance where the particle's data are completely shared (updated once per frame reused at multiple locations for each system using the network); as shared implies all particles will act exactly the same (but will still be relative to the particle system object transformation the network is connected to).

Static Variables

Name	Description
`object`	Parent Object where the ParticleSystem structure is maintained.
Declaration Object *object
`particlenetwork`	Active ParticleNetwork connected to the active ParticleSystem.
Declaration ParticleNetwork *particlenetwork

Variables

Name	Description
`auto_delete`	Automatically remove the ParticleSystem Object if all particles are destroyed.
Declaration bool auto_delete
`state`	The active playback State of the ParticleSystem.
Declaration State state
`system_type`	The current SystemType used by the active ParticleSystem.
Declaration SystemType system_type

Functions

Name	Description
`SetParticleNetwork`	Connect an existing ParticleNetwork to the active ParticleSystem.
Declaration bool SetParticleNetwork( ParticleNetwork particlenetwork ) Parameters* `particlenetwork`: A valid ParticleNetwork reference or `nil` to disconnect a previous Asset. Return Value `true` if the ParticleSystem receive in parameter is connected or disconnected successfully. Return `false` if the active SystemType is `kInstance` and one of the ParticleNetwork ParticleEmitter is emitting `kMatter` since they cannot be instanced.
`SetMaterial`	Specify which Material to use when rendering the active ParticleSystem on a specific RenderLayer.
Declaration bool SetMaterial( int renderlayer_cap, unsigned char emitter_index, Material material ) Parameters* `renderlayer_cap`: An existing RenderLayer cap. `emitter_index`: Index of the emitter to connect the Material to. `material`: A valid Material Asset reference; or `nil` to disconnect a previously connected Material. Return Value `true` if the ParticleSystem is connected to a ParticleNetwork and the`emitter_index` and `material` is valid; else return `false`.
`CopyMaterials`	Helper function that copy the Material settings from one RenderLayer cap to another.
Declaration bool CopyMaterials( int from_renderlayer_cap, int to_renderlayer_cap ) Parameters `from_renderlayer_cap`: The source cap to copy the active Material configuration. `to_renderlayer_cap`: The destination cap to create or assign it to. Return Value `true` if the `from_renderlayer_cap` is valid and an existing Material configuration was found; else return `false`.
`GetMaterial`	Retrieve a specific Material reference assigned to an existing Material configuration.
Declaration Material GetMaterial( int renderlayer_cap, unsigned char emitter_index ) Parameters* `renderlayer_cap`: The RenderLayer cap that identify the configuration. `emitter_index`: The emitter index to retrieve the Material reference from. Return Value A valid Material reference if the configuration correspond to the parameters received by the function; `nil` if the configuration is innexistent or if no Material is applied on the ParticleEmitter pointed by `index`.
`GetActiveParticleCount`	Retrieve the current amount of particles emitted by the ParticleSystem that are in motion (alive).
Declaration unsigned int GetActiveParticleCount( void ) Return Value Return the active particle count.
`GetParticlesAt`	Retrieve a specific Particles array for a specific ParticleEmitter using its index as key.
Declaration Particles GetParticlesAt( unsigned char index ) Parameters* `index`: Index of the Particles array to retrieve. Return Value A valid Particles array reference; else return `nil` if the index is out of bounds.
`Play`	Active the current ParticleSystem.
Declaration void Play( void )
`Pause`	Temporary stop updating the active ParticleSystem.
Declaration void Pause( void )
`Stop`	Stop updating the active ParticleSystem.
Declaration void Stop( void )
`Update`	Temporary stop updating the active ParticleSystem.
Declaration bool Update( void ) Return Value `true` if the ParticleSystem have been updated; else return `false`.

Events

Events available when an Object is a ParticleSystem.

Callbacks	Description
`OnPlay`	Occurs when the particle system `Play` function is called.
Declaration function OnPlay()
`OnResume`	Occurs when ParticleSystem have been previously paused and the `Play` function is called again to resume the playback.
Declaration function OnResume()
`OnPause`	Triggered when the `Pause` function is called.
Declaration function OnPause()
`OnStop`	Triggered when the ParticleSystem stops playing (no more active particles) or the function `Stop` is called either internally or by the user.
Declaration function OnStop()
`OnDraw`	This event is triggered just before the ParticleSystem is ready to draw.
Declaration function OnDraw()
`OnDisplay`	Triggered right after the ParticleSystem draw calls have been sent.
Declaration function OnDisplay()

SystemType

Available types of ParticleSystem.

kInstance: Particles are updated once per frame for all ParticleSystem that are using a particular ParticleNetwork.
kTemplate: All particles will look and behave the same as defined in the ParticleNetwork and will be updated once per frame. This type is allowing randomness among multiple ParticleSystem using the same ParticleNetwork.
kDiscrete: Creates an independent variation of the ParticleNetwork connected to the ParticleSystem. Using this type of system you can locally alter the original attributes of the ParticleNetwork without affecting the Asset itself.

Warning: When using a kDiscrete ParticleSystem all changes made to the ParticleNetwork after affectation will not be taken in consideration until it is re-assigned to the ParticleSystem.