public void SetCurve(Vector3 end, float time)
{
if (m_object != null)
{
TweenCurve cur = TweenCurve.Get(m_object);
cur.duration = time * 0.001f;
cur.from = GetPos();
cur.front = new Vector3(0, 4, 0);
cur.back = new Vector3(0, 4, 0);
cur.to = end;
cur.method = UITweener.Method.EaseIn;
cur.Reset();
cur.Play(true);
//TweenFloat rota = TweenFloat.Get(m_object);
//rota.from = 0;
//rota.to = 2000;
//rota.duration = time * 0.001f;
//rota.Reset();
//rota.Play(true);
//rota.FloatUpdateEvent = (val) => {
// SetDirection(val * Vector3.one);
//};
}
}
/// <summary>
/// 设置抛物线（贝塞尔曲线）
/// </summary>
public void SetCurve(Vector3 end, float time, float hight)
{
if (m_object != null)
{
TweenCurve cur = TweenCurve.Get(m_object);
cur.duration = time * 0.001f;
cur.from = GetPos();
cur.front = new Vector3(0, hight, 0);
cur.back = new Vector3(0, hight, 0);
cur.to = end;
cur.method = UITweener.Method.Linear;
cur.Reset();
cur.Play(true);
TweenFloat rota = TweenFloat.Get(m_object);
rota.duration = time * 0.001f;
rota.from = 0;
rota.to = -360;
rota.method = UITweener.Method.EaseOut;
rota.Reset();
rota.Play(true);
rota.FloatUpdateEvent = (val) => {
SetDirection(val * Vector3.one);
};
}
}
private void TweenToInTime(Pose target, float time)
{
Pose start = _pose;
if (_tweenCurves.Count > 0)
{
TweenCurve previousCurve = _tweenCurves[_tweenCurves.Count - 1];
float progressIn = previousCurve.Curve.ProgressIn(Mathf.Min(_maxOverlapTime, time));
if (progressIn != 1.0f)
{
float deltaEase = progressIn - previousCurve.PrevProgress;
float remainEase = 1.0f - previousCurve.PrevProgress;
float percentTravel = deltaEase / remainEase;
start = previousCurve.Current;
start.Lerp(in previousCurve.Target, percentTravel);
}
}
TweenCurve tweenCurve = new TweenCurve()
{
Curve = new ProgressCurve(_animationCurve, time),
PrevProgress = 0f,
Current = start,
Target = target
};
_tweenCurves.Add(tweenCurve);
tweenCurve.Curve.Start();
}
static public TweenCurve Get(GameObject go)
{
TweenCurve pos = go.GetComponent <TweenCurve>();
if (pos == null)
{
pos = go.AddComponent <TweenCurve>();
}
return(pos);
}
public void Tick()
{
for (int i = _tweenCurves.Count - 1; i >= 0; i--)
{
TweenCurve tweenCurve = _tweenCurves[i];
float progress = tweenCurve.Curve.Progress();
if (progress == 1.0f)
{
tweenCurve.Current = tweenCurve.Target;
tweenCurve.PrevProgress = 1.0f;
continue;
}
float deltaEase = progress - tweenCurve.PrevProgress;
float remainEase = 1.0f - tweenCurve.PrevProgress;
float percentTravel = deltaEase / remainEase;
tweenCurve.Current.Lerp(in tweenCurve.Target, percentTravel);
tweenCurve.PrevProgress = progress;
}
float multiplier = 1.0f;
float overlap = 0.0f;
Pose pose = _tweenCurves[_tweenCurves.Count - 1].Current;
for (int i = _tweenCurves.Count - 2; i >= 0; i--)
{
TweenCurve nextCurve = _tweenCurves[i + 1];
float timeProgress = nextCurve.Curve.ProgressTime();
if (nextCurve.Curve.AnimationLength == 0f)
{
overlap = 1.0f;
}
else
{
overlap = Mathf.Min(_maxOverlapTime, timeProgress) /
Mathf.Min(_maxOverlapTime, nextCurve.Curve.AnimationLength);
}
if (overlap == 1.0f)
{
_tweenCurves.RemoveRange(0, i);
break;
}
multiplier = (1 - overlap) * multiplier;
Pose easeCurve = _tweenCurves[i].Current;
pose.Lerp(in easeCurve, multiplier);
}
_pose = pose;
}
static public TweenCurve Begin(GameObject go, float duration, Vector3 to, Vector3 front, Vector3 back)
{
TweenCurve comp = UITweener.Begin <TweenCurve>(go, duration);
comp.from = comp.position;
comp.to = to;
comp.front = front;
comp.back = back;
if (duration <= 0f)
{
comp.Sample(1f, true);
comp.enabled = false;
}
return(comp);
}
// Core methods ---------------------------------------------------------------------------------------------------------------
// Moves a value between a startValue and an endValue based on a currentTime, along the specified tween curve
public static float TweenConstructor(float currentTime, float initialTime, float endTime, float startValue, float endValue, TweenCurve curve)
{
currentTime = MathsHelper.Remap(currentTime, initialTime, endTime, 0f, 1f);
switch (curve)
{
case TweenCurve.LinearTween: currentTime = TweenDefinitions.Linear_Tween(currentTime); break;
case TweenCurve.AntiLinearTween: currentTime = TweenDefinitions.LinearAnti_Tween(currentTime); break;
case TweenCurve.EaseInQuadratic: currentTime = TweenDefinitions.EaseIn_Quadratic(currentTime); break;
case TweenCurve.EaseOutQuadratic: currentTime = TweenDefinitions.EaseOut_Quadratic(currentTime); break;
case TweenCurve.EaseInOutQuadratic: currentTime = TweenDefinitions.EaseInOut_Quadratic(currentTime); break;
case TweenCurve.EaseInCubic: currentTime = TweenDefinitions.EaseIn_Cubic(currentTime); break;
case TweenCurve.EaseOutCubic: currentTime = TweenDefinitions.EaseOut_Cubic(currentTime); break;
case TweenCurve.EaseInOutCubic: currentTime = TweenDefinitions.EaseInOut_Cubic(currentTime); break;
case TweenCurve.EaseInQuartic: currentTime = TweenDefinitions.EaseIn_Quartic(currentTime); break;
case TweenCurve.EaseOutQuartic: currentTime = TweenDefinitions.EaseOut_Quartic(currentTime); break;
case TweenCurve.EaseInOutQuartic: currentTime = TweenDefinitions.EaseInOut_Quartic(currentTime); break;
case TweenCurve.EaseInQuintic: currentTime = TweenDefinitions.EaseIn_Quintic(currentTime); break;
case TweenCurve.EaseOutQuintic: currentTime = TweenDefinitions.EaseOut_Quintic(currentTime); break;
case TweenCurve.EaseInOutQuintic: currentTime = TweenDefinitions.EaseInOut_Quintic(currentTime); break;
case TweenCurve.EaseInSinusoidal: currentTime = TweenDefinitions.EaseIn_Sinusoidal(currentTime); break;
case TweenCurve.EaseOutSinusoidal: currentTime = TweenDefinitions.EaseOut_Sinusoidal(currentTime); break;
case TweenCurve.EaseInOutSinusoidal: currentTime = TweenDefinitions.EaseInOut_Sinusoidal(currentTime); break;
case TweenCurve.EaseInBounce: currentTime = TweenDefinitions.EaseIn_Bounce(currentTime); break;
case TweenCurve.EaseOutBounce: currentTime = TweenDefinitions.EaseOut_Bounce(currentTime); break;
case TweenCurve.EaseInOutBounce: currentTime = TweenDefinitions.EaseInOut_Bounce(currentTime); break;
case TweenCurve.EaseInOverhead: currentTime = TweenDefinitions.EaseIn_Overhead(currentTime); break;
case TweenCurve.EaseOutOverhead: currentTime = TweenDefinitions.EaseOut_Overhead(currentTime); break;
case TweenCurve.EaseInOutOverhead: currentTime = TweenDefinitions.EaseInOut_Overhead(currentTime); break;
case TweenCurve.EaseInExponential: currentTime = TweenDefinitions.EaseIn_Exponential(currentTime); break;
case TweenCurve.EaseOutExponential: currentTime = TweenDefinitions.EaseOut_Exponential(currentTime); break;
case TweenCurve.EaseInOutExponential: currentTime = TweenDefinitions.EaseInOut_Exponential(currentTime); break;
case TweenCurve.EaseInElastic: currentTime = TweenDefinitions.EaseIn_Elastic(currentTime); break;
case TweenCurve.EaseOutElastic: currentTime = TweenDefinitions.EaseOut_Elastic(currentTime); break;
case TweenCurve.EaseInOutElastic: currentTime = TweenDefinitions.EaseInOut_Elastic(currentTime); break;
case TweenCurve.EaseInCircular: currentTime = TweenDefinitions.EaseIn_Circular(currentTime); break;
case TweenCurve.EaseOutCircular: currentTime = TweenDefinitions.EaseOut_Circular(currentTime); break;
case TweenCurve.EaseInOutCircular: currentTime = TweenDefinitions.EaseInOut_Circular(currentTime); break;
}
return(startValue + currentTime * (endValue - startValue));
}
protected static IEnumerator RotateTransformAroundCo(Transform targetTransform, Transform center, Transform destination, float angle, WaitForSeconds delay, float delayDuration, float duration, TweenCurve curve)
{
if (delayDuration > 0f)
{
yield return(delay);
}
Vector3 initialRotationPosition = targetTransform.transform.position;
Quaternion initialRotationRotation = targetTransform.transform.rotation;
float rate = 1f / duration;
float timeSpent = 0f;
while (timeSpent < duration)
{
float newAngle = TweenConstructor(timeSpent, 0f, duration, 0f, angle, curve);
targetTransform.transform.position = initialRotationPosition;
initialRotationRotation = targetTransform.transform.rotation;
targetTransform.RotateAround(center.transform.position, center.transform.up, newAngle);
targetTransform.transform.rotation = initialRotationRotation;
timeSpent += Time.deltaTime;
yield return(null);
}
targetTransform.transform.position = destination.position;
}
protected static IEnumerator MoveTransformCo(Transform targetTransform, Transform origin, Transform destination, WaitForSeconds delay, float delayDuration, float duration, TweenCurve curve, bool updatePosition = true, bool updateRotation = true)
{
if (delayDuration > 0f)
{
yield return(delay);
}
float timeLeft = duration;
while (timeLeft > 0f)
{
if (updatePosition)
{
targetTransform.transform.position = TweenConstructor(duration - timeLeft, 0f, duration, origin.position, destination.position, curve);
}
if (updateRotation)
{
targetTransform.transform.rotation = TweenConstructor(duration - timeLeft, 0f, duration, origin.rotation, destination.rotation, curve);
}
timeLeft -= Time.deltaTime;
yield return(null);
}
if (updatePosition)
{
targetTransform.transform.position = destination.position;
}
if (updateRotation)
{
targetTransform.transform.localEulerAngles = destination.localEulerAngles;
}
}
public static Coroutine RotateTransformAround(MonoBehaviour mono, Transform targetTransform, Transform center, Transform destination, float angle, WaitForSeconds delay, float delayDuration, float duration, TweenCurve curve)
{
return(mono.StartCoroutine(RotateTransformAroundCo(targetTransform, center, destination, angle, delay, delayDuration, duration, curve)));
}
// MOVE METHODS ---------------------------------------------------------------------------------------------------------
public static Coroutine MoveTransform(MonoBehaviour mono, Transform targetTransform, Transform origin, Transform destination, WaitForSeconds delay, float delayDuration, float duration, TweenCurve curve, bool updatePosition = true, bool updateRotation = true)
{
return(mono.StartCoroutine(MoveTransformCo(targetTransform, origin, destination, delay, delayDuration, duration, curve, updatePosition, updateRotation)));
}
public static Quaternion TweenConstructor(float currentTime, float initialTime, float endTime, Quaternion startValue, Quaternion endValue, TweenCurve curve)
{
float turningRate = TweenConstructor(currentTime, initialTime, endTime, 0f, 1f, curve);
startValue = Quaternion.Slerp(startValue, endValue, turningRate);
return(startValue);
}
public static Vector3 TweenConstructor(float currentTime, float initialTime, float endTime, Vector3 startValue, Vector3 endValue, TweenCurve curve)
{
startValue.x = TweenConstructor(currentTime, initialTime, endTime, startValue.x, endValue.x, curve);
startValue.y = TweenConstructor(currentTime, initialTime, endTime, startValue.y, endValue.y, curve);
startValue.z = TweenConstructor(currentTime, initialTime, endTime, startValue.z, endValue.z, curve);
return(startValue);
}
public static Vector2 Tween(float currentTime, float initialTime, float endTime, Vector2 startValue, Vector2 endValue, TweenCurve curve)
{
startValue.x = Tween(currentTime, initialTime, endTime, startValue.x, endValue.x, curve);
startValue.y = Tween(currentTime, initialTime, endTime, startValue.y, endValue.y, curve);
return(startValue);
}
