Advertisement
Guest User

Untitled

a guest
Oct 10th, 2015
132
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using UnityEngine;
  3.  
  4. public delegate float TweeningFunction(float timeElapsed, float start, float change, float duration);
  5.  
  6. public class Tweener
  7. {
  8.     public Tweener(float from, float to, float duration, TweeningFunction tweeningFunction)
  9.     {
  10.         _from = from;
  11.         _position = from;
  12.         _change = to - from;
  13.         _tweeningFunction = tweeningFunction;
  14.         _duration = duration;
  15.     }
  16.    
  17.     public Tweener(float from, float to, TimeSpan duration, TweeningFunction tweeningFunction)
  18.         : this(from, to, (float)duration.TotalSeconds, tweeningFunction)
  19.     {
  20.     }
  21.    
  22.     #region Properties
  23.     private float _position;
  24.     public float Position
  25.     {
  26.         get
  27.         {
  28.             return _position;
  29.         }
  30.         protected set
  31.         {
  32.             _position = value;
  33.         }
  34.     }
  35.    
  36.     private float _from;
  37.     protected float from
  38.     {
  39.         get
  40.         {
  41.             return _from;
  42.         }
  43.         set
  44.         {
  45.             _from = value;
  46.         }
  47.     }
  48.    
  49.     private float _change;
  50.     protected float change
  51.     {
  52.         get
  53.         {
  54.             return _change;
  55.         }
  56.         set
  57.         {
  58.             _change = value;
  59.         }
  60.     }
  61.    
  62.     private float _duration;
  63.     protected float duration
  64.     {
  65.         get
  66.         {
  67.             return _duration;
  68.         }
  69.     }
  70.    
  71.     private float _elapsed = 0.0f;
  72.     protected float elapsed
  73.     {
  74.         get
  75.         {
  76.             return _elapsed;
  77.         }
  78.         set
  79.         {
  80.             _elapsed = value;
  81.         }
  82.     }
  83.    
  84.     private bool _running = true;
  85.     public bool Running
  86.     {
  87.         get { return _running; }
  88.         protected set { _running = value; }
  89.     }
  90.    
  91.     private TweeningFunction _tweeningFunction;
  92.     protected TweeningFunction tweeningFunction
  93.     {
  94.         get
  95.         {
  96.             return _tweeningFunction;
  97.         }
  98.     }
  99.    
  100.     public delegate void EndHandler();
  101.     public event EndHandler Ended;
  102.     #endregion
  103.    
  104.     #region Methods
  105.     public void Update()
  106.     {
  107.         if (!Running || (elapsed == duration))
  108.         {
  109.             return;
  110.         }
  111.         Position = tweeningFunction(elapsed, from, change, duration);
  112.         elapsed += (float)Time.deltaTime;
  113.         if (elapsed >= duration)
  114.         {
  115.             elapsed = duration;
  116.             Position = from + change;
  117.             OnEnd();
  118.         }
  119.     }
  120.    
  121.     protected void OnEnd()
  122.     {
  123.         if (Ended != null)
  124.         {
  125.             Ended();
  126.         }
  127.     }
  128.    
  129.     public void Start()
  130.     {
  131.         Running = true;
  132.     }
  133.    
  134.     public void Stop()
  135.     {
  136.         Running = false;
  137.     }
  138.    
  139.     public void Reset()
  140.     {
  141.         elapsed = 0.0f;
  142.         from = Position;
  143.     }
  144.    
  145.     public void Reset(float to)
  146.     {
  147.         change = to - Position;
  148.         Reset();
  149.     }
  150.    
  151.     public void Reverse()
  152.     {
  153.         elapsed = 0.0f;
  154.         change = -change + (from + change - Position);
  155.         from = Position;
  156.     }
  157.    
  158.     public override string ToString()
  159.     {
  160.         return String.Format("{0}.{1}. Tween {2} -> {3} in {4}s. Elapsed {5:##0.##}s",
  161.                              tweeningFunction.Method.DeclaringType.Name,
  162.                              tweeningFunction.Method.Name,
  163.                              from,
  164.                              from + change,
  165.                              duration,
  166.                              elapsed);
  167.     }
  168.     #endregion
  169. }
  170.  
  171. public static class Bounce
  172. {
  173.     public static float EaseOut(float t, float b, float c, float d)
  174.     {
  175.         if ((t /= d) < (1 / 2.75))
  176.         {
  177.             return c * (7.5625f * t * t) + b;
  178.         }
  179.         else if (t < (2 / 2.75))
  180.         {
  181.             return c * (7.5625f * (t -= (1.5f / 2.75f)) * t + .75f) + b;
  182.         }
  183.         else if (t < (2.5 / 2.75))
  184.         {
  185.             return c * (7.5625f * (t -= (2.25f / 2.75f)) * t + .9375f) + b;
  186.         }
  187.         else
  188.         {
  189.             return c * (7.5625f * (t -= (2.625f / 2.75f)) * t + .984375f) + b;
  190.         }
  191.     }
  192.    
  193.     public static float EaseIn(float t, float b, float c, float d)
  194.     {
  195.         return c - EaseOut(d - t, 0, c, d) + b;
  196.     }
  197.    
  198.     public static float EaseInOut(float t, float b, float c, float d)
  199.     {
  200.         if (t < d / 2) return EaseIn(t * 2, 0, c, d) * 0.5f + b;
  201.         else return EaseOut(t * 2 - d, 0, c, d) * .5f + c * 0.5f + b;
  202.     }
  203. }
  204.  
  205. public static class Back
  206. {
  207.     public static float EaseIn(float t, float b, float c, float d)
  208.     {
  209.         return c * (t /= d) * t * ((1.70158f + 1) * t - 1.70158f) + b;
  210.     }
  211.    
  212.     public static float EaseOut(float t, float b, float c, float d)
  213.     {
  214.         return c * ((t = t / d - 1) * t * ((1.70158f + 1) * t + 1.70158f) + 1) + b;
  215.     }
  216.    
  217.     public static float EaseInOut(float t, float b, float c, float d)
  218.     {
  219.         float s = 1.70158f;
  220.         if ((t /= d / 2) < 1)
  221.         {
  222.             return c / 2 * (t * t * (((s *= (1.525f)) + 1) * t - s)) + b;
  223.         }
  224.         return c / 2 * ((t -= 2) * t * (((s *= (1.525f)) + 1) * t + s) + 2) + b;
  225.     }
  226. }
  227.  
  228. public static class Quadratic
  229. {
  230.     public static float EaseIn(float t, float b, float c, float d)
  231.     {
  232.         return c * (t /= d) * t + b;
  233.     }
  234.    
  235.     public static float EaseOut(float t, float b, float c, float d)
  236.     {
  237.         return -c * (t /= d) * (t - 2) + b;
  238.     }
  239.    
  240.     public static float EaseInOut(float t, float b, float c, float d)
  241.     {
  242.         if ((t /= d / 2) < 1)
  243.         {
  244.             return c / 2 * t * t + b;
  245.         }
  246.         return -c / 2 * ((--t) * (t - 2) - 1) + b;
  247.     }
  248. }
  249.  
  250. public static class Quartic
  251. {
  252.     public static float EaseIn(float t, float b, float c, float d)
  253.     {
  254.         return c * (t /= d) * t * t * t + b;
  255.     }
  256.    
  257.     public static float EaseOut(float t, float b, float c, float d)
  258.     {
  259.         return -c * ((t = t / d - 1) * t * t * t - 1) + b;
  260.     }
  261.    
  262.     public static float EaseInOut(float t, float b, float c, float d)
  263.     {
  264.         if ((t /= d / 2) < 1)
  265.         {
  266.             return c / 2 * t * t * t * t + b;
  267.         }
  268.         return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
  269.     }
  270. }
  271.  
  272. public static class Quintic
  273. {
  274.     public static float EaseIn(float t, float b, float c, float d)
  275.     {
  276.         return c * (t /= d) * t * t * t * t + b;
  277.     }
  278.    
  279.     public static float EaseOut(float t, float b, float c, float d)
  280.     {
  281.         return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
  282.     }
  283.    
  284.     public static float EaseInOut(float t, float b, float c, float d)
  285.     {
  286.         if ((t /= d / 2) < 1)
  287.         {
  288.             return c / 2 * t * t * t * t * t + b;
  289.         }
  290.         return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
  291.     }
  292. }
  293.  
  294. public static class Sinusoidal
  295. {
  296.     public static float EaseIn(float t, float b, float c, float d)
  297.     {
  298.         return -c * (float)Math.Cos(t / d * (Math.PI / 2)) + c + b;
  299.     }
  300.     public static float EaseOut(float t, float b, float c, float d)
  301.     {
  302.         return c * (float)Math.Sin(t / d * (Math.PI / 2)) + b;
  303.     }
  304.     public static float EaseInOut(float t, float b, float c, float d)
  305.     {
  306.         return -c / 2 * ((float)Math.Cos(Math.PI * t / d) - 1) + b;
  307.     }
  308. }
  309.  
  310. public static class Exponential
  311. {
  312.     public static float EaseIn(float t, float b, float c, float d)
  313.     {
  314.         return (t == 0) ? b : c * (float)Math.Pow(2, 10 * (t / d - 1)) + b;
  315.     }
  316.    
  317.     public static float EaseOut(float t, float b, float c, float d)
  318.     {
  319.         return (t == d) ? b + c : c * (float)(-Math.Pow(2, -10 * t / d) + 1) + b;
  320.     }
  321.    
  322.     public static float EaseInOut(float t, float b, float c, float d)
  323.     {
  324.         if (t == 0)
  325.         {
  326.             return b;
  327.         }
  328.         if (t == d)
  329.         {
  330.             return b + c;
  331.         }
  332.         if ((t /= d / 2) < 1)
  333.         {
  334.             return c / 2 * (float)Math.Pow(2, 10 * (t - 1)) + b;
  335.         }
  336.         return c / 2 * (float)(-Math.Pow(2, -10 * --t) + 2) + b;
  337.     }
  338. }
  339.  
  340. public static class Linear
  341. {
  342.     public static float EaseNone(float t, float b, float c, float d)
  343.     {
  344.         return c * t / d + b;
  345.     }
  346.    
  347.     public static float EaseIn(float t, float b, float c, float d)
  348.     {
  349.         return c * t / d + b;
  350.     }
  351.    
  352.     public static float EaseOut(float t, float b, float c, float d)
  353.     {
  354.         return c * t / d + b;
  355.     }
  356.    
  357.     public static float EaseInOut(float t, float b, float c, float d)
  358.     {
  359.         return c * t / d + b;
  360.     }
  361. }
  362.  
  363. public class Elastic
  364. {
  365.     public static float EaseIn(float t, float b, float c, float d)
  366.     {
  367.         if (t == 0)
  368.         {
  369.             return b;
  370.         }
  371.         if ((t /= d) == 1)
  372.         {
  373.             return b + c;
  374.         }
  375.         float p = d * .3f;
  376.         float s = p / 4;
  377.         return -(float)(c * Math.Pow(2, 10 * (t -= 1)) * Math.Sin((t * d - s) * (2 * Math.PI) / p)) + b;
  378.     }
  379.    
  380.     public static float EaseOut(float t, float b, float c, float d)
  381.     {
  382.         if (t == 0)
  383.         {
  384.             return b;
  385.         }
  386.         if ((t /= d) == 1)
  387.         {
  388.             return b + c;
  389.         }
  390.         float p = d * .3f;
  391.         float s = p / 4;
  392.         return (float)(c * Math.Pow(2, -10 * t) * Math.Sin((t * d - s) * (2 * Math.PI) / p) + c + b);
  393.     }
  394.    
  395.     public static float EaseInOut(float t, float b, float c, float d)
  396.     {
  397.         if (t == 0)
  398.         {
  399.             return b;
  400.         }
  401.         if ((t /= d / 2) == 2)
  402.         {
  403.             return b + c;
  404.         }
  405.         float p = d * (.3f * 1.5f);
  406.         float a = c;
  407.         float s = p / 4;
  408.         if (t < 1)
  409.         {
  410.             return -.5f * (float)(a * Math.Pow(2, 10 * (t -= 1)) * Math.Sin((t * d - s) * (2 * Math.PI) / p)) + b;
  411.         }
  412.         return (float)(a * Math.Pow(2, -10 * (t -= 1)) * Math.Sin((t * d - s) * (2 * Math.PI) / p) * .5 + c + b);
  413.     }
  414. }
  415.  
  416. public static class Circular
  417. {
  418.     public static float EaseIn(float t, float b, float c, float d)
  419.     {
  420.         return -c * ((float)Math.Sqrt(1 - (t /= d) * t) - 1) + b;
  421.     }
  422.    
  423.     public static float EaseOut(float t, float b, float c, float d)
  424.     {
  425.         return c * (float)Math.Sqrt(1 - (t = t / d - 1) * t) + b;
  426.     }
  427.    
  428.     public static float EaseInOut(float t, float b, float c, float d)
  429.     {
  430.         if ((t /= d / 2) < 1)
  431.         {
  432.             return -c / 2 * ((float)Math.Sqrt(1 - t * t) - 1) + b;
  433.         }
  434.         return c / 2 * ((float)Math.Sqrt(1 - (t -= 2) * t) + 1) + b;
  435.     }
  436. }
  437.  
  438. public static class Cubic
  439. {
  440.     public static float EaseIn(float t, float b, float c, float d)
  441.     {
  442.         return c * (t /= d) * t * t + b;
  443.     }
  444.    
  445.     public static float EaseOut(float t, float b, float c, float d)
  446.     {
  447.         return c * ((t = t / d - 1) * t * t + 1) + b;
  448.     }
  449.    
  450.     public static float EaseInOut(float t, float b, float c, float d)
  451.     {
  452.         if ((t /= d / 2) < 1)
  453.         {
  454.             return c / 2 * t * t * t + b;
  455.         }
  456.         return c / 2 * ((t -= 2) * t * t + 2) + b;
  457.     }
  458. }
Advertisement
Advertisement
Advertisement
RAW Paste Data Copied
Advertisement