internal void Subscribe(Emitter emitter)
{
if (!_subscriptions.Contains(emitter))
{
_subscriptions.Add(emitter);
}
}
internal void UnSubscribe(Emitter emitter)
{
if (_subscriptions.Contains(emitter))
{
_subscriptions.Remove(emitter);
}
}
/// <summary>
/// Processes an Emitter.
/// </summary>
/// <param name="time">Game timing data.</param>
/// <param name="controlled">MercuryParticleEngine.Emitters.Emitter object to process.</param>
public override void ProcessEmitter(GameTime time, Emitter controlled)
{
MouseState state = Mouse.GetState();
controlled.Position.X = (float)state.X;
controlled.Position.Y = (float)state.Y;
switch (_button)
{
case MouseButtons.Left:
{
if (state.LeftButton == ButtonState.Pressed)
controlled.Trigger();
break;
}
case MouseButtons.Middle:
{
if (state.MiddleButton == ButtonState.Pressed)
controlled.Trigger();
break;
}
case MouseButtons.Right:
{
if (state.RightButton == ButtonState.Pressed)
controlled.Trigger();
break;
}
}
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="emitter">Emitter to trail</param>
/// <param name="frequency">Frequency to trigger</param>
public TrailController(Emitter emitter, int frequency)
{
AutoResetEvent autoReset = new AutoResetEvent(false);
TimerCallback timerDelegate = new TimerCallback(Tick);
_emitter = emitter;
_timer = new Timer(timerDelegate, autoReset, 0, frequency);
}
public override void UpdateEmitter(GameTime time, Emitter emitter)
{
if (_primed)
{
emitter.Trigger();
_primed = false;
}
}
public void AddEmitter(Emitter emitter)
{
_emitters.Add(emitter);
foreach (Modifier mod in _modifiers)
{
emitter.ApplyModifier(mod);
}
}
protected override void Initialize()
{
base.Initialize();
emitter = new Emitter(1000);
emitter.ParticleLifespan = 2000;
emitter.ParticleSpeed = 150f;
emitter.ParticleSpeedRange = 50f;
//We have seen some examples of Modifiers in the previous examples. Modifiers
//are always necessary to bring Emitters to life, but there is no limit to the
//amount, and variety of Modifiers you can apply.
emitter.ApplyModifier(new EmitterMouseController(false));
emitter.ApplyModifier(new TimedTriggerController(10f));
//There are many Modifiers to choose from to get the effect you desire, and it
//is easy to create you own (there will be another example of this). Here i will
//demonstrate some of the most useful Modifiers.
//The GravityModifier applys a linear gravity force to all active Particles. You
//can adjust the direction, and the strength of gravity.
emitter.ApplyModifier(new GravityModifier(MathHelper.PiOver2, 350f));
//The Color3Modifier fades the color of Particles between 3 colors. You can
//adjust the sweep rate of the middle color. The interpolation is pre-calculated,
//and you can change the smoothness of the pre-calculation (higher is better).
emitter.ApplyModifier(new Color3Modifier(Color.White.ToVector3(),
Color.SteelBlue.ToVector3(), 0.25f, Color.Purple.ToVector3(), 128));
//Also available is a Color2Modifier, which fades between 2 colors - this is not
//pre-calculated and so you can change the colors in realtime.
//Plus, there is a RandomColorModifier, which gives each spawned Particle a
//random color.
//As well as color, there are similar Modifiers for adjusting Particles opacity
//and scale. They work in the same way. There is the addition of MultiOpacity
//and MultiScale Modifiers, which interpolate between and infinate number of
//values...
emitter.ApplyModifier(new Scale2Modifier(0f, 3f));
emitter.ApplyModifier(new Opacity3Modifier(1f, 1f, 0.75f, 0f, 64));
//The AtmosphereModifier allows you to simulate dense atmosphere of water. It
//works by adjusting the speed of the Particles as they move... A density of 1
//will have no effect on the Particles. A density >1 has the effect of slowing
//Particles.
emitter.ApplyModifier(new AtmosphereModifier(1.2f));
//Finally, the WindowBounceModifier causes Particles to bounce off the edge of
//game window. You can adjust the bounce coefficient.
emitter.ApplyModifier(new WindowBounceModifier(this.Window, .75f));
//As always, we need to add the Emitter to the ParticleSystem.
system.AddEmitter(emitter);
}
public bool RemoveEmitter(Emitter emitter, bool mods)
{
if (mods)
{
foreach (Modifier mod in _modifiers)
{
emitter.RemoveModifier(mod);
}
}
return _emitters.Remove(emitter);
}
/// <summary>
/// Processes the Emitter.
/// </summary>
/// <param name="time">Game timing data.</param>
/// <param name="controlled">MercuryParticleEngine.Emitters.Emitter object to process.</param>
public override void ProcessEmitter(GameTime time, Emitter controlled)
{
GamePadState state = GamePad.GetState(PlayerIndex.One, GamePadDeadZone.Circular);
if (_stick == ThumbSticks.Left)
{
controlled.Position.X += (state.ThumbSticks.Left.X * 32f);
controlled.Position.Y -= (state.ThumbSticks.Left.Y * 32f);
}
else
{
controlled.Position.X += (state.ThumbSticks.Right.X * 32f);
controlled.Position.Y -= (state.ThumbSticks.Right.Y * 32f);
}
switch (_button)
{
case Buttons.A:
{
if (state.Buttons.A == ButtonState.Pressed) { controlled.Trigger(); }
break;
}
case Buttons.B:
{
if (state.Buttons.B == ButtonState.Pressed) { controlled.Trigger(); }
break;
}
case Buttons.X:
{
if (state.Buttons.X == ButtonState.Pressed) { controlled.Trigger(); }
break;
}
case Buttons.Y:
{
if (state.Buttons.Y == ButtonState.Pressed) { controlled.Trigger(); }
break;
}
case Buttons.LB:
{
if (state.Buttons.LeftShoulder == ButtonState.Pressed) { controlled.Trigger(); }
break;
}
case Buttons.RB:
{
if (state.Buttons.RightShoulder == ButtonState.Pressed) { controlled.Trigger(); }
break;
}
}
}
public override void UpdateEmitter(GameTime time, Emitter emitter)
{
MouseState state = Mouse.GetState();
emitter.Position.X = (float)state.X;
emitter.Position.Y = (float)state.Y;
if (_click)
{
if (state.LeftButton == ButtonState.Pressed)
{
emitter.Trigger();
}
}
}
protected override void Initialize()
{
base.Initialize();
//When creating an Emitter, you will always need to specify a budget. The budget
//is the number of Particles the Emittter has, and if the Emitter tries to
//emit more than this number, it will raise a 'starving' event. (Emitter events
//will be demonstrated in another example)
emitter = new Emitter(1000);
//Setting the DischargeQuantity controls how many Particles the Emitter spawns
//each time it is triggered.
emitter.DischargeQuantity = 3;
//The speed of Particles is controlled with two values. The first value is the
//base speed of all Particles, and the second value is the range either side of
//the base speed. Each particle is assigned a random speed value between
//Speed - (Range /2), and Speed + (Range /2).
emitter.ParticleSpeed = 50f;
emitter.ParticleSpeedRange = 50f;
//So, each Particle will have a speed between 25, and 75.
//Applying Modififiers to an Emitter is the way to advanced Emitter effects, and
//can also help integrate the engine into your game. In this example we are
//applying 3 simple Modifiers. The first is a MouseController, which moves the
//position of the Emitter to match the Mouse coordinates. The MouseController
//modifier can also trigger the Emitter when the mouse button is pressed. The
//second is a RandomColorModifier, which causes each spawned Particle to be a
//random color. The third is a RandomScaleModifier, which causes each Particle
//to be a random scale between the minimum and maximum values specified.
Modifier mouseControl = new EmitterMouseController(true);
Modifier randomColor = new RandomColorModifier();
Modifier randomScale = new RandomScaleModifier(.1f, 2f);
//We must apply each of these Modifiers to the Emitter.
emitter.ApplyModifier(mouseControl);
emitter.ApplyModifier(randomColor);
emitter.ApplyModifier(randomScale);
//And finally, we must add the Emitter to the ParticleSystem.
system.AddEmitter(emitter);
//This demonstration is now ready to run!
}
public Game1()
{
graphics = new GraphicsDeviceManager(this);
content = new ContentManager(Services);
system = new ParticleSystem(this);
emitter = new Emitter(1000);
emitter.ParticleSpeed = 150f;
emitter.ApplyModifier(new EmitterMouseController(true));
//When creating an ImageStrip, you must supply 5 pieces of information. You must
//give the ImageStrip a name, so that Emitters can identify it. You must specify
//the number of frames in the ImageStrip, and also the width and height of each
//frame. Finally you must specify the asset name, as specified in the content
//pipeline.
strip = new ImageStrip("custom");
strip.Asset = "CustomParticleImage";
strip.FrameHeight = 128;
strip.FrameWidth = 128;
strip.Frames = 4;
//When it is done, you will add the ImageStrip to the ParticleSystem.
system.ImageStrips.Add("custom", strip);
//Then you will tell the Emitter to use this ImageStrip.
emitter.ImageStrip = "custom";
emitter.Frame = 2;
//When using the ImageStrip, the Emitter will automatically render the
//specified frame at the correct size, and the origin will always be at the
//centre of the frame.
system.AddEmitter(emitter);
//If you make an error, either by telling the Emitter to use an ImageStrip that
//doesn't exist, or telling it to use a frame that doesn't exist - The Emitter
//will instead render Particles with an exclamation mark (!), to let you know
//that there has been an error.
}
public bool RemoveEmitter(Emitter emitter, bool mods)
{
return _groups["Default"].RemoveEmitter(emitter, mods);
}
public void AddEmitter(Emitter emitter)
{
_groups["Default"].AddEmitter(emitter);
}
public virtual void UpdateEmitter(GameTime time, Emitter emitter) { }
/// <summary>
/// Adds an Emitter to the ParticleSystem.
/// </summary>
/// <param name="emitter">MercuryParticleEngine.Emitters.Emitter object to add.</param>
/// <returns>True if the Emitter was successfully added, else false.</returns>
/// <remarks>The system is smart enough to prevent the same Emitter being added
/// multiple times.</remarks>
public bool AddEmitter(Emitter emitter)
{
if (_emitters.Contains(emitter)) { return false; }
_emitters.Add(emitter);
_modifiers.ForEach(delegate(Modifier modifier)
{
emitter.ApplyModifier(modifier);
});
return true;
}
/// <summary>
/// Process an Emitter.
/// </summary>
/// <param name="time">Game timing data.</param>
/// <param name="controlled">MercuryParticleEngine.Emitters.Emitter object to process.</param>
public virtual void ProcessEmitter(GameTime time, Emitter controlled) { }
/// <summary>
/// Default Constructor.
/// </summary>
/// <param name="emitter">Emitter whos Particles will explode on expiry.</param>
public ExplosionController(Emitter emitter)
{
_emitter = emitter;
emitter.Disposing += new EventHandler(Disposed);
}
/// <summary>
/// Removes an Emitter from the ParticleSystem.
/// </summary>
/// <param name="emitter">MercuryParticleEngine.Emitters.Emitter object to remove.</param>
/// <returns>True if the Emitter was successfully removed, else false.</returns>
public bool RemoveEmitter(Emitter emitter)
{
if (!_emitters.Contains(emitter)) { return false; }
_modifiers.ForEach(delegate(Modifier modifier)
{
emitter.RemoveModifier(modifier);
});
return true;
}
