From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- Client/Assets/Scripts/XUtliPoolLib/XInterpolate.cs | 520 +++++++++++++++++++++ 1 file changed, 520 insertions(+) create mode 100644 Client/Assets/Scripts/XUtliPoolLib/XInterpolate.cs (limited to 'Client/Assets/Scripts/XUtliPoolLib/XInterpolate.cs') diff --git a/Client/Assets/Scripts/XUtliPoolLib/XInterpolate.cs b/Client/Assets/Scripts/XUtliPoolLib/XInterpolate.cs new file mode 100644 index 00000000..aedb912c --- /dev/null +++ b/Client/Assets/Scripts/XUtliPoolLib/XInterpolate.cs @@ -0,0 +1,520 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEngine; + +namespace XUtliPoolLib +{ + public class XInterpolate + { + public enum EaseType + { + Linear, + EaseInQuad, + EaseOutQuad, + EaseInOutQuad, + EaseInCubic, + EaseOutCubic, + EaseInOutCubic, + EaseInQuart, + EaseOutQuart, + EaseInOutQuart, + EaseInQuint, + EaseOutQuint, + EaseInOutQuint, + EaseInSine, + EaseOutSine, + EaseInOutSine, + EaseInExpo, + EaseOutExpo, + EaseInOutExpo, + EaseInCirc, + EaseOutCirc, + EaseInOutCirc + } + + public delegate Vector3 ToVector3(T v); + + public delegate float Function(float a, float b, float c, float d); + + private static Vector3 Identity(Vector3 v) + { + return v; + } + + private static Vector3 TransformDotPosition(Transform t) + { + return t.position; + } + + private static IEnumerable NewTimer(float duration) + { + float elapsedTime = 0f; + while (elapsedTime < duration) + { + yield return elapsedTime; + elapsedTime += Time.deltaTime; + bool flag = elapsedTime >= duration; + if (flag) + { + yield return elapsedTime; + } + } + yield break; + } + + private static IEnumerable NewCounter(int start, int end, int step) + { + for (int i = start; i <= end; i += step) + { + yield return (float)i; + } + yield break; + } + + public static IEnumerator NewEase(XInterpolate.Function ease, Vector3 start, Vector3 end, float duration) + { + IEnumerable driver = XInterpolate.NewTimer(duration); + return XInterpolate.NewEase(ease, start, end, duration, driver); + } + + public static IEnumerator NewEase(XInterpolate.Function ease, Vector3 start, Vector3 end, int slices) + { + IEnumerable driver = XInterpolate.NewCounter(0, slices + 1, 1); + return XInterpolate.NewEase(ease, start, end, (float)(slices + 1), driver); + } + + private static IEnumerator NewEase(XInterpolate.Function ease, Vector3 start, Vector3 end, float total, IEnumerable driver) + { + Vector3 distance = end - start; + foreach (float i in driver) + { + yield return XInterpolate.Ease(ease, start, distance, i, total); + } + IEnumerator enumerator = null; + yield break; + yield break; + } + + private static Vector3 Ease(XInterpolate.Function ease, Vector3 start, Vector3 distance, float elapsedTime, float duration) + { + start.x = ease(start.x, distance.x, elapsedTime, duration); + start.y = ease(start.y, distance.y, elapsedTime, duration); + start.z = ease(start.z, distance.z, elapsedTime, duration); + return start; + } + + public static XInterpolate.Function Ease(XInterpolate.EaseType type) + { + XInterpolate.Function result = null; + switch (type) + { + case XInterpolate.EaseType.Linear: + result = new XInterpolate.Function(XInterpolate.Linear); + break; + case XInterpolate.EaseType.EaseInQuad: + result = new XInterpolate.Function(XInterpolate.EaseInQuad); + break; + case XInterpolate.EaseType.EaseOutQuad: + result = new XInterpolate.Function(XInterpolate.EaseOutQuad); + break; + case XInterpolate.EaseType.EaseInOutQuad: + result = new XInterpolate.Function(XInterpolate.EaseInOutQuad); + break; + case XInterpolate.EaseType.EaseInCubic: + result = new XInterpolate.Function(XInterpolate.EaseInCubic); + break; + case XInterpolate.EaseType.EaseOutCubic: + result = new XInterpolate.Function(XInterpolate.EaseOutCubic); + break; + case XInterpolate.EaseType.EaseInOutCubic: + result = new XInterpolate.Function(XInterpolate.EaseInOutCubic); + break; + case XInterpolate.EaseType.EaseInQuart: + result = new XInterpolate.Function(XInterpolate.EaseInQuart); + break; + case XInterpolate.EaseType.EaseOutQuart: + result = new XInterpolate.Function(XInterpolate.EaseOutQuart); + break; + case XInterpolate.EaseType.EaseInOutQuart: + result = new XInterpolate.Function(XInterpolate.EaseInOutQuart); + break; + case XInterpolate.EaseType.EaseInQuint: + result = new XInterpolate.Function(XInterpolate.EaseInQuint); + break; + case XInterpolate.EaseType.EaseOutQuint: + result = new XInterpolate.Function(XInterpolate.EaseOutQuint); + break; + case XInterpolate.EaseType.EaseInOutQuint: + result = new XInterpolate.Function(XInterpolate.EaseInOutQuint); + break; + case XInterpolate.EaseType.EaseInSine: + result = new XInterpolate.Function(XInterpolate.EaseInSine); + break; + case XInterpolate.EaseType.EaseOutSine: + result = new XInterpolate.Function(XInterpolate.EaseOutSine); + break; + case XInterpolate.EaseType.EaseInOutSine: + result = new XInterpolate.Function(XInterpolate.EaseInOutSine); + break; + case XInterpolate.EaseType.EaseInExpo: + result = new XInterpolate.Function(XInterpolate.EaseInExpo); + break; + case XInterpolate.EaseType.EaseOutExpo: + result = new XInterpolate.Function(XInterpolate.EaseOutExpo); + break; + case XInterpolate.EaseType.EaseInOutExpo: + result = new XInterpolate.Function(XInterpolate.EaseInOutExpo); + break; + case XInterpolate.EaseType.EaseInCirc: + result = new XInterpolate.Function(XInterpolate.EaseInCirc); + break; + case XInterpolate.EaseType.EaseOutCirc: + result = new XInterpolate.Function(XInterpolate.EaseOutCirc); + break; + case XInterpolate.EaseType.EaseInOutCirc: + result = new XInterpolate.Function(XInterpolate.EaseInOutCirc); + break; + } + return result; + } + + public static IEnumerable NewBezier(XInterpolate.Function ease, Transform[] nodes, float duration) + { + IEnumerable steps = XInterpolate.NewTimer(duration); + return XInterpolate.NewBezier(ease, nodes, new XInterpolate.ToVector3(XInterpolate.TransformDotPosition), duration, steps); + } + + public static IEnumerable NewBezier(XInterpolate.Function ease, Transform[] nodes, int slices) + { + IEnumerable steps = XInterpolate.NewCounter(0, slices + 1, 1); + return XInterpolate.NewBezier(ease, nodes, new XInterpolate.ToVector3(XInterpolate.TransformDotPosition), (float)(slices + 1), steps); + } + + public static IEnumerable NewBezier(XInterpolate.Function ease, Vector3[] points, float duration) + { + IEnumerable steps = XInterpolate.NewTimer(duration); + return XInterpolate.NewBezier(ease, points, new XInterpolate.ToVector3(XInterpolate.Identity), duration, steps); + } + + public static IEnumerable NewBezier(XInterpolate.Function ease, Vector3[] points, int slices) + { + IEnumerable steps = XInterpolate.NewCounter(0, slices + 1, 1); + return XInterpolate.NewBezier(ease, points, new XInterpolate.ToVector3(XInterpolate.Identity), (float)(slices + 1), steps); + } + + private static IEnumerable NewBezier(XInterpolate.Function ease, IList nodes, XInterpolate.ToVector3 toVector3, float maxStep, IEnumerable steps) + { + bool flag = nodes.Count >= 2; + if (flag) + { + Vector3[] points = new Vector3[nodes.Count]; + foreach (float step in steps) + { + int num; + for (int i = 0; i < nodes.Count; i = num + 1) + { + points[i] = toVector3((T)((object)nodes[i])); + num = i; + } + yield return XInterpolate.Bezier(ease, points, step, maxStep); + } + IEnumerator enumerator = null; + points = null; + } + yield break; + yield break; + } + + private static Vector3 Bezier(XInterpolate.Function ease, Vector3[] points, float elapsedTime, float duration) + { + for (int i = points.Length - 1; i > 0; i--) + { + for (int j = 0; j < i; j++) + { + points[j].x = ease(points[j].x, points[j + 1].x - points[j].x, elapsedTime, duration); + points[j].y = ease(points[j].y, points[j + 1].y - points[j].y, elapsedTime, duration); + points[j].z = ease(points[j].z, points[j + 1].z - points[j].z, elapsedTime, duration); + } + } + return points[0]; + } + + public static IEnumerable NewCatmullRom(Transform[] nodes, int slices, bool loop) + { + return XInterpolate.NewCatmullRom(nodes, new XInterpolate.ToVector3(XInterpolate.TransformDotPosition), slices, loop); + } + + public static IEnumerable NewCatmullRom(Vector3[] points, int slices, bool loop) + { + return XInterpolate.NewCatmullRom(points, new XInterpolate.ToVector3(XInterpolate.Identity), slices, loop); + } + + private static IEnumerable NewCatmullRom(IList nodes, XInterpolate.ToVector3 toVector3, int slices, bool loop) + { + bool flag = nodes.Count >= 2; + if (flag) + { + yield return toVector3((T)((object)nodes[0])); + int last = nodes.Count - 1; + int current = 0; + while (loop || current < last) + { + bool flag2 = loop && current > last; + if (flag2) + { + current = 0; + } + int previous = (current == 0) ? (loop ? last : current) : (current - 1); + int start = current; + int end = (current == last) ? (loop ? 0 : current) : (current + 1); + int next = (end == last) ? (loop ? 0 : end) : (end + 1); + int stepCount = slices + 1; + int num; + for (int step = 1; step <= stepCount; step = num + 1) + { + yield return XInterpolate.CatmullRom(toVector3((T)((object)nodes[previous])), toVector3((T)((object)nodes[start])), toVector3((T)((object)nodes[end])), toVector3((T)((object)nodes[next])), (float)step, (float)stepCount); + num = step; + } + num = current; + current = num + 1; + } + } + yield break; + } + + private static Vector3 CatmullRom(Vector3 previous, Vector3 start, Vector3 end, Vector3 next, float elapsedTime, float duration) + { + float num = elapsedTime / duration; + float num2 = num * num; + float num3 = num2 * num; + return previous * (-0.5f * num3 + num2 - 0.5f * num) + start * (1.5f * num3 + -2.5f * num2 + 1f) + end * (-1.5f * num3 + 2f * num2 + 0.5f * num) + next * (0.5f * num3 - 0.5f * num2); + } + + private static float Linear(float start, float distance, float elapsedTime, float duration) + { + bool flag = elapsedTime > duration; + if (flag) + { + elapsedTime = duration; + } + return distance * (elapsedTime / duration) + start; + } + + private static float EaseInQuad(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration)); + return distance * elapsedTime * elapsedTime + start; + } + + private static float EaseOutQuad(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration)); + return -distance * elapsedTime * (elapsedTime - 2f) + start; + } + + private static float EaseInOutQuad(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f))); + bool flag = elapsedTime < 1f; + float result; + if (flag) + { + result = distance / 2f * elapsedTime * elapsedTime + start; + } + else + { + elapsedTime -= 1f; + result = -distance / 2f * (elapsedTime * (elapsedTime - 2f) - 1f) + start; + } + return result; + } + + private static float EaseInCubic(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration)); + return distance * elapsedTime * elapsedTime * elapsedTime + start; + } + + private static float EaseOutCubic(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration)); + elapsedTime -= 1f; + return distance * (elapsedTime * elapsedTime * elapsedTime + 1f) + start; + } + + private static float EaseInOutCubic(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f))); + bool flag = elapsedTime < 1f; + float result; + if (flag) + { + result = distance / 2f * elapsedTime * elapsedTime * elapsedTime + start; + } + else + { + elapsedTime -= 2f; + result = distance / 2f * (elapsedTime * elapsedTime * elapsedTime + 2f) + start; + } + return result; + } + + private static float EaseInQuart(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration)); + return distance * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start; + } + + private static float EaseOutQuart(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration)); + elapsedTime -= 1f; + return -distance * (elapsedTime * elapsedTime * elapsedTime * elapsedTime - 1f) + start; + } + + private static float EaseInOutQuart(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f))); + bool flag = elapsedTime < 1f; + float result; + if (flag) + { + result = distance / 2f * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start; + } + else + { + elapsedTime -= 2f; + result = -distance / 2f * (elapsedTime * elapsedTime * elapsedTime * elapsedTime - 2f) + start; + } + return result; + } + + private static float EaseInQuint(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration)); + return distance * elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start; + } + + private static float EaseOutQuint(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration)); + elapsedTime -= 1f; + return distance * (elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + 1f) + start; + } + + private static float EaseInOutQuint(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f))); + bool flag = elapsedTime < 1f; + float result; + if (flag) + { + result = distance / 2f * elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + start; + } + else + { + elapsedTime -= 2f; + result = distance / 2f * (elapsedTime * elapsedTime * elapsedTime * elapsedTime * elapsedTime + 2f) + start; + } + return result; + } + + private static float EaseInSine(float start, float distance, float elapsedTime, float duration) + { + bool flag = elapsedTime > duration; + if (flag) + { + elapsedTime = duration; + } + return -distance * Mathf.Cos(elapsedTime / duration * 1.57079637f) + distance + start; + } + + private static float EaseOutSine(float start, float distance, float elapsedTime, float duration) + { + bool flag = elapsedTime > duration; + if (flag) + { + elapsedTime = duration; + } + return distance * Mathf.Sin(elapsedTime / duration * 1.57079637f) + start; + } + + private static float EaseInOutSine(float start, float distance, float elapsedTime, float duration) + { + bool flag = elapsedTime > duration; + if (flag) + { + elapsedTime = duration; + } + return -distance / 2f * (Mathf.Cos(3.14159274f * elapsedTime / duration) - 1f) + start; + } + + private static float EaseInExpo(float start, float distance, float elapsedTime, float duration) + { + bool flag = elapsedTime > duration; + if (flag) + { + elapsedTime = duration; + } + return distance * Mathf.Pow(2f, 10f * (elapsedTime / duration - 1f)) + start; + } + + private static float EaseOutExpo(float start, float distance, float elapsedTime, float duration) + { + bool flag = elapsedTime > duration; + if (flag) + { + elapsedTime = duration; + } + return distance * (-Mathf.Pow(2f, -10f * elapsedTime / duration) + 1f) + start; + } + + private static float EaseInOutExpo(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f))); + bool flag = elapsedTime < 1f; + float result; + if (flag) + { + result = distance / 2f * Mathf.Pow(2f, 10f * (elapsedTime - 1f)) + start; + } + else + { + elapsedTime -= 1f; + result = distance / 2f * (-Mathf.Pow(2f, -10f * elapsedTime) + 2f) + start; + } + return result; + } + + private static float EaseInCirc(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration)); + return -distance * (Mathf.Sqrt(1f - elapsedTime * elapsedTime) - 1f) + start; + } + + private static float EaseOutCirc(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 1f : (elapsedTime / duration)); + elapsedTime -= 1f; + return distance * Mathf.Sqrt(1f - elapsedTime * elapsedTime) + start; + } + + private static float EaseInOutCirc(float start, float distance, float elapsedTime, float duration) + { + elapsedTime = ((elapsedTime > duration) ? 2f : (elapsedTime / (duration / 2f))); + bool flag = elapsedTime < 1f; + float result; + if (flag) + { + result = -distance / 2f * (Mathf.Sqrt(1f - elapsedTime * elapsedTime) - 1f) + start; + } + else + { + elapsedTime -= 2f; + result = distance / 2f * (Mathf.Sqrt(1f - elapsedTime * elapsedTime) + 1f) + start; + } + return result; + } + } +} -- cgit v1.1-26-g67d0