public IModifier3D DeepCopy(IModifiable3D newOwner)
{
SpirographLerpModifier clone = null;
clone = new SpirographLerpModifier();
clone.distWasSmaller = distWasSmaller;
clone.lRadiusWasSmaller = lRadiusWasSmaller;
clone.sRadiusWasSmaller = sRadiusWasSmaller;
clone.radiansWasSmaller = radiansWasSmaller;
clone.targetDist = targetDist;
clone.targetLargeRadius = targetLargeRadius;
clone.targetRadians = targetRadians;
clone.targetSmallRadius = targetSmallRadius;
clone.lerpSpeed = lerpSpeed;
clone.frames = frames;
clone.ID = ID;
if (newOwner != null)
{
clone.Owner = newOwner;
}
else
{
clone.owner = owner;
}
clone.Paused = Paused;
clone.Active = Active;
return(clone);
}
public IModifier3D DeepCopy(IModifiable3D newOwner)
{
OrbitModifier3D clone;
if (Target != null)
{
clone = new OrbitModifier3D(Target, orbitPivot, orbitDist, orbitAngle, orbitSpeed, newOwner, RemoveIfComplete, frames);
}
else
{
clone = new OrbitModifier3D(TargetPosition, orbitPivot, orbitDist, orbitAngle, orbitSpeed, newOwner, RemoveIfComplete, frames);
}
if (Owner != null)
{
clone.Owner = Owner;
}
else
{
clone.Owner = this.Owner;
}
clone.StrictOrbit = StrictOrbit;
clone.Paused = Paused;
clone.Active = Active;
return(clone);
}
/// <summary>
/// Creates a new OrbitModifier3D.
/// </summary>
/// <param name="targetObject">The object the owner will orbit about.</param>
/// <param name="perpedicularAxis">The Vector3 perpendicular to the orbital plane.</param>
/// <param name="distance">How far from the target the owner will be.</param>
/// <param name="initialAngle">The initial angle of the owner along the orbital path.</param>
/// <param name="speed">How fast, in radians, the owner will move along its path.</param>
/// <param name="owner">The object the modifier will be applied to.</param>
/// <param name="removeIfComplete">Set to true to delete this modifier when Active is false.</param>
/// <param name="time">Time, in frames, it will move along the orbit. Set to -1 to orbit forever.</param>
public OrbitModifier3D(IModifiable3D targetObject, Vector3 perpedicularAxis, float distance, float initialAngle, float speed, IModifiable3D owner, bool removeIfComplete, int time)
{
Target = targetObject;
TargetPosition = Target.WorldPosition;
orbitPivot = perpedicularAxis;
orbitSpeed = speed;
orbitDist = distance;
orbitAngle = initialAngle;
Vector3 orbitRightNormal;
this.Owner = owner;
if (orbitPivot != Vector3.Up)
{
orbitRightNormal = Vector3.Cross(orbitPivot, Vector3.Up);
}
else
{
orbitRightNormal = Vector3.Right;
}
Vector3 orbitUpNormal = Vector3.Cross(orbitRightNormal, orbitPivot);
currentOrbitLocation = new Vector3((float)(orbitDist * Math.Cos(orbitAngle) * orbitRightNormal.X + orbitDist * Math.Sin(orbitAngle) * orbitUpNormal.X),
(float)(orbitDist * Math.Cos(orbitAngle) * orbitRightNormal.Y + orbitDist * Math.Sin(orbitAngle) * orbitUpNormal.Y),
(float)(orbitDist * Math.Cos(orbitAngle) * orbitRightNormal.Z + orbitDist * Math.Sin(orbitAngle) * orbitUpNormal.Z)) + TargetPosition;
owner.WorldPosition = currentOrbitLocation;
lastOwnerPosition = currentOrbitLocation;
Active = true;
RemoveIfComplete = removeIfComplete;
frames = time;
}
/// <summary>
/// Creates a new RotateTo Modifier.
/// </summary>
/// <param name="targetRotation">Quaternion that the owner will rotate to.</param>
/// <param name="owner">The object the modifier will be applied to.</param>
/// <param name="removeIfComplete">Set to true to delete this modifier when Active is false.</param>
/// <param name="time">Time, in frames, it will take to rotate. Set to 1 for immediate rotation.</param>
public RotateToModifier3D(Quaternion targetRotation, IModifiable3D owner, bool removeIfComplete, int time)
{
if (time < 1)
{
throw new ArgumentException("This modifier takes at least 1 frame to execute.", "time");
}
frames = time;
this.Owner = owner;
Active = true;
targetRotation.Normalize();
Vector3 rotationAxis = Vector3.Transform(Vector3.UnitY, owner.Rotation);
rotationAxis.Normalize();
Vector3 targetAxis = Vector3.Transform(Vector3.UnitY, targetRotation);
targetAxis.Normalize();
float angleToTarget = (float)Math.Acos(Vector3.Dot(rotationAxis, targetAxis));
if (float.IsNaN(angleToTarget))
{
angleToTarget = 0;
}
if (angleToTarget != 0)
{
float lerpAngularSpeed = angleToTarget / time;
Vector3 pivotAxis = Vector3.Cross(rotationAxis, targetAxis);
pivotAxis.Normalize();
lerpSpeed = Quaternion.CreateFromAxisAngle(pivotAxis, lerpAngularSpeed);
}
else
{
lerpSpeed = Quaternion.Identity;
}
}
public ColorModifier3D(Color color, bool removeIfComplete, IModifiable3D owner, int time)
{
prevColor = owner.Color;
targetColor = color;
frames = time;
Active = true;
RemoveIfComplete = removeIfComplete;
}
/// <summary>
/// Creates a new MoveTo Modifier.
/// </summary>
/// <param name="target">Object the owner will move to.</param>
/// <param name="owner">The object the modifier will be applied to.</param>
/// <param name="removeIfComplete">Set to true to delete this modifier when Active is false.</param>
/// <param name="time">Time, in frames, it will take to move. Set to 1 for immediate movement.</param>
public MoveToModifier3D(IModifiable3D target, IModifiable3D owner, bool removeIfComplete, int time)
{
if (time < 1)
{
throw new ArgumentException("This modifier takes at least 1 frame to execute.", "time");
}
framesLeft = time;
Active = true;
RemoveIfComplete = removeIfComplete;
this.target = target;
}
/// <summary>
/// Creates a new FollowModifier3D.
/// </summary>
/// <param name="target">Object to follow.</param>
/// <param name="strict">If true, this modifier will override all others.</param>
/// <param name="removeIfComplete">Set to true to delete this modifier when Active is false.</param>
/// <param name="time">How long to follow it for.</param>
public FollowModifier3D(IModifiable3D target, bool strict, bool removeIfComplete, int time)
{
this.target = target;
targetLastPosition = target.WorldPosition;
followX = true;
followY = true;
followZ = true;
strictFollow = strict;
RemoveIfComplete = removeIfComplete;
frames = time;
Active = true;
}
public IModifier3D DeepCopy(IModifiable3D newOwner)
{
RotateModifier3D clone = new RotateModifier3D(rotationalMomentum, RemoveIfComplete, frames);
if (newOwner != null)
{
clone.Owner = newOwner;
}
else
{
clone.Owner = Owner;
}
clone.ID = ID;
clone.Paused = Paused;
clone.Active = Active;
return(clone);
}
public IModifier3D DeepCopy(IModifiable3D newOwner)
{
ColorModifier3D clone = new ColorModifier3D(targetColor, RemoveIfComplete, Owner, frames);
if (newOwner != null)
{
clone.Owner = newOwner;
}
else
{
clone.Owner = Owner;
}
clone.prevColor = prevColor;
clone.framesSpent = framesSpent;
clone.Paused = Paused;
return(clone);
}
public IModifier3D DeepCopy(IModifiable3D newOwner)
{
BillboardModifier3D clone = new BillboardModifier3D(Strict, RemoveIfComplete, frames);
clone.prevRotation = prevRotation;
if (newOwner != null)
{
clone.Owner = newOwner;
}
else
{
clone.Owner = Owner;
}
clone.ID = ID;
clone.Paused = Paused;
clone.Active = Active;
return(clone);
}
public IModifier3D DeepCopy(IModifiable3D newOwner)
{
RotateToModifier3D clone = new RotateToModifier3D();
clone.frames = frames;
clone.lerpSpeed = lerpSpeed;
if (newOwner != null)
{
clone.Owner = newOwner;
}
else
{
clone.Owner = Owner;
}
clone.ID = ID;
clone.Paused = Paused;
clone.Active = Active;
return(clone);
}
public IModifier3D DeepCopy(IModifiable3D newOwner)
{
ScaleToModifier3D clone = new ScaleToModifier3D();
clone.lerpSpeed = lerpSpeed;
clone.frames = frames;
if (newOwner != null)
{
clone.Owner = newOwner;
}
else
{
clone.Owner = Owner;
}
clone.RemoveIfComplete = RemoveIfComplete;
clone.ID = ID;
clone.Active = Active;
clone.Paused = Paused;
return(clone);
}
/// <summary>
/// Creates a new FollowModifier3D.
/// </summary>
/// <param name="target">Object to follow.</param>
/// <param name="followAxes">Sets which axes to follow the target on. Set a value to -1 to ignore that axis.</param>
/// <param name="strict">If true, this modifier will override all others.</param>
/// <param name="removeIfComplete">Set to true to delete this modifier when Active is false.</param>
/// <param name="time">How long to follow it for.</param>
public FollowModifier3D(IModifiable3D target, Vector3 followAxes, bool strict, bool removeIfComplete, int time)
{
this.target = target;
targetLastPosition = target.WorldPosition;
if (followAxes.X != -1)
{
followX = true;
}
if (followAxes.Y != -1)
{
followY = true;
}
if (followAxes.Z != -1)
{
followZ = true;
}
strictFollow = strict;
RemoveIfComplete = removeIfComplete;
frames = time;
Active = true;
}
public IModifier3D DeepCopy(IModifiable3D newOwner)
{
SmoothStepModifier3D clone = null;
clone = new SmoothStepModifier3D(endPoint, Owner, RemoveIfComplete, 2);
clone.framesSpent = framesSpent;
clone.frames = frames;
clone.startPoint = startPoint;
if (newOwner != null)
{
clone.Owner = newOwner;
}
else
{
clone.Owner = Owner;
}
clone.ID = ID;
clone.Paused = Paused;
clone.Active = Active;
return(clone);
}
/// <summary>
/// Creates a new OrbitModifier3D.
/// </summary>
/// <param name="targetObject">The object the owner will orbit about.</param>
/// <param name="startingPosition">The Vector3 the owner will start from.</param>
/// <param name="speed">How fast, in radians, the owner will move along its path.</param>
/// <param name="owner">The object the modifier will be applied to.</param>
/// <param name="removeIfComplete">Set to true to delete this modifier when Active is false.</param>
/// <param name="time">Time, in frames, it will move along the orbit. Set to -1 to orbit forever.</param>
public OrbitModifier3D(IModifiable3D targetObject, Vector3 startingPosition, float speed, IModifiable3D owner, bool removeIfComplete, int time)
{
Target = targetObject;
TargetPosition = Target.WorldPosition;
Vector3 startingVector = (startingPosition - TargetPosition);
Vector3 startingRightNormal = Vector3.Cross(startingVector, Vector3.Up);
orbitPivot = Vector3.Cross(startingRightNormal, startingVector);
orbitSpeed = speed;
orbitDist = startingVector.Length();
this.Owner = owner;
Vector3 startingOrbitLocation = new Vector3((float)(orbitDist * startingRightNormal.X), //orbitAngle = 0, cos(orbitAngle) = 1, sin(orbitAngle) = 0.
(float)(orbitDist * startingRightNormal.Y),
(float)(orbitDist * startingRightNormal.Z)) + TargetPosition;
orbitAngle = (float)Math.Acos(Vector3.Dot(startingPosition, startingOrbitLocation));
Vector3 orbitRightNormal;
if (orbitPivot != Vector3.Up)
{
orbitRightNormal = Vector3.Cross(orbitPivot, Vector3.Up);
}
else
{
orbitRightNormal = Vector3.Right;
}
Vector3 orbitUpNormal = Vector3.Cross(orbitRightNormal, orbitPivot);
currentOrbitLocation = new Vector3((float)(orbitDist * Math.Cos(orbitAngle) * orbitRightNormal.X + orbitDist * Math.Sin(orbitAngle) * orbitUpNormal.X),
(float)(orbitDist * Math.Cos(orbitAngle) * orbitRightNormal.Y + orbitDist * Math.Sin(orbitAngle) * orbitUpNormal.Y),
(float)(orbitDist * Math.Cos(orbitAngle) * orbitRightNormal.Z + orbitDist * Math.Sin(orbitAngle) * orbitUpNormal.Z)) + TargetPosition;
owner.WorldPosition = currentOrbitLocation;
lastOwnerPosition = currentOrbitLocation;
Active = true;
RemoveIfComplete = removeIfComplete;
frames = time;
}
public IModifier3D DeepCopy(IModifiable3D newOwner)
{
MoveToModifier3D clone = null;
clone = new MoveToModifier3D(targetPosition, Owner, RemoveIfComplete, 2);
clone.framesLeft = framesLeft;
if (target != null)
{
clone.target = target;
}
clone.targetPosition = targetPosition;
if (newOwner != null)
{
clone.Owner = newOwner;
}
else
{
clone.Owner = Owner;
}
clone.Paused = Paused;
clone.Active = Active;
return(clone);
}
/// <summary>
/// Creates a new ScaleTo Modifier.
/// </summary>
/// <param name="targetRotation">Size that the owner will scale to.</param>
/// <param name="owner">The object the modifier will be applied to.</param>
/// <param name="removeIfComplete">Set to true to delete this modifier when Active is false.</param>
/// <param name="time">Time, in frames, it will take to scale. Set to 1 for immediate rescaling.</param>
public ScaleToModifier3D(Vector3 targetScale, IModifiable3D owner, bool removeIfComplete, int time)
{
if (time < 1)
{
throw new ArgumentException("This modifier takes at least 1 frame to execute.", "time");
}
frames = time;
Active = true;
RemoveIfComplete = removeIfComplete;
if (targetScale.X != -1)
{
lerpSpeed.X = (owner.Scale.X - targetScale.X) / time;
}
if (targetScale.Y != -1)
{
lerpSpeed.Y = (owner.Scale.Y - targetScale.Y) / time;
}
if (targetScale.Z != -1)
{
lerpSpeed.Z = (owner.Scale.Z - targetScale.Z) / time;
}
}
public IModifier3D DeepCopy(IModifiable3D newOwner)
{
FollowModifier3D clone = null;
clone = new FollowModifier3D(target, strictFollow, RemoveIfComplete, 2);
clone.frames = frames;
clone.followX = followX;
clone.followY = followY;
clone.followZ = followZ;
clone.targetLastPosition = targetLastPosition;
if (newOwner != null)
{
clone.Owner = newOwner;
}
else
{
clone.Owner = Owner;
}
clone.ID = ID;
clone.Paused = Paused;
clone.Active = Active;
return(clone);
}
/// <summary>
/// Creates a new SmoothStep Modifier.
/// </summary>
/// <param name="targetPosition">Position the object will move to.</param>
/// <param name="owner">The object the modifier will be applied to.</param>
/// <param name="removeIfComplete">Set to true to delete this modifier when Active is false.</param>
/// <param name="time">Time, in frames, it will take to move. Set to 1 for immediate movement.</param>
public SmoothStepModifier3D(Vector3 targetPosition, IModifiable3D owner, bool removeIfComplete, int time)
{
if (time < 1)
{
throw new ArgumentException("This modifier takes at least 1 frame to execute.", "time");
}
frames = time;
Active = true;
startPoint = owner.WorldPosition;
RemoveIfComplete = removeIfComplete;
endPoint = startPoint;
if (targetPosition.X != -1)
{
endPoint.X = targetPosition.X;
}
if (targetPosition.Y != -1)
{
endPoint.Y = targetPosition.Y;
}
if (targetPosition.Z != -1)
{
endPoint.Z = targetPosition.Z;
}
}
