The Emitter class is the base class for the Emitter2D and Emitter3D classes.
The emitter class contains the common behavioour used by these two concrete
classes.
An Emitter manages the creation and ongoing state of particles. It uses
a number of utility classes to customise its behaviour.
An emitter uses Initializers to customise the initial state of particles
that it creates; their position, velocity, color etc. These are added to the
emitter using the addInitializer method.
An emitter uses Actions to customise the behaviour of particles that
it creates; to apply gravity, drag, fade etc. These are added to the emitter
using the addAction method.
An emitter uses Activities to customise its own behaviour in an ongoing
manner, to move it or rotate it for example.
An emitter uses a Counter to know when and how many particles to emit.
All timings in the emitter are based on actual time passed,
independent of the frame rate of the flash movie.
Most functionality is best added to an emitter using Actions,
Initializers, Activities and Counters. This offers greater
flexibility to combine behaviours without needing to subclass
the Emitter classes.
actions:Array [read-write]
The array of all actions being used by this emitter.
Implementation
public function get actions():Array
public function set actions(value:Array):void
activities:Array [read-write]
The array of all actions being used by this emitter.
Implementation
public function get activities():Array
public function set activities(value:Array):void
counter:Counter [read-write]
The Counter for the Emitter. The counter defines when and
with what frequency the emitter emits particles.
Implementation
public function get counter():Counter
public function set counter(value:Counter):void
protected var _dispatchCounterComplete:Boolean = false
Indicates if the emitter should dispatch a counterComplete event at the
end of the next update cycle.
fixedFrameTime:Number [read-write]
Indicates a fixed time (in seconds) to use for every frame. Setting
this property causes the emitter to bypass its frame timing
functionality and use the given time for every frame. This enables
the particle system to be frame based rather than time based.
To return to time based animation, set this value to zero (the
default).
This feature only works if useInternalTick is true (the default).
Implementation
public function get fixedFrameTime():Number
public function set fixedFrameTime(value:Number):void
See also
initializers:Array [read-write]
The array of all initializers being used by this emitter.
Implementation
public function get initializers():Array
public function set initializers(value:Array):void
maximumFrameTime:Number [read-write]
The maximum duration for a single update frame, in seconds.
Under some circumstances related to the Flash player (e.g. on MacOSX, when the
user right-clicks on the flash movie) the flash movie will freeze for a period. When the
freeze ends, the current frame of the particle system will be calculated as the time since
the previous frame, which encompases the duration of the freeze. This could cause the
system to generate a single frame update that compensates for a long period of time and
hence moves the particles an unexpected long distance in one go. The result is usually
visually unacceptable and certainly unexpected.
This property sets a maximum duration for a frame such that any frames longer than
this duration are ignored. The default value is 0.5 seconds. Developers don't usually
need to change this from the default value.
Implementation
public function get maximumFrameTime():Number
public function set maximumFrameTime(value:Number):void
particleFactory:ParticleFactory [read-write]
This is the particle factory used by the emitter to create and dispose
of particles. The 2D and 3D libraries each have a default particle
factory that is used by the Emitter2D and Emitter3D classes. Any custom
particle factory should implement the ParticleFactory interface.
Implementation
public function get particleFactory():ParticleFactory
public function set particleFactory(value:ParticleFactory):void
See also
particles:Array [read-write]
The array of all particles created by this emitter.
Implementation
public function get particles():Array
public function set particles(value:Array):void
running:Boolean [read-only]
Indicates if the emitter is currently running.
Implementation
public function get running():Boolean
useInternalTick:Boolean [read-write]
Indicates whether the emitter should manage its own internal update
tick. The internal update tick is tied to the frame rate and updates
the particle system every frame.
If users choose not to use the internal tick, they have to call
the emitter's update method with the appropriate time parameter every
time they want the emitter to update the particle system.
Implementation
public function get useInternalTick():Boolean
public function set useInternalTick(value:Boolean):void
public function Emitter()
The constructor creates an emitter.
public function addAction(action:Action):void
Adds an Action to the Emitter. Actions set the behaviour of particles
created by the emitter.
Parameters
| action:Action — The Action to add
|
See also
removeAction();
org.flintParticles.common.actions.Action.getDefaultPriority()
public function addActivity(activity:Activity):void
Adds an Activity to the Emitter. Activities set the behaviour
of the Emitter.
Parameters
See also
removeActivity()
org.flintParticles.common.activities.Activity.getDefaultPriority()
public function addExistingParticles(particles:Array, applyInitializers:Boolean = false):void
Adds existing particles to the emitter. This enables users to create
particles externally to the emitter and then pass the particles to the
emitter for management.
Parameters
| particles:Array — An array of particles
|
| |
| applyInitializers:Boolean (default = false) |
public function addInitializer(initializer:Initializer):void
Adds an Initializer object to the Emitter. Initializers set the
initial state of particles created by the emitter.
Parameters
See also
removeInitializer()
org.flintParticles.common.initializers.Initializer.getDefaultPriority()
protected function createParticle():Particle
Returns
public function dispatchCounterComplete():void
Used by counters to tell the emitter to dispatch a counter complete event.
public function hasAction(action:Action):Boolean
Detects if the emitter is using a particular action or not.
Parameters
| action:Action — The action to look for.
|
Returns
| Boolean — true if the action is being used by the emitter, false
otherwise.
|
public function hasActionOfType(actionClass:Class):Boolean
Detects if the emitter is using an action of a particular class.
Parameters
| actionClass:Class — The type of action to look for.
|
Returns
| Boolean — true if the emitter is using an instance of the class as an
action, false otherwise.
|
public function hasActivity(activity:Activity):Boolean
Detects if the emitter is using a particular activity or not.
Parameters
| activity:Activity — The activity to look for.
|
Returns
| Boolean — true if the activity is being used by the emitter, false
otherwise.
|
public function hasActivityOfType(activityClass:Class):Boolean
Detects if the emitter is using an activity of a particular class.
Parameters
| activityClass:Class — The type of activity to look for.
|
Returns
| Boolean — true if the emitter is using an instance of the class as an
activity, false otherwise.
|
public function hasInitializer(initializer:Initializer):Boolean
Detects if the emitter is using a particular initializer or not.
Parameters
Returns
| Boolean — true if the initializer is being used by the emitter, false
otherwise.
|
public function hasInitializerOfType(initializerClass:Class):Boolean
Detects if the emitter is using an initializer of a particular class.
Parameters
| initializerClass:Class — The type of initializer to look for.
|
Returns
| Boolean — true if the emitter is using an instance of the class as an
initializer, false otherwise.
|
protected function initParticle(particle:Particle):void
Emitters do their own particle initialization here - usually involves
positioning and rotating the particle to match the position and rotation
of the emitter. This method is called before any initializers that are
assigned to the emitter, so initializers can override any properties set
here.
The implementation of this method in this base class does nothing.
Parameters
public function killAllParticles():void
public function pause():void
Pauses the emitter.
public function removeAction(action:Action):void
Removes an Action from the Emitter.
Parameters
| action:Action — The Action to remove
|
See also
addAction()
public function removeActivity(activity:Activity):void
Removes an Activity from the Emitter.
Parameters
| activity:Activity — The Activity to remove
|
See also
addActivity()
public function removeInitializer(initializer:Initializer):void
Removes an Initializer from the Emitter.
Parameters
See also
addInitializer()
public function resume():void
Resumes the emitter after a pause.
public function runAhead(time:Number, frameRate:Number = 10):void
Makes the emitter skip forwards a period of time with a single update.
Used when you want the emitter to look like it's been running for a while.
Parameters
| time:Number — The time, in seconds, to skip ahead.
|
| |
| frameRate:Number (default = 10) |
protected function sortParticles():void
Used to sort the particles as required. In this base class this method
does nothing.
public function start():void
Starts the emitter. Until start is called, the emitter will not emit or
update any particles.
public function stop():void
Stops the emitter, killing all current particles and returning them to the
particle factory for reuse.
public function update(time:Number):void
Used to update the emitter. If using the internal tick, this method
will be called every frame without any action by the user. If not
using the internal tick, the user should call this method on a regular
basis to update the particle system.
The method asks the counter how many particles to create then creates
those particles. Then it calls sortParticles, applies the activities to
the emitter, applies the Actions to all the particles, removes all dead
particles, and finally dispatches an emitterUpdated event which tells
any renderers to redraw the particles.
Parameters
| time:Number — The duration, in seconds, to be applied in the update step.
|
See also
sortParticles();
Event object type: org.flintparticles.common.events.EmitterEvent
Dispatched when the counter for the particle system has finished its cycle and so
the system will not emit any more particles unless the counter is changed or restarted.
Event object type: org.flintparticles.common.events.EmitterEvent
Dispatched when an emitter attempts to update the particles' state but it
contains no particles. This event will be dispatched every time the update
occurs and there are no particles in the emitter. The update does not occur
when the emitter has not yet been started, when the emitter is paused, and
after the emitter has been stopped, so the event will not be dispatched
at these times.
See the firework example for an example that uses this event.
See also
start();
pause();
stop();
Event object type: org.flintparticles.common.events.EmitterEvent
Dispatched when the particle system has updated and the state of the particles
has changed.
Event object type: org.flintparticles.common.events.ParticleEvent
Dispatched when a pre-existing particle is added to the emitter.
Event object type: org.flintparticles.common.events.ParticleEvent
Dispatched when a particle is created and has just been added to the emitter.
Event object type: org.flintparticles.common.events.ParticleEvent
Dispatched when a particle dies and is about to be removed from the system.
As soon as the event has been handled the particle will be removed but at the
time of the event it still exists so its properties (e.g. its location) can be
read from it.
© Richard Lord 2009
flash.events.EventDispatcher