365 lines
20 KiB
C#
365 lines
20 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
/**
|
|
* Use these smooth methods to move one value towards another<br /><br />
|
|
* <strong>Example: </strong><br />fromY = LeanSmooth.spring(fromY, followArrow.localPosition.y, ref velocityY, 1.1f);<br />
|
|
* fromVec3 = LeanSmooth.damp(fromVec3, dude5Title.localPosition, ref velocityVec3, 1.1f);<br />
|
|
* fromColor = LeanSmooth.damp(fromColor, dude5Title.GetComponent<Renderer>().material.color, ref velocityColor, 1.1f);<br />
|
|
* Debug.Log("Smoothed y:" + fromY + " vec3:" + fromVec3 + " color:" + fromColor);<br />
|
|
*
|
|
* @class LeanSmooth
|
|
*/
|
|
|
|
public class LeanSmooth {
|
|
|
|
|
|
/**
|
|
* <summary>Moves one value towards another (eases in and out to destination with no overshoot)</summary>
|
|
*
|
|
* @method LeanSmooth.damp (float)
|
|
* @param {float} current:float the current value
|
|
* @param {float} target:float the value we are trying to reach
|
|
* @param {float} currentVelocity:float the current velocity of the value
|
|
* @param {float} smoothTime:float roughly the time it takes to reach the destination
|
|
* @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @example
|
|
* followVar = LeanSmooth.damp(followVar, destinationVar, ref followVelocity, 1.1f);\n
|
|
* Debug.Log("current:"+followVar);
|
|
*/
|
|
public static float damp(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f)
|
|
{
|
|
if (deltaTime < 0f)
|
|
deltaTime = Time.deltaTime;
|
|
|
|
smoothTime = Mathf.Max(0.0001f, smoothTime);
|
|
float num = 2f / smoothTime;
|
|
float num2 = num * deltaTime;
|
|
float num3 = 1f / (1f + num2 + 0.48f * num2 * num2 + 0.235f * num2 * num2 * num2);
|
|
float num4 = current - target;
|
|
float num5 = target;
|
|
if (maxSpeed > 0f)
|
|
{
|
|
float num6 = maxSpeed * smoothTime;
|
|
num4 = Mathf.Clamp(num4, -num6, num6);
|
|
}
|
|
target = current - num4;
|
|
float num7 = (currentVelocity + num * num4) * deltaTime;
|
|
currentVelocity = (currentVelocity - num * num7) * num3;
|
|
float num8 = target + (num4 + num7) * num3;
|
|
if (num5 - current > 0f == num8 > num5)
|
|
{
|
|
num8 = num5;
|
|
currentVelocity = (num8 - num5) / deltaTime;
|
|
}
|
|
return num8;
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one value towards another (eases in and out to destination with no overshoot)</summary>
|
|
*
|
|
* @method LeanSmooth.damp (Vector3)
|
|
* @param {float} current:Vector3 the current value
|
|
* @param {float} target:Vector3 the value we are trying to reach
|
|
* @param {float} currentVelocity:Vector3 the current velocity of the value
|
|
* @param {float} smoothTime:float roughly the time it takes to reach the destination
|
|
* @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @example
|
|
* transform.position = LeanSmooth.damp(transform.position, destTrans.position, ref followVelocity, 1.1f);\n
|
|
* Debug.Log("current:"+transform.position);
|
|
*/
|
|
public static Vector3 damp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f)
|
|
{
|
|
float x = damp(current.x, target.x, ref currentVelocity.x, smoothTime, maxSpeed, deltaTime);
|
|
float y = damp(current.y, target.y, ref currentVelocity.y, smoothTime, maxSpeed, deltaTime);
|
|
float z = damp(current.z, target.z, ref currentVelocity.z, smoothTime, maxSpeed, deltaTime);
|
|
|
|
return new Vector3(x, y, z);
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one color value towards another color (eases in and out to destination with no overshoot)</summary>
|
|
*
|
|
* @method LeanSmooth.damp (Color)
|
|
* @param {float} current:Color the current value
|
|
* @param {float} target:Color the value we are trying to reach
|
|
* @param {float} currentVelocity:Color the current velocity of the value
|
|
* @param {float} smoothTime:float roughly the time it takes to reach the destination
|
|
* @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @example
|
|
* fromColor = LeanSmooth.damp(fromColor, transform.GetComponent<Renderer>().material.color, ref velocityColor, 1.1f);\n
|
|
* Debug.Log("current:"+fromColor);
|
|
*/
|
|
public static Color damp(Color current, Color target, ref Color currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f)
|
|
{
|
|
float r = damp(current.r, target.r, ref currentVelocity.r, smoothTime, maxSpeed, deltaTime);
|
|
float g = damp(current.g, target.g, ref currentVelocity.g, smoothTime, maxSpeed, deltaTime);
|
|
float b = damp(current.b, target.b, ref currentVelocity.b, smoothTime, maxSpeed, deltaTime);
|
|
float a = damp(current.a, target.a, ref currentVelocity.a, smoothTime, maxSpeed, deltaTime);
|
|
|
|
return new Color(r, g, b, a);
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one value towards another (eases in and out to destination with possible overshoot bounciness)</summary>
|
|
*
|
|
* @method LeanSmooth.spring (float)
|
|
* @param {float} current:float the current value
|
|
* @param {float} target:float the value we are trying to reach
|
|
* @param {float} currentVelocity:float the current velocity of the value
|
|
* @param {float} smoothTime:float roughly the time it takes to reach the destination
|
|
* @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
|
|
* @param {float} [accelRate]:float the rate it accelerates from it's initial position
|
|
* @example
|
|
* followVar = LeanSmooth.spring(followVar, destinationVar, ref followVelocity, 1.1f);\n
|
|
* Debug.Log("current:"+followVar);
|
|
*/
|
|
public static float spring(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f)
|
|
{
|
|
if (deltaTime < 0f)
|
|
deltaTime = Time.deltaTime;
|
|
|
|
float diff = target - current;
|
|
|
|
currentVelocity += deltaTime / smoothTime * accelRate * diff;
|
|
|
|
currentVelocity *= (1f - deltaTime * friction);
|
|
|
|
if (maxSpeed > 0f && maxSpeed < Mathf.Abs(currentVelocity))
|
|
currentVelocity = maxSpeed * Mathf.Sign(currentVelocity);
|
|
|
|
float returned = current + currentVelocity;
|
|
|
|
return returned;
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one value towards another (eases in and out to destination with possible overshoot bounciness)</summary>
|
|
*
|
|
* @method LeanSmooth.spring (Vector3)
|
|
* @param {Vector3} current:float the current value
|
|
* @param {Vector3} target:float the value we are trying to reach
|
|
* @param {Vector3} currentVelocity:float the current velocity of the value
|
|
* @param {float} smoothTime:float roughly the time it takes to reach the destination
|
|
* @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
|
|
* @param {float} [accelRate]:float the rate it accelerates from it's initial position
|
|
* @example
|
|
* transform.position = LeanSmooth.spring(transform.position, destTrans.position, ref followVelocity, 1.1f);\n
|
|
* Debug.Log("current:"+transform.position);
|
|
*/
|
|
public static Vector3 spring(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f)
|
|
{
|
|
float x = spring(current.x, target.x, ref currentVelocity.x, smoothTime, maxSpeed, deltaTime, friction, accelRate);
|
|
float y = spring(current.y, target.y, ref currentVelocity.y, smoothTime, maxSpeed, deltaTime, friction, accelRate);
|
|
float z = spring(current.z, target.z, ref currentVelocity.z, smoothTime, maxSpeed, deltaTime, friction, accelRate);
|
|
|
|
return new Vector3(x, y, z);
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one color towards another (eases in and out to destination with possible overshoot bounciness)</summary>
|
|
*
|
|
* @method LeanSmooth.spring (Color)
|
|
* @param {Color} current:float the current value
|
|
* @param {Color} target:float the value we are trying to reach
|
|
* @param {Color} currentVelocity:float the current velocity of the value
|
|
* @param {float} smoothTime:float roughly the time it takes to reach the destination
|
|
* @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
|
|
* @param {float} [accelRate]:float the rate it accelerates from it's initial position
|
|
* @example
|
|
* fromColor = LeanSmooth.spring(fromColor, transform.GetComponent<Renderer>().material.color, ref velocityColor, 1.1f);\n
|
|
* Debug.Log("current:"+fromColor);
|
|
*/
|
|
public static Color spring(Color current, Color target, ref Color currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f)
|
|
{
|
|
float r = spring(current.r, target.r, ref currentVelocity.r, smoothTime, maxSpeed, deltaTime, friction, accelRate);
|
|
float g = spring(current.g, target.g, ref currentVelocity.g, smoothTime, maxSpeed, deltaTime, friction, accelRate);
|
|
float b = spring(current.b, target.b, ref currentVelocity.b, smoothTime, maxSpeed, deltaTime, friction, accelRate);
|
|
float a = spring(current.a, target.a, ref currentVelocity.a, smoothTime, maxSpeed, deltaTime, friction, accelRate);
|
|
|
|
return new Color(r, g, b, a);
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one value towards another (at a constant speed)</summary>
|
|
*
|
|
* @method LeanSmooth.linear (float)
|
|
* @param {float} current:float the current value
|
|
* @param {float} target:float the value we are trying to reach
|
|
* @param {float} moveSpeed:float the speed at which to move towards the target
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @example
|
|
* followVar = LeanSmooth.linear(followVar, destinationVar, 50f);\n
|
|
* Debug.Log("current:"+followVar);
|
|
*/
|
|
public static float linear(float current, float target, float moveSpeed, float deltaTime = -1f)
|
|
{
|
|
if (deltaTime < 0f)
|
|
deltaTime = Time.deltaTime;
|
|
|
|
bool targetGreater = (target > current);
|
|
|
|
float currentVelocity = deltaTime * moveSpeed * (targetGreater ? 1f : -1f);
|
|
|
|
float returned = current + currentVelocity;
|
|
|
|
float returnPassed = returned - target;
|
|
if ((targetGreater && returnPassed > 0) || !targetGreater && returnPassed < 0)
|
|
{ // Has passed point, return target
|
|
return target;
|
|
}
|
|
|
|
return returned;
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one value towards another (at a constant speed)</summary>
|
|
*
|
|
* @method LeanSmooth.linear (Vector3)
|
|
* @param {Vector3} current:float the current value
|
|
* @param {Vector3} target:float the value we are trying to reach
|
|
* @param {float} moveSpeed:float the speed at which to move towards the target
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @example
|
|
* transform.position = LeanSmooth.linear(transform.position, followTrans.position, 50f);\n
|
|
* Debug.Log("current:"+transform.position);
|
|
*/
|
|
public static Vector3 linear(Vector3 current, Vector3 target, float moveSpeed, float deltaTime = -1f)
|
|
{
|
|
float x = linear(current.x, target.x, moveSpeed, deltaTime);
|
|
float y = linear(current.y, target.y, moveSpeed, deltaTime);
|
|
float z = linear(current.z, target.z, moveSpeed, deltaTime);
|
|
|
|
return new Vector3(x, y, z);
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one color towards another (at a constant speed)</summary>
|
|
*
|
|
* @method LeanSmooth.linear (Color)
|
|
* @param {Color} current:float the current value
|
|
* @param {Color} target:float the value we are trying to reach
|
|
* @param {float} moveSpeed:float the speed at which to move towards the target
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @example
|
|
* fromColor = LeanSmooth.linear(fromColor, transform.GetComponent<Renderer>().material.color, 50f);\n
|
|
* Debug.Log("current:"+fromColor);
|
|
*/
|
|
public static Color linear(Color current, Color target, float moveSpeed)
|
|
{
|
|
float r = linear(current.r, target.r, moveSpeed);
|
|
float g = linear(current.g, target.g, moveSpeed);
|
|
float b = linear(current.b, target.b, moveSpeed);
|
|
float a = linear(current.a, target.a, moveSpeed);
|
|
|
|
return new Color(r, g, b, a);
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one value towards another (with an ease that bounces back some when it reaches it's destination)</summary>
|
|
*
|
|
* @method LeanSmooth.bounceOut (float)
|
|
* @param {float} current:float the current value
|
|
* @param {float} target:float the value we are trying to reach
|
|
* @param {float} currentVelocity:float the current velocity of the value
|
|
* @param {float} smoothTime:float roughly the time it takes to reach the destination
|
|
* @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
|
|
* @param {float} [accelRate]:float the rate it accelerates from it's initial position
|
|
* @param {float} [hitDamping]:float the rate at which to dampen the bounciness of when it reaches it's destination
|
|
* @example
|
|
* followVar = LeanSmooth.bounceOut(followVar, destinationVar, ref followVelocity, 1.1f);\n
|
|
* Debug.Log("current:"+followVar);
|
|
*/
|
|
public static float bounceOut(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f, float hitDamping = 0.9f)
|
|
{
|
|
if (deltaTime < 0f)
|
|
deltaTime = Time.deltaTime;
|
|
|
|
float diff = target - current;
|
|
|
|
currentVelocity += deltaTime / smoothTime * accelRate * diff;
|
|
|
|
currentVelocity *= (1f - deltaTime * friction);
|
|
|
|
if (maxSpeed > 0f && maxSpeed < Mathf.Abs(currentVelocity))
|
|
currentVelocity = maxSpeed * Mathf.Sign(currentVelocity);
|
|
|
|
float returned = current + currentVelocity;
|
|
|
|
bool targetGreater = (target > current);
|
|
float returnPassed = returned - target;
|
|
if ((targetGreater && returnPassed > 0) || !targetGreater && returnPassed < 0)
|
|
{ // Start a bounce
|
|
currentVelocity = -currentVelocity * hitDamping;
|
|
returned = current + currentVelocity;
|
|
}
|
|
|
|
return returned;
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one value towards another (with an ease that bounces back some when it reaches it's destination)</summary>
|
|
*
|
|
* @method LeanSmooth.bounceOut (Vector3)
|
|
* @param {Vector3} current:float the current value
|
|
* @param {Vector3} target:float the value we are trying to reach
|
|
* @param {Vector3} currentVelocity:float the current velocity of the value
|
|
* @param {float} smoothTime:float roughly the time it takes to reach the destination
|
|
* @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
|
|
* @param {float} [accelRate]:float the rate it accelerates from it's initial position
|
|
* @param {float} [hitDamping]:float the rate at which to dampen the bounciness of when it reaches it's destination
|
|
* @example
|
|
* transform.position = LeanSmooth.bounceOut(transform.position, followTrans.position, ref followVelocity, 1.1f);\n
|
|
* Debug.Log("current:"+transform.position);
|
|
*/
|
|
public static Vector3 bounceOut(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f, float hitDamping = 0.9f)
|
|
{
|
|
float x = bounceOut(current.x, target.x, ref currentVelocity.x, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
|
|
float y = bounceOut(current.y, target.y, ref currentVelocity.y, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
|
|
float z = bounceOut(current.z, target.z, ref currentVelocity.z, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
|
|
|
|
return new Vector3(x, y, z);
|
|
}
|
|
|
|
/**
|
|
* <summary>Moves one color towards another (with an ease that bounces back some when it reaches it's destination)</summary>
|
|
*
|
|
* @method LeanSmooth.bounceOut (Color)
|
|
* @param {Color} current:float the current value
|
|
* @param {Color} target:float the value we are trying to reach
|
|
* @param {Color} currentVelocity:float the current velocity of the value
|
|
* @param {float} smoothTime:float roughly the time it takes to reach the destination
|
|
* @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
|
|
* @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
|
|
* @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
|
|
* @param {float} [accelRate]:float the rate it accelerates from it's initial position
|
|
* @param {float} [hitDamping]:float the rate at which to dampen the bounciness of when it reaches it's destination
|
|
* @example
|
|
* fromColor = LeanSmooth.bounceOut(fromColor, transform.GetComponent<Renderer>().material.color, ref followVelocity, 1.1f);\n
|
|
* Debug.Log("current:" + fromColor);
|
|
*/
|
|
public static Color bounceOut(Color current, Color target, ref Color currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f, float hitDamping = 0.9f)
|
|
{
|
|
float r = bounceOut(current.r, target.r, ref currentVelocity.r, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
|
|
float g = bounceOut(current.g, target.g, ref currentVelocity.g, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
|
|
float b = bounceOut(current.b, target.b, ref currentVelocity.b, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
|
|
float a = bounceOut(current.a, target.a, ref currentVelocity.a, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
|
|
|
|
return new Color(r, g, b, a);
|
|
}
|
|
}
|