You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
173 lines
6.8 KiB
173 lines
6.8 KiB
using UnityEngine;
|
|
namespace Animmal.Animmals1
|
|
{
|
|
public sealed class Mathfx
|
|
{
|
|
//Ease in out
|
|
public static float EasyInOut(float start, float end, float value)
|
|
{
|
|
return Mathf.Lerp(start, end, value * value * (3.0f - 2.0f * value));
|
|
}
|
|
|
|
public static Vector2 EasyInOut(Vector2 start, Vector2 end, float value)
|
|
{
|
|
return new Vector2(EasyInOut(start.x, end.x, value), EasyInOut(start.y, end.y, value));
|
|
}
|
|
|
|
public static Vector3 EasyInOut(Vector3 start, Vector3 end, float value)
|
|
{
|
|
return new Vector3(EasyInOut(start.x, end.x, value), EasyInOut(start.y, end.y, value), EasyInOut(start.z, end.z, value));
|
|
}
|
|
|
|
//Ease out
|
|
public static float EasyOut(float start, float end, float value)
|
|
{
|
|
return Mathf.Lerp(start, end, Mathf.Sin(value * Mathf.PI * 0.5f));
|
|
}
|
|
|
|
public static Vector2 EasyOut(Vector2 start, Vector2 end, float value)
|
|
{
|
|
return new Vector2(Mathf.Lerp(start.x, end.x, Mathf.Sin(value * Mathf.PI * 0.5f)), Mathf.Lerp(start.y, end.y, Mathf.Sin(value * Mathf.PI * 0.5f)));
|
|
}
|
|
|
|
public static Vector3 EasyOut(Vector3 start, Vector3 end, float value)
|
|
{
|
|
return new Vector3(Mathf.Lerp(start.x, end.x, Mathf.Sin(value * Mathf.PI * 0.5f)), Mathf.Lerp(start.y, end.y, Mathf.Sin(value * Mathf.PI * 0.5f)), Mathf.Lerp(start.z, end.z, Mathf.Sin(value * Mathf.PI * 0.5f)));
|
|
}
|
|
|
|
//Ease in
|
|
public static float EasyIn(float start, float end, float value)
|
|
{
|
|
return Mathf.Lerp(start, end, 1.0f - Mathf.Cos(value * Mathf.PI * 0.5f));
|
|
}
|
|
|
|
public static Vector2 EasyIn(Vector2 start, Vector2 end, float value)
|
|
{
|
|
return new Vector2(EasyIn(start.x, end.x, value), EasyIn(start.y, end.y, value));
|
|
}
|
|
|
|
public static Vector3 EasyIn(Vector3 start, Vector3 end, float value)
|
|
{
|
|
return new Vector3(EasyIn(start.x, end.x, value), EasyIn(start.y, end.y, value), EasyIn(start.z, end.z, value));
|
|
}
|
|
|
|
//Boing
|
|
public static float Boing(float start, float end, float value)
|
|
{
|
|
value = Mathf.Clamp01(value);
|
|
value = (Mathf.Sin(value * Mathf.PI * (0.2f + 2.5f * value * value * value)) * Mathf.Pow(1f - value, 2.2f) + value) * (1f + (1.2f * (1f - value)));
|
|
return start + (end - start) * value;
|
|
}
|
|
|
|
public static Vector2 Boing(Vector2 start, Vector2 end, float value)
|
|
{
|
|
return new Vector2(Boing(start.x, end.x, value), Boing(start.y, end.y, value));
|
|
}
|
|
|
|
public static Vector3 Boing(Vector3 start, Vector3 end, float value)
|
|
{
|
|
return new Vector3(Boing(start.x, end.x, value), Boing(start.y, end.y, value), Boing(start.z, end.z, value));
|
|
}
|
|
|
|
//Like lerp with ease in ease out
|
|
public static float SmoothStep(float x, float min, float max)
|
|
{
|
|
x = Mathf.Clamp(x, min, max);
|
|
float v1 = (x - min) / (max - min);
|
|
float v2 = (x - min) / (max - min);
|
|
return -2 * v1 * v1 * v1 + 3 * v2 * v2;
|
|
}
|
|
|
|
public static Vector2 SmoothStep(Vector2 vec, float min, float max)
|
|
{
|
|
return new Vector2(SmoothStep(vec.x, min, max), SmoothStep(vec.y, min, max));
|
|
}
|
|
|
|
public static Vector3 SmoothStep(Vector3 vec, float min, float max)
|
|
{
|
|
return new Vector3(SmoothStep(vec.x, min, max), SmoothStep(vec.y, min, max), SmoothStep(vec.z, min, max));
|
|
}
|
|
|
|
public static float Lerp(float start, float end, float value)
|
|
{
|
|
return ((1.0f - value) * start) + (value * end);
|
|
}
|
|
|
|
public static Vector3 NearestPoint(Vector3 lineStart, Vector3 lineEnd, Vector3 point)
|
|
{
|
|
Vector3 lineDirection = Vector3.Normalize(lineEnd - lineStart);
|
|
float closestPoint = Vector3.Dot((point - lineStart), lineDirection);
|
|
return lineStart + (closestPoint * lineDirection);
|
|
}
|
|
|
|
public static Vector3 NearestPointStrict(Vector3 lineStart, Vector3 lineEnd, Vector3 point)
|
|
{
|
|
Vector3 fullDirection = lineEnd - lineStart;
|
|
Vector3 lineDirection = Vector3.Normalize(fullDirection);
|
|
float closestPoint = Vector3.Dot((point - lineStart), lineDirection);
|
|
return lineStart + (Mathf.Clamp(closestPoint, 0.0f, Vector3.Magnitude(fullDirection)) * lineDirection);
|
|
}
|
|
|
|
//Bounce
|
|
public static float Bounce(float x)
|
|
{
|
|
return Mathf.Abs(Mathf.Sin(6.28f * (x + 1f) * (x + 1f)) * (1f - x));
|
|
}
|
|
|
|
public static Vector2 Bounce(Vector2 vec)
|
|
{
|
|
return new Vector2(Bounce(vec.x), Bounce(vec.y));
|
|
}
|
|
|
|
public static Vector3 Bounce(Vector3 vec)
|
|
{
|
|
return new Vector3(Bounce(vec.x), Bounce(vec.y), Bounce(vec.z));
|
|
}
|
|
|
|
// test for value that is near specified float (due to floating point inprecision)
|
|
// all thanks to Opless for this!
|
|
public static bool Approx(float val, float about, float range)
|
|
{
|
|
return ((Mathf.Abs(val - about) < range));
|
|
}
|
|
|
|
// test if a Vector3 is close to another Vector3 (due to floating point inprecision)
|
|
// compares the square of the distance to the square of the range as this
|
|
// avoids calculating a square root which is much slower than squaring the range
|
|
public static bool Approx(Vector3 val, Vector3 about, float range)
|
|
{
|
|
return ((val - about).sqrMagnitude < range * range);
|
|
}
|
|
|
|
/*
|
|
* CLerp - Circular Lerp - is like lerp but handles the wraparound from 0 to 360.
|
|
* This is useful when interpolating eulerAngles and the object
|
|
* crosses the 0/360 boundary. The standard Lerp function causes the object
|
|
* to rotate in the wrong direction and looks stupid. Clerp fixes that.
|
|
*/
|
|
public static float Clerp(float start, float end, float value)
|
|
{
|
|
float min = 0.0f;
|
|
float max = 360.0f;
|
|
float half = Mathf.Abs((max - min) / 2.0f);//half the distance between min and max
|
|
float retval = 0.0f;
|
|
float diff = 0.0f;
|
|
|
|
if ((end - start) < -half)
|
|
{
|
|
diff = ((max - start) + end) * value;
|
|
retval = start + diff;
|
|
}
|
|
else if ((end - start) > half)
|
|
{
|
|
diff = -((max - end) + start) * value;
|
|
retval = start + diff;
|
|
}
|
|
else retval = start + (end - start) * value;
|
|
|
|
// Debug.Log("Start: " + start + " End: " + end + " Value: " + value + " Half: " + half + " Diff: " + diff + " Retval: " + retval);
|
|
return retval;
|
|
}
|
|
|
|
}
|
|
}
|