protected override void OnUpdate(Graphics.UpdateEventArgs e)
{
base.OnUpdate(e);
//A possible optimization would be to break here if the particle effect is not within the frustum
//if(ActiveInMain == CurrenFrame)
// Do the below
//else
// Do nothing
#if PROFILE_PARTICLESYSTEM
if (UpdateStart != null)
{
UpdateStart();
}
#endif
TimeElapsed += e.Dtime;
accDtime += e.Dtime;
if (WithLength && TimeElapsed > EffectDuration)
{
End();
}
#if PROFILE_PARTICLESYSTEM
if (AddStart != null)
{
AddStart();
}
#endif
if (Instant)
{
#if USE_NEW_GRAPHICS_SYSTEM
if (particles.Count != Count)
{
StillAlive = Count;
SpawnGraphicParticles(Count);
}
#else
if (Children.Count() != Count)
{
StillAlive = Count;
ClearChildren();
SpawnEntityParticles(Count);
}
#endif
}
else if (!end)
{
int spawns = (int)(accDtime * (float)SpawnsPerSecond);
if (spawns > 0)
{
accDtime = 0;
}
#if USE_NEW_GRAPHICS_SYSTEM
SpawnGraphicParticles(spawns);
#else
SpawnEntityParticles(spawns);
#endif
StillAlive += spawns;
}
#if PROFILE_PARTICLESYSTEM
if (AddEnd != null)
{
AddEnd();
}
if (LogicStart != null)
{
LogicStart();
}
#endif
#if USE_NEW_GRAPHICS_SYSTEM
foreach (Particle particle in particles)
#else
foreach (ParticleEntity particle in Children)
#endif
{
particle.TimeElapsed += e.Dtime;
if (particle.TimeElapsed > TimeToLive)
{
particlesToBeRemoved.Add(particle);
StillAlive--;
}
#if PROFILE_PARTICLESYSTEM
if (InterpolateStart != null)
{
InterpolateStart();
}
#endif
if (particle.TimeElapsed <= ParticleFadeInTime)
{
((Graphics.Content.MetaModel)particle.MainGraphic).Opacity = particle.TimeElapsed / particleFadeInTime;
}
else if (particle.TimeElapsed >= timeToLive - particleFadeOutTime)
{
((Graphics.Content.MetaModel)particle.MainGraphic).Opacity = (timeToLive - particle.TimeElapsed) / particleFadeOutTime;
}
else
{
((Graphics.Content.MetaModel)particle.MainGraphic).Opacity = 1f;
}
#if PROFILE_PARTICLESYSTEM
if (InterpolateEnd != null)
{
InterpolateEnd();
}
#endif
Direction = Vector3.Normalize(particle.Direction);
float angle = particle.RandomNumbers[0] * HorizontalSpreadAngle;
float vAngle = particle.RandomNumbers[1] * VerticalSpreadAngle;
var spreadAngle = Common.Math.SphericalToCartesianCoordinates(vAngle, angle);
Matrix directionMatrix = Common.Math.MatrixFromNormal(particle.Direction);
Vector3 newDirection = Vector3.Normalize(Vector3.TransformNormal(spreadAngle, directionMatrix));
float speed = (speedMin + (SpeedMax - SpeedMin) * particle.RandomNumbers[2]);
Vector3 initialVelocityForThisParticle = newDirection * speed;
Matrix translationMatrix;
Matrix scalingMatrix;
//Matrix rotationMatrix;
translationMatrix = Matrix.Translation(initialVelocityForThisParticle * particle.TimeElapsed + new Vector3(
((AccelerationMin + (AccelerationMax - AccelerationMin) * particle.RandomNumbers[3]) * particle.Acceleration.X) * particle.TimeElapsed * particle.TimeElapsed,
((AccelerationMin + (AccelerationMax - AccelerationMin) * particle.RandomNumbers[4]) * particle.Acceleration.Y) * particle.TimeElapsed * particle.TimeElapsed,
((AccelerationMin + (AccelerationMax - AccelerationMin) * particle.RandomNumbers[5]) * particle.Acceleration.Z) * particle.TimeElapsed * particle.TimeElapsed)
);
if (RandomScaling)
{
float randomScaleFactor = MinScale + (MaxScale - MinScale) * particle.RandomNumbers[6];
scalingMatrix = Matrix.Scaling((particle.TimeElapsed * ScaleSpeed) * randomScaleFactor + 1.0f * InitialScalingFactor * (randomScaleFactor * 0.3f + 0.85f),
(particle.TimeElapsed * ScaleSpeed) * randomScaleFactor + 1.0f * InitialScalingFactor * (randomScaleFactor * 0.3f + 0.85f),
1.0f);
}
else
{
scalingMatrix = Matrix.Scaling((particle.TimeElapsed * ScaleSpeed) + 1.0f * InitialScalingFactor,
(particle.TimeElapsed * ScaleSpeed) + 1.0f * InitialScalingFactor,
1.0f);
}
//if (RandomRotation)
//{
// Vector3 billBoardDirection = -(((LookatCamera)Scene.Camera).Lookat) - Scene.Camera.Position;
// rotationMatrix = Matrix.RotationAxis(billBoardDirection, (float)(Math.PI * 2.0d * r.NextDouble()));
// throw new NotImplementedException();
//}
//else
//{
// rotationMatrix = Matrix.Identity;
//}
#if PROFILE_PARTICLESYSTEM
if (ParticleUpdateWorldStart != null)
{
ParticleUpdateWorldStart();
}
#endif
//v.WorldMatrix = scalingMatrix * rotationMatrix * translationMatrix * v.InitialTranslation;
#if USE_NEW_GRAPHICS_SYSTEM
particle.MainGraphic.World = particle.InitialModelMatrix * scalingMatrix * translationMatrix * particle.InitialTranslation;
#else
particle.WorldMatrix = scalingMatrix * translationMatrix * particle.InitialTranslation;
#endif
#if PROFILE_PARTICLESYSTEM
if (ParticleUpdateWorldEnd != null)
{
ParticleUpdateWorldEnd();
}
#endif
}
#if PROFILE_PARTICLESYSTEM
if (LogicEnd != null)
{
LogicEnd();
}
if (RemoveStart != null)
{
RemoveStart();
}
#endif
if (StillAlive == 0 && (Instant || end))
{
remove = true;
}
#if USE_NEW_GRAPHICS_SYSTEM
foreach (Particle p in particlesToBeRemoved)
{
RemoveGraphic(p.MainGraphic);
particles.Remove(p);
}
#else
foreach (Graphics.Entity entity in particlesToBeRemoved)
{
entity.Remove();
}
#endif
particlesToBeRemoved.Clear();
if (remove)
{
if (!IsRemoved)
{
Remove();
}
}
#if PROFILE_PARTICLESYSTEM
if (RemoveEnd != null)
{
RemoveEnd();
}
if (UpdateEnd != null)
{
UpdateEnd();
}
#endif
}
protected override void OnUpdate(Graphics.UpdateEventArgs e)
{
base.OnUpdate(e);
if (!Activated)
{
return;
}
cannotPerformAcc += e.Dtime;
if (cannotPerformAcc >= 1)
{
cannotPerformAcc = 0;
lastCannotPerformAbility = null;
lastCannotPerformReason = CannotPerformReason.None;
}
if (Game.Instance.State is Game.PausedState ||
Game.Instance.Map.MainCharacter.State != Map.UnitState.Alive ||
Game.Instance.FrameId <= 2 || !Program.Instance.Focused)
{
return;
}
if (Game.Instance.Input.State.SwitchToMeleeWeapon)
{
Game.Instance.Map.MainCharacter.SelectedWeapon = 0;
}
else if (Game.Instance.Input.State.SwitchToRangedWeapon)
{
Game.Instance.Map.MainCharacter.SelectedWeapon = 1;
}
RunDir.Y = RunDir.X = 0;
//if((GetAsyncKeyState(65) >> 8) != 0)
if (Game.Instance.Input.State.StrafeLeft)
{
RunDir.X -= 1;
}
//if ((GetAsyncKeyState(68) >> 8) != 0)
if (Game.Instance.Input.State.StrafeRight)
{
RunDir.X += 1;
}
//if ((GetAsyncKeyState(87) >> 8) != 0)
if (Game.Instance.Input.State.WalkForward)
{
RunDir.Y += 1;
}
//if ((GetAsyncKeyState(83) >> 8) != 0)
if (Game.Instance.Input.State.WalkBackward)
{
RunDir.Y -= 1;
}
if (RunDir.Length() != 0)
{
Program.Instance.SignalEvent(new ProgramEvents.UserInput {
InputType = ProgramEvents.UserInputType.WASD
});
}
Game.Instance.Map.MainCharacter.Running = RunDir.Length() > 0;
Vector3 mvp = Game.Instance.Input.State.MousePlanePosition;
var dir3 = Vector3.Normalize(mvp - Game.Instance.Map.MainCharacter.Translation);
var dir = Vector2.Normalize(Common.Math.ToVector2(dir3));
if (dir.X == 0 && dir.Y == 0)
{
dir.X = 1;
}
float rot = (float)Common.Math.AngleFromVector3XY(Common.Math.ToVector3(dir));
var worldDir = Vector3.Normalize(Game.Instance.Input.State.MouseGroundPosition -
(Game.Instance.Map.MainCharacter.Translation + Vector3.UnitZ * Game.Instance.Map.MainCharacter.MainAttackFromHeight));
float lean = (float)Math.Asin(worldDir.Z);
if (Game.Instance.Map.MainCharacter.CanControlRotation)
{
#if DEBUG
if (dir.X == 0 && dir.Y == 0)
{
throw new Exception("dir: " + dir + ", rot: " + rot);
}
else
{
Game.Instance.Map.MainCharacter.LookatDir = rot;
}
#else
if (dir.X != 0 || dir.Y != 0)
{
Game.Instance.Map.MainCharacter.LookatDir = rot;
}
#endif
Game.Instance.Map.MainCharacter.TorsoLean = lean;
if (!Game.Instance.Map.MainCharacter.Running)
{
float startMoveLegsAngle = 0.7f;
if (Game.Instance.Map.MainCharacter.TorsoDiffDir > startMoveLegsAngle)
{
Game.Instance.Map.MainCharacter.Orientation = rot - startMoveLegsAngle < 0 ? rot - startMoveLegsAngle + 2f * (float)System.Math.PI : rot - startMoveLegsAngle;
}
else if (Game.Instance.Map.MainCharacter.TorsoDiffDir < -1)
{
Game.Instance.Map.MainCharacter.Orientation = rot + startMoveLegsAngle < 0 ? rot + startMoveLegsAngle + 2f * (float)System.Math.PI : rot + startMoveLegsAngle;
}
}
}
bool spacePressed = Game.Instance.Input.State.Jump;
if (spacePressed && !spaceWasPressed)
{
if (Game.Instance.Map.MainCharacter.State == Client.Game.Map.UnitState.Alive)
{
Game.Instance.Map.MainCharacter.Jump();
Program.Instance.SignalEvent(new ProgramEvents.UserInput {
InputType = ProgramEvents.UserInputType.Jump
});
}
}
spaceWasPressed = spacePressed;
if (Game.Instance.Map.MainCharacter.CanControlMovement)
{
if (RunDir.Length() > 0)
{
var runDir = Vector3.TransformNormal(Common.Math.ToVector3(RunDir),
Game.Instance.Scene.Camera.ViewProjection);
runDir.Z = 0;
runDir.Normalize();
runDir *= Game.Instance.Map.MainCharacter.RunSpeed;
Game.Instance.Map.MainCharacter.MotionUnit.RunVelocity = Common.Math.ToVector2(runDir);
float runAngle = (float)Common.Math.AngleFromVector3XY(runDir);
if (Common.Math.DiffAngle(rot, runAngle) > Math.PI / 2f)
{
runAngle = (float)Common.Math.AngleFromVector3XY(-runDir);
Game.Instance.Map.MainCharacter.RunningBackwards = true;
}
else
{
Game.Instance.Map.MainCharacter.RunningBackwards = false;
}
Game.Instance.Map.MainCharacter.MotionUnit.Rotation = Quaternion.RotationAxis(Vector3.UnitZ, runAngle < 0 ? runAngle + 2f * (float)System.Math.PI : runAngle);
}
else
{
Game.Instance.Map.MainCharacter.MotionUnit.RunVelocity = Vector2.Zero;
}
}
Fire fire = Fire.None;
if (Game.Instance.Map.MainCharacter.CanPerformAbilities &&
!Game.Instance.Map.MainCharacter.IsPerformingAbility)
{
Vector3 mouseGroundPosition = Game.Instance.Input.State.MouseGroundPosition;
//Map.Unit unit = null;
//if (Game.Instance.SceneController.MouseOverEntity != null)
// unit = Game.Instance.SceneController.MouseOverEntity as Map.Unit;
foreach (var v in Game.Instance.Map.MainCharacter.Abilities)
{
//v.TargetEntity = unit;
v.TargetPosition = mouseGroundPosition;
}
Map.Ability ab = null;
if (Game.Instance.Input.State.PrimaryFire)
{
ab = Game.Instance.Map.MainCharacter.PrimaryAbility;
fire = Fire.Primary;
Program.Instance.SignalEvent(new ProgramEvents.UserInput {
InputType = ProgramEvents.UserInputType.FirePrimary
});
}
else if (Game.Instance.Input.State.SecondaryFire)
{
ab = Game.Instance.Map.MainCharacter.SecondaryAbility;
fire = Fire.Secondary;
}
if (ab != null && !ab.IsPerforming)
{
if (!ab.TryStartPerform())
{
if (ab.LastCannotPerformReason != CannotPerformReason.None &&
prevFire != fire)
{
DisplayCannotPerformWarning(ab, ab.LastCannotPerformReason);
}
}
}
}
prevFire = fire;
}
protected override void OnUpdate(Graphics.UpdateEventArgs e)
{
base.OnUpdate(e);
}
