void Decelerate()
{
if (deceleration > 0 && accelerators.Count == 0)
{
velocity = SloneUtil.AdvanceValue(velocity, Vector3.zero, deceleration);
}
}
// Update is called once per frame
void FixedUpdate()
{
foreach (Vector3 acc in accelerators)
{
velocity += acc * Time.deltaTime;
}
if (topSpeed > 0)
{
velocity = SloneUtil.CapMagnitude(velocity, topSpeed);
}
Vector3 frameMove = velocity * Time.fixedDeltaTime;
if (localMotion)
{
Vector3 forward = moverTransform.forward;
Vector3 right = moverTransform.right;
Vector3 up = moverTransform.up;
moverTransform.position += ((right * frameMove.x) + (up * frameMove.y) + (forward * frameMove.z));
}
else
{
moverTransform.position += frameMove;
}
Decelerate();
}
// Update is called once per frame
void Update()
{
if (acceleration != 0f)
{
rotateVector = SloneUtil.AdvanceValue(rotateVector, goalRotateVector, acceleration);
if (rotateVector == goalRotateVector)
{
acceleration = 0f;
}
}
Vector3 finalRotation = rotateVector + randomizedRotation;
if (localRotation)
{
moverTransform.Rotate(finalRotation * Time.deltaTime);
}
else
{
moverTransform.RotateAround(moverTransform.position, Vector3.right, finalRotation.x * Time.deltaTime);
moverTransform.RotateAround(moverTransform.position, Vector3.up, finalRotation.y * Time.deltaTime);
moverTransform.RotateAround(moverTransform.position, Vector3.forward, finalRotation.z * Time.deltaTime);
}
}
// Advance the current position along the path according to the speed
// and time that has passed.
//
protected override void AdvancePath(float speed, float deltaTime)
{
Vector3 pos = transform.position;
float desiredDistance = speed * deltaTime;
desiredDistance *= desiredDistance;
while (pos.DistanceSquared(transform.position) < desiredDistance)
{
int pointIndex = Mathf.FloorToInt(t);
if (pointIndex >= curve.pointCount - 1)
{
break;
}
float stepSize = desiredDistance / curveLengths [pointIndex];
t += stepSize;
pos = GetPosition(t);
}
t = Mathf.Clamp(t, 0.0f, (float)(curve.pointCount - 1));
transform.position = SloneUtil.AdvanceValue(transform.position, pos, speed);
}
IEnumerator Move_coroutine(Vector3 newPosition, float moveTime, bool smooth = true, bool localMovement = false)
{
Vector3 startPosition;
if (localMovement)
{
startPosition = moverTransform.localPosition;
}
else
{
startPosition = moverTransform.position;
}
float startTime = Time.time;
if (moveTime > 0)
{
while (startTime + moveTime > Time.time)
{
yield return(new WaitForFixedUpdate());
float pct = (Time.time - startTime) / moveTime;
if (localMovement)
{
if (smooth)
{
moverTransform.localPosition = SloneUtil.LerpSmooth(startPosition, newPosition, pct);
}
else
{
moverTransform.localPosition = Vector3.Lerp(startPosition, newPosition, pct);
}
}
else
{
if (smooth)
{
moverTransform.position = SloneUtil.LerpSmooth(startPosition, newPosition, pct);
}
else
{
moverTransform.position = Vector3.Lerp(startPosition, newPosition, pct);
}
}
}
}
if (localMovement)
{
moverTransform.localPosition = newPosition;
}
else
{
moverTransform.position = newPosition;
}
moveRoutine = null;
}
// Update is called once per frame
void Update()
{
float pct = 1.0f;
if (changeTime > 0f)
{
pct = Mathf.Clamp01((Time.time - startTime) / changeTime);
}
sharedMaterialInstance.GetMaterialInstance().color = SloneUtil.Lerp(startColor, endColor, pct);
}
void Update()
{
if (scaleSpeed > 0f)
{
moverTransform.localScale = SloneUtil.AdvanceValue(moverTransform.localScale, scaleGoal, scaleSpeed);
// Once we reach it, stop advancing.
if (moverTransform.localScale == scaleGoal)
{
scaleSpeed = 0f;
}
}
}
IEnumerator Rotate_coroutine(Vector3 newAngles, float time, bool smooth = true, bool localMovement = true)
{
Vector3 startAngles;
if (localMovement)
{
startAngles = moverTransform.localEulerAngles;
}
else
{
startAngles = moverTransform.eulerAngles;
}
float startTime = Time.time;
if (rotateTime > 0)
{
while (startTime + rotateTime > Time.time)
{
yield return(new WaitForEndOfFrame());
float pct = (Time.time - startTime) / rotateTime;
if (smooth)
{
pct = SloneUtil.LerpSmooth(0f, 1f, pct);
}
if (localMovement)
{
moverTransform.localEulerAngles = SloneUtil.LerpEulerAngles(startAngles, newAngles, pct);
}
else
{
moverTransform.eulerAngles = SloneUtil.LerpEulerAngles(startAngles, newAngles, pct);
}
}
}
if (localMovement)
{
moverTransform.localEulerAngles = newAngles;
}
else
{
moverTransform.eulerAngles = newAngles;
}
}
IEnumerator Rotate_coroutine(Vector3 newRotation, float moveTime, bool localMovement = false)
{
Vector3 startRotation;
if (localMovement)
{
startRotation = moverTransform.localEulerAngles;
}
else
{
startRotation = moverTransform.eulerAngles;
}
float startTime = Time.time;
if (moveTime > 0)
{
while (startTime + moveTime > Time.time)
{
yield return(new WaitForFixedUpdate());
float pct = (Time.time - startTime) / moveTime;
if (localMovement)
{
moverTransform.localEulerAngles = SloneUtil.LerpEulerAngles(startRotation, newRotation, pct);
}
else
{
moverTransform.eulerAngles = SloneUtil.LerpEulerAngles(startRotation, newRotation, pct);
}
}
}
if (localMovement)
{
moverTransform.localEulerAngles = newRotation;
}
else
{
moverTransform.eulerAngles = newRotation;
}
rotateRoutine = null;
}
// Get the world-space vector from this point to the nearest point onscreen that maintains
// the current distance from the camera.
//
// position: position to check.
// cam: camera on which to check (Deaults to main camera).
//
public static Vector2 GetVectorToOnscreen(Vector3 position, Camera cam = null)
{
if (cam == null)
{
cam = Camera.main;
}
Vector3 toPosition = position - cam.transform.position;
float zDist = Vector3.Dot(toPosition, cam.transform.forward);
if (zDist < 0)
{
Debug.LogError("Cannot find distance offscreen for object behind camera.");
return(Vector2.zero);
}
// Get the position relative to the camera.
float xDist = Vector3.Dot(toPosition, cam.transform.right);
float yDist = Vector3.Dot(toPosition, cam.transform.up);
Vector2 halfViewportSize = SloneUtil.GetViewportSizeAtDistance(zDist, cam) * 0.5f;
// Calculate the distance from each camera-relative direction (x and y) and multiply back into world space.
//
Vector2 returnX = Vector2.zero;
if (Mathf.Abs(xDist) > halfViewportSize.x)
{
float xOffscreen = -1f * Mathf.Sign(xDist) * (Mathf.Abs(xDist) - halfViewportSize.x);
returnX = xOffscreen * cam.transform.right;
}
Vector2 returnY = Vector2.zero;
if (Mathf.Abs(yDist) > halfViewportSize.y)
{
float yOffscreen = -1f * Mathf.Sign(yDist) * (Mathf.Abs(yDist) - halfViewportSize.y);
returnY = yOffscreen * cam.transform.up;
}
return(returnX + returnY);
}
// Evaluate the oscillator as a curve with output between 0 and 1.
//
private float Evaluate01()
{
// Multiply by 2 so that 50% yields 1.0 and 100% is back to 0.0.
float pct = ((Time.time - startTime) / wavelength) * 2f;
if (curveType == OscillationType.SMOOTH)
{
return(SloneUtil.LerpSmooth(0f, 1f, pct, true));
}
else
{
if (curveType != OscillationType.LINEAR)
{
Debug.LogError("Unknown OscillationType: " + curveType);
}
int baseNumber = Mathf.FloorToInt(pct);
bool downSwing = (baseNumber % 2) == 1;
float leftoverPct = pct - ((float)baseNumber);
return(downSwing ? 1.0f - leftoverPct : leftoverPct);
}
}
// Advance the rotation of the camera toward the specified goal.
//
// goalAngle: Angle (in degrees, 0-360) toward which to rotate the camera.
//
void UpdateRotation(float goalAngle)
{
Vector3 angles = Camera.main.transform.eulerAngles;
Camera.main.transform.eulerAngles = new Vector3(angles.x, angles.y, SloneUtil.AdvanceAngle(angles.z, goalAngle, rotationChangeSpeed));
}
// Advance the field of view toward the specified goal.
//
// goalFov: the desired final FOV.
//
void UpdateFOV(float goalFov)
{
Camera.main.fieldOfView = SloneUtil.AdvanceValue(Camera.main.fieldOfView, goalFov, fovChangeSpeed);
}
// Lerp from one vector to another using a smoothed lerp to ease departure and approach.
//
// from: starting value, returned if pct is 0.0
// to: ending value, returned if pct is 1.0
// pct: percentage (0.0-1.0) along the continuum between from and to
// oscillate: True if values beyond 0-1 should oscillate back to where they started.
//
public static Vector3 LerpSmooth(Vector3 from, Vector3 to, float pct, bool oscillate = false)
{
float smoothed = SmoothValue(pct, oscillate);
return(SloneUtil.LerpUnbounded(from, to, smoothed));
}
