public virtual void Fire(GameObject objStart, Vector3 endPosition, float duration, string easeName = null) { this.BindGameLoop(); _transStart = objStart.transform; _startUnit = null; _startUnitId = 0; _startPosition = _transStart.position; _startAngle = -1.0f; _transEnd = null; _endUnit = null; _endUnitId = 0; _endPosition = endPosition; _endTeleportFlag = -1; _duration = duration <= 0 ? _duration : duration; _startTime = GetMSTime(); _easeName = string.IsNullOrEmpty(easeName) ? _easeName : easeName; _easeFunc = EaseFunc.GetFunction(easeName); _transform = this.transform; _transform.position = _startPosition; _isEnded = false; _delayTimeCounter = _delayTime; this.OnEffectStart(); }
public virtual void Fire(UBattleUnit startUnit, Vector3 endPosition, float duration, string easeName = null) { this.BindGameLoop(); _transStart = startUnit.GetBoneTransform("missile"); _startUnit = startUnit; _startUnitId = startUnit.unitId; _startPosition = _transStart.position; _startAngle = _startUnit.curDirectionAngle; _transEnd = null; _endUnit = null; _endUnitId = 0; _endPosition = endPosition; _endTeleportFlag = -1; _duration = duration <= 0 ? _duration : duration; _startTime = GetMSTime(); _easeName = string.IsNullOrEmpty(easeName) ? _easeName : easeName; _easeFunc = EaseFunc.GetFunction(easeName); _transform = this.transform; _transform.position = _startPosition; _isEnded = false; _delayTimeCounter = _delayTime; this.OnEffectStart(); }
/// <summary> /// Calculate the new value using the Ease and Lerp functions /// </summary> /// <param name="start">Value to start at</param> /// <param name="end">Target Value</param> /// <param name="percent">Progress along ease function where 0-1 is 0%-100%</param> /// <param name="easeFunc">Function to use when Easing</param> /// <param name="lerpFunc">Function to use when Interpolating</param> /// <returns>Eased value</returns> private static T Calculate(T start, T end, float percent, EaseFunc easeFunc, LerpFunc <T> lerpFunc) { // Scale the percent based on the ease float scaledPercent = easeFunc(percent); // Pass in scaled percent to interpolation return(lerpFunc(start, end, scaledPercent)); }
public static System.Collections.Generic.IEnumerable <float> Go(EaseFunc f, float duration) { var startTime = Time.timeSinceLevelLoad; for (var t = 0f; t < duration; t = (Time.timeSinceLevelLoad - startTime)) { yield return(f(t, 0f, 1f, duration)); } yield return(1f); }
public ChainItem(T destination, float duration, EaseFunc scaleFunc, TweenAccessors <T> accessors, LerpFunc <T> lerp) { this.destination = destination; this.duration = duration; this.scaleFunc = scaleFunc; this.accessors = accessors; this.lerpFunc = lerp; this.tween = new Tween <T>(this.lerpFunc); }
/// <summary> /// Transform an ease function by reversing it and appending it to itself to create an InOut from an Out /// </summary> /// <param name="percent">Progress along ease function where 0-1 is 0%-100%</param> /// <param name="Out">Out Ease function to create InOut from (must be OUT)</param> /// <returns>An InOut ease function</returns> public static float InOut(float percent, EaseFunc Out) { // If less than halfway if (percent < 0.5) { // Reverse the Out to create an In, and scale it down by half return(Reverse(percent * 2, Out) / 2); } // Shift over the out to the halfway point and scale it down by half return((Out(percent * 2 - 1) / 2) + 0.5f); }
/// <summary> /// Create a new Tweener /// </summary> /// <param name="start">Value to start at</param> /// <param name="end">Target value</param> /// <param name="duration">Time (in seconds) to get to the target</param> /// <param name="easeFunc">Ease function to use (defaults to linear if unspecified)</param> /// <param name="lerpFunc">Lerp function to use (defaults to generic if unspecified)</param> public Tweener(T start, T end, double duration, EaseFunc easeFunc = null, LerpFunc <T> lerpFunc = null) { _elapsed = 0.0f; _start = start; _end = end; _duration = duration; // If there's no ease function specified, use Linear _easeFunc = easeFunc ?? Ease.Linear; // If there's no lerp function specified, use Generic Default _lerpFunc = lerpFunc ?? LerpFuncDefault; Value = _start; Running = true; }
/// <summary> /// Initializes a new instance of the <see cref="GenericEaseImpl"/> class. /// </summary> /// <param name="easeInFunc">The ease in function.</param> /// <param name="easeOutFunc">The ease out function.</param> /// <param name="easeInOutFunc">The ease in out function.</param> /// <exception cref="Exception">Both in and out arguments none, this should not happen! This is bad.</exception> private GenericEaseImpl(EaseFunc easeInFunc, EaseFunc easeOutFunc, EaseFunc easeInOutFunc) { if (easeInFunc == null && easeOutFunc == null) { throw new Exception("Both in and out arguments none, this should not happen! This is bad."); } // If there's no In function, create one generically (from Out) _easeInFunc = easeInFunc ?? GenericIn; // If there's no Out function, create one generically (from In) _easeOutFunc = easeOutFunc ?? GenericOut; // If there's no InOut function, create one generically (from Out) _easeInOutFunc = easeInOutFunc ?? GenericInOut; }
private void OnParabolaStart() { if (_maxParabolaHeight == 0) { _parabolaAutoRotate = false; _parabolaOffset = Vector3.zero; return; } _parabolaEaseFunc = _parabolaEase.hasFunc ? _parabolaEase.func : EaseFunc.GetFunction("EaseOutCubic"); var endPosition = GetEndPosition(); var parabolaHeight = _maxParabolaHeight; var distance = UGameTools.GetPosDistance(_startPosition, endPosition); if (endPosition.y > _startPosition.y) { var normalLineLength = Mathf.Abs((endPosition.x - _startPosition.x) * distance * 0.5f / (endPosition.y - _startPosition.y)); if (normalLineLength <= _maxParabolaHeight) { parabolaHeight = normalLineLength * 0.5f; } } var heightLimit = distance * _parabolaLimitFactor; parabolaHeight = parabolaHeight > heightLimit ? heightLimit : parabolaHeight; if (endPosition.x - _startPosition.x > 0) { _parabolaOffset.x = (endPosition.y - _startPosition.y) * parabolaHeight * -1 / distance; _parabolaOffset.y = (endPosition.x - _startPosition.x) * parabolaHeight / distance; } else { _parabolaOffset.x = (endPosition.y - _startPosition.y) * parabolaHeight / distance; _parabolaOffset.y = (endPosition.x - _startPosition.x) * parabolaHeight * -1 / distance; } if (_parabolaAutoRotate) { var nextPosition = GetPosition(0.03f, EaseValue(0.03f), _startPosition, endPosition); _transform.localEulerAngles = new Vector3(0, 0, UGameTools.GetPosAngle(_startPosition, nextPosition)); } }
/// <summary> /// Starts a tween. /// </summary> /// <param name="start">The start value.</param> /// <param name="end">The end value.</param> /// <param name="duration">The duration of the tween.</param> /// <param name="easeFunc">A function used to scale progress over time.</param> public void Start(T start, T end, float duration, EaseFunc easeFunc) { if (duration <= 0) { throw new ArgumentException("duration must be greater than 0"); } if (easeFunc == null) { throw new ArgumentNullException("easeFunc"); } CurrentTime = 0; Duration = duration; this.easeFunc = easeFunc; State = TweenState.Running; StartValue = start; EndValue = end; UpdateValue(); }
public TweenChainComponent AddLocalMoveTween(Vector2 targetPos, float duration, EaseFunc easeFunc) { return(AddTween(targetPos, duration, easeFunc, this.actor.LocalPositionTweenAccessors(), Vector2.Lerp)); }
public TweenChainComponent AddTween <T>(T target, float duration, EaseFunc easeFunc, TweenAccessors <T> accessors, LerpFunc <T> lerp) where T : struct { this.chain.Append(new TweenChain.ChainItem <T>(target, duration, easeFunc, accessors, lerp)); return(this); }
public static IEase Create(EaseFunc easeInFunc, EaseFunc easeOutFunc, EaseFunc easeInOutFunc = null) { return(GenericEaseImpl.From(easeInFunc, easeOutFunc, easeInOutFunc)); }
/// <summary> /// Easing function range map using Fastest smooth function /// </summary> /// <param name="x">val</param> /// <param name="inStart">In range start</param> /// <param name="inEnd">In range end</param> /// <param name="outStart">Out range start</param> /// <param name="outEnd">out range end</param> /// <param name="easingFunc"></param> /// <returns></returns> public static float RangeMap(float val, float inStart, float inEnd, float outStart, float outEnd, EaseFunc <float, float> easingFunc) { float res = val - inStart; res /= (inEnd - inStart); res = easingFunc(res); res *= (outEnd - outStart); return(res - outStart); }
public static float Mix(EaseFunc <float, float> func1, EaseFuncN <float, int, float> funcN, int n, float blend, float x) { return(((1f - blend) * func1(x)) + (blend * funcN(x, n))); }
public TweenChain AppendPointTween(Point targetVal, float duration, EaseFunc easeFunc, TweenAccessors <Point> accessors) { return(Append(new ChainItem <Point>(targetVal, duration, easeFunc, accessors, TweenChain.PointLerp))); }
public void AddVectorTween(Vector2 targetVal, float duration, EaseFunc easeFunc, TweenAccessors <Vector2> accessors) { this.chain.AppendVectorTween(targetVal, duration, easeFunc, accessors); }
public TweenChain AppendVectorTween(Vector2 targetVal, float duration, EaseFunc easeFunc, TweenAccessors <Vector2> accessors) { return(Append(new ChainItem <Vector2>(targetVal, duration, easeFunc, accessors, Vector2.Lerp))); }
public static System.Collections.Generic.IEnumerable<float> Go(EaseFunc f, float duration) { var startTime = Time.timeSinceLevelLoad; for (var t = 0f; t < duration; t = (Time.timeSinceLevelLoad - startTime)) yield return f(t, 0f, 1f, duration); yield return 1f; }
public static float CrossFade(EaseFunc <float, float> func1, EaseFuncN <float, int, float> funcN, int n, float x) { return(((1 - x) * func1(x)) + (x * funcN(x, n))); }
/// <summary> /// To use with SmoothStart2 (exemple) & SmoothStop2 (exemple) /// </summary> public static float CrossFade(EaseFunc <float, float> func1, EaseFunc <float, float> func2, float x) { return(((1 - x) * func1(x)) + (x * func2(x))); }
public TweenChainComponent AddFloatTween(float targetVal, float duration, EaseFunc easeFunc, TweenAccessors <float> accessors) { this.chain.AppendFloatTween(targetVal, duration, easeFunc, accessors); return(this); }
/// <summary> /// Create a new Generic Implementation set from an Out ease, and an optional InOut ease. /// </summary> /// <param name="easeOutFunc">Out ease function</param> /// <param name="easeInOutFunc">Optional InOut ease function</param> /// <returns>A new Generic Ease Set</returns> public static GenericEaseImpl FromOut(EaseFunc easeOutFunc, EaseFunc easeInOutFunc = null) { return(new GenericEaseImpl(null, easeOutFunc, easeInOutFunc)); }
public void AddIntTween(int targetVal, int duration, EaseFunc easeFunc, TweenAccessors <int> accessors) { this.chain.AppendIntTween(targetVal, duration, easeFunc, accessors); }
/// <summary> /// Create a new Tweener /// </summary> /// <param name="start">Value to start at</param> /// <param name="end">Target value</param> /// <param name="duration">Time (in seconds) to get to the target</param> /// <param name="easeFunc">Ease function to use (defaults to linear if unspecified)</param> /// <param name="lerpFunc">Lerp function to use (defaults to generic if unspecified)</param> public Tweener(T start, T end, float duration, EaseFunc easeFunc = null, LerpFunc <T> lerpFunc = null) : this(start, end, (double)duration, easeFunc, lerpFunc) { }
/// <summary> /// Create a new Tweener /// </summary> /// <param name="start">Value to start at</param> /// <param name="end">Target value</param> /// <param name="duration">How long to get to the target</param> /// <param name="easeFunc">Ease function to use (defaults to linear if unspecified)</param> /// <param name="lerpFunc">Lerp function to use (defaults to generic if unspecified)</param> public Tweener(T start, T end, TimeSpan duration, EaseFunc easeFunc = null, LerpFunc <T> lerpFunc = null) : this(start, end, duration.TotalSeconds, easeFunc, lerpFunc) { }
public static float FlipScale(EaseFunc <float, float> func, float x, float scale) { return((1 - x) * func(x) * scale); }
/// <summary> /// Create a new Generic Implementation set from an In ease, and an optional InOut ease. /// </summary> /// <param name="easeInFunc">In ease function</param> /// <param name="easeInOutFunc">Optional InOut ease function</param> /// <returns>A new Generic Ease Set</returns> public static GenericEaseImpl FromIn(EaseFunc easeInFunc, EaseFunc easeInOutFunc = null) { return(new GenericEaseImpl(easeInFunc, null, easeInOutFunc)); }
/// <summary> /// SmoothStart^A.B = Mix(SmoothStartA, SmoothStartA+1, B) /// </summary> public static float Mix(EaseFunc <float, float> func1, EaseFunc <float, float> func2, float blend, float x) { return(((1f - blend) * func1(x)) + (blend * func2(x))); }
/// <summary> /// Reverse an ease function to go from Out -> In, or In -> Out /// </summary> /// <param name="percent">Progress along ease function where 0-1 is 0%-100%</param> /// <param name="easeFunc">Ease function to reverse</param> /// <returns>The reverse of the usual output from easeFunc</returns> public static float Reverse(float percent, EaseFunc easeFunc) { return(1 - easeFunc(1 - percent)); }
public static float Scale(EaseFunc <float, float> func, float x, float scale) { return(scale * func(x)); }