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; } }