;- Easing
 Enumeration
       #Easing_Linear
      
      #Easing_ExpoEaseOut
      #Easing_ExpoEaseIn
      #Easing_ExpoEaseInOut
      #Easing_ExpoEaseOutIn
      
      #Easing_QuadEaseOut
      #Easing_QuadEaseIn
      #Easing_QuadEaseInOut
      #Easing_QuadEaseOutIn
      
      #Easing_CubicEaseOut
      #Easing_CubicEaseIn
      #Easing_CubicEaseInOut
      #Easing_CubicEaseOutIn
      
      #Easing_QuartEaseOut
      #Easing_QuartEaseIn
      #Easing_QuartEaseInOut
      #Easing_QuartEaseOutIn
      
      #Easing_QuintEaseOut
      #Easing_QuintEaseIn
      #Easing_QuintEaseInOut
      #Easing_QuintEaseOutIn
      
      #Easing_CircEaseOut
      #Easing_CircEaseIn
      #Easing_CircEaseInOut
      #Easing_CircEaseOutIn
      
      #Easing_SineEaseOut
      #Easing_SineEaseIn
      #Easing_SineEaseInOut
      #Easing_SineEaseOutIn
      
       #Easing_ElasticEaseOut
      #Easing_ElasticEaseIn
      #Easing_ElasticEaseInOut
      #Easing_ElasticEaseOutIn
      
      #Easing_BounceEaseOut
      #Easing_BounceEaseIn
      #Easing_BounceEaseInOut
      #Easing_BounceEaseOutIn
      
      #Easing_BackEaseOut
      #Easing_BackEaseIn
      #Easing_BackEaseInOut
      #Easing_BackEaseOutIn      
      
      #Easing_End
    EndEnumeration
    
    #MAX_EASING=$10000
    
    Global Dim EASING.f(#Easing_End-1, #MAX_EASING)
    
    
    ;-Expo
    
    CompilerIf Defined(Easing_ExpoEaseOut, #PB_Constant) Or Defined(Easing_ExpoEaseOutIn,#PB_Constant)
    Procedure.f ExpoEaseOut(Fraction.f)
      If Fraction=1 : ProcedureReturn 1 : Else : ProcedureReturn (-Pow(2, -10 * Fraction) + 1) : EndIf
    EndProcedure
    CompilerEndIf
    
    CompilerIf Defined(Easing_ExpoEaseIn,#PB_Constant) Or Defined(Easing_ExpoEaseOutIn,#PB_Constant)
   ; Easing equation function for an exponential (2^t) easing in:
   ; accelerating from zero velocity.
   Procedure.f ExpoEaseIn(Fraction.f)
      If Fraction=0 : ProcedureReturn 0 : Else : ProcedureReturn Pow(2, 10 * (Fraction-1)) : EndIf
   EndProcedure
 CompilerEndIf
 
 CompilerIf Defined(Easing_ExpoEaseInOut,#PB_Constant)
   ; Easing equation function for an exponential (2^t) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f ExpoEaseInOut(Fraction.f)
      If (Fraction=0)
         ProcedureReturn 0
      ElseIf (Fraction=1)
         ProcedureReturn 1
      EndIf
      
      Fraction * 2
      If (Fraction<1)
         ProcedureReturn 0.5 * Pow(2, 10 * (Fraction - 1))
      Else
         ProcedureReturn 0.5 * (-Pow(2, -10 * (Fraction - 1)) + 2)
      EndIf
   EndProcedure
 CompilerEndIf
 
 CompilerIf Defined(Easing_ExpoEaseOutIn,#PB_Constant)
   ; Easing equation function for an exponential (2^t) easing out/in:
   ; deceleration until halfway, then acceleration.
   Procedure.f ExpoEaseOutIn(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5 * ExpoEaseOut(2*Fraction)
      Else
         ProcedureReturn 0.5 + 0.5 * ExpoEaseIn(2*Fraction - 1)
      EndIf
   EndProcedure
 CompilerEndIf 
 
 ;-Quadratic
 
 CompilerIf Defined(Easing_QuadEaseOut,#PB_Constant) Or Defined(Easing_QuadEaseOutIn,#PB_Constant)
   ; Easing equation function for a quadratic (t^2) easing out:
   ; decelerating from zero velocity.
   Procedure.f QuadEaseOut(Fraction.f) 
      ProcedureReturn -Fraction * (Fraction - 2)
   EndProcedure
 CompilerEndIf
 
  CompilerIf Defined(Easing_QuadEaseIn,#PB_Constant) Or Defined(Easing_QuadEaseOutIn,#PB_Constant)
   ; Easing equation function for a quadratic (t^2) easing in:
   ; accelerating from zero velocity.
   Procedure.f QuadEaseIn(Fraction.f)
      ProcedureReturn Fraction * Fraction
   EndProcedure
 CompilerEndIf
 
 CompilerIf Defined(Easing_QuadEaseInOut,#PB_Constant)
   ; Easing equation function for a quadratic (t^2) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f QuadEaseInOut(Fraction.f)
      Fraction * 2
      If (Fraction<1)
         ProcedureReturn 0.5 * Fraction * Fraction
      Else
         Fraction-1
         ProcedureReturn -0.5 * (Fraction * (Fraction - 2) - 1)
      EndIf
    EndProcedure
 CompilerEndIf
 
 CompilerIf Defined(Easing_QuadEaseOutIn,#PB_Constant)
   ; Easing equation function for a quadratic (t^2) easing out/in:
   ; deceleration until halfway, then acceleration.
   Procedure.f QuadEaseOutIn(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5 * QuadEaseOut(Fraction * 2);
      Else
         ProcedureReturn 0.5 + 0.5 * QuadEaseIn((Fraction * 2) - 1)
      EndIf
   EndProcedure
  CompilerEndIf 

   CompilerIf Defined(Easing_CubicEaseOut,#PB_Constant) Or Defined(Easing_CubicEaseOutIn,#PB_Constant) 
   ; Easing equation function for a cubic (t^3) easing out:
   ; decelerating from zero velocity.
   Procedure.f CubicEaseOut(Fraction.f)
      Fraction - 1
      ProcedureReturn Fraction * Fraction * Fraction + 1
    EndProcedure
  CompilerEndIf
  
  CompilerIf Defined(Easing_CubicEaseIn,#PB_Constant)  Or Defined(Easing_CubicEaseOutIn,#PB_Constant) 
   ; Easing equation function for a cubic (t^3) easing in:
   ; accelerating from zero velocity.
   Procedure.f CubicEaseIn(Fraction.f)
      ProcedureReturn Fraction * Fraction * Fraction
    EndProcedure
  CompilerEndIf
   
   ; Easing equation function for a cubic (t^3) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f CubicEaseInOut(Fraction.f)
      Fraction * 2
      If (Fraction<1)
         ProcedureReturn 0.5 * Fraction * Fraction * Fraction
      Else
         Fraction - 2
         ProcedureReturn 0.5 * (Fraction * Fraction * Fraction + 2)
      EndIf
   EndProcedure
   
   CompilerIf Defined(Easing_CubicEaseOutIn,#PB_Constant) 
   ; Easing equation function for a cubic (t^3) easing out/in:
   ; deceleration until halfway, then acceleration.
   Procedure.f CubicEaseOutIn(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5 * CubicEaseOut(Fraction * 2)
      Else
         ProcedureReturn 0.5 + 0.5 * CubicEaseIn((Fraction * 2) - 1)
      EndIf
   EndProcedure
   CompilerEndIf
  ;-Quartic
   CompilerIf Defined(Easing_QuartEaseOut,#PB_Constant)  Or Defined(Easing_QuartEaseOutIn,#PB_Constant) 
   ; Easing equation function for a quartic (t^4) easing out:
   ; decelerating from zero velocity.
   Procedure.f QuartEaseOut(Fraction.f)
      Fraction - 1
      ProcedureReturn -(Fraction * Fraction * Fraction * Fraction - 1)
   EndProcedure
 CompilerEndIf
  CompilerIf Defined(Easing_QuartEaseIn,#PB_Constant) Or Defined(Easing_QuartEaseOutIn,#PB_Constant) 
   ; Easing equation function for a quartic (t^4) easing in:
   ; accelerating from zero velocity.
   Procedure.f QuartEaseIn(Fraction.f)
      ProcedureReturn Fraction * Fraction * Fraction * Fraction
    EndProcedure
  CompilerEndIf 
   
   CompilerIf Defined(Easing_QuartEaseInOut,#PB_Constant) 
   ; Easing equation function for a quartic (t^4) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f QuartEaseInOut(Fraction.f)
      Fraction * 2
      If (Fraction<1)
         ProcedureReturn 0.5 * Fraction * Fraction * Fraction * Fraction
      Else
         Fraction - 2
         ProcedureReturn -0.5 * (Fraction * Fraction * Fraction * Fraction - 2)
      EndIf
   EndProcedure
 CompilerEndIf
 
 CompilerIf Defined(Easing_QuartEaseOutIn,#PB_Constant) 
   ; Easing equation function for a quartic (t^4) easing out/in:
   ; deceleration until halfway, then acceleration.
   Procedure.f QuartEaseOutIn(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5 * QuartEaseOut(Fraction * 2)
      Else
         ProcedureReturn 0.5 + 0.5 * QuartEaseIn((Fraction * 2) - 1)
      EndIf
   EndProcedure
 CompilerEndIf  
   
  ;-Quintic
 
CompilerIf Defined(Easing_QuintEaseOut,#PB_Constant)  Or Defined(Easing_QuintEaseOutIn,#PB_Constant) 
   ; Easing equation function for a quintic (t^5) easing out:
   ; decelerating from zero velocity.
   Procedure.f QuintEaseOut(Fraction.f)
      Fraction - 1
      ProcedureReturn (Fraction * Fraction * Fraction * Fraction * Fraction + 1)
   EndProcedure
 CompilerEndIf
 
 CompilerIf Defined(Easing_QuintEaseIn,#PB_Constant) Or Defined(Easing_QuintEaseOutIn,#PB_Constant) 
   ; Easing equation function for a quintic (t^5) easing in:
   ; accelerating from zero velocity.
   Procedure.f QuintEaseIn(Fraction.f)
      ProcedureReturn Fraction * Fraction * Fraction * Fraction * Fraction
    EndProcedure
 CompilerEndIf
 
 CompilerIf Defined(Easing_QuintEaseInOut,#PB_Constant) 
   ; Easing equation function for a quintic (t^5) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f QuintEaseInOut(Fraction.f)
      Fraction * 2
      If (Fraction<1)
         ProcedureReturn 0.5 * Fraction * Fraction * Fraction * Fraction * Fraction
      Else
         Fraction - 2
         ProcedureReturn 0.5 * (Fraction * Fraction * Fraction * Fraction * Fraction + 2)
      EndIf
    EndProcedure
 CompilerEndIf
   
   CompilerIf Defined(Easing_QuintEaseOutIn,#PB_Constant) 
   ; Easing equation function for a quintic (t^5) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f QuintEaseOutIn(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5*QuintEaseOut(Fraction * 2);
      Else
         ProcedureReturn 0.5 + 0.5*QuintEaseIn((Fraction * 2) - 1)
      EndIf
    EndProcedure
   CompilerEndIf
   

   
 ;- Circular
   CompilerIf Defined(Easing_CircEaseOut,#PB_Constant) Or Defined(Easing_CircEaseOutIn,#PB_Constant) 
   ; Easing equation function for a circular (sqrt(1-t^2)) easing out:
   ; decelerating from zero velocity.
   Procedure.f CircEaseOut(Fraction.f)
      Fraction - 1
      ProcedureReturn Sqr(1 - Fraction * Fraction)
    EndProcedure
  CompilerEndIf
  
  CompilerIf Defined(Easing_CircEaseIn,#PB_Constant) Or Defined(Easing_CircEaseOutIn,#PB_Constant) 
   ; Easing equation function for a circular (sqrt(1-t^2)) easing in:
   ; accelerating from zero velocity.
   Procedure.f CircEaseIn(Fraction.f)
      ProcedureReturn - (Sqr(1 - Fraction * Fraction) - 1)
    EndProcedure
  CompilerEndIf
  
  CompilerIf Defined(Easing_CircEaseInOut,#PB_Constant) 
   ; Easing equation function for a circular (sqrt(1-t^2)) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f CircEaseInOut(Fraction.f)
      Fraction * 2
      If (Fraction<1)
         ProcedureReturn -0.5 * (Sqr(1 - Fraction * Fraction) - 1)
      Else
         Fraction - 2
         ProcedureReturn 0.5 * (Sqr(1 - Fraction * Fraction) + 1)
      EndIf
    EndProcedure
  CompilerEndIf
  
  CompilerIf Defined(Easing_CircEaseOutIn,#PB_Constant) 
   ; Easing equation function for a circular (sqrt(1-t^2)) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f CircEaseOutIn(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5*CircEaseOut(Fraction * 2)
      Else
         ProcedureReturn 0.5 + 0.5*CircEaseIn((Fraction * 2) - 1)
      EndIf
    EndProcedure
 CompilerEndIf
   
   
;-Sine
   CompilerIf Defined(Easing_SineEaseOut,#PB_Constant) Or Defined(Easing_SineEaseOutIn,#PB_Constant) 
   ; Easing equation function for a sinusoidal (sin(t)) easing out:
   ; decelerating from zero velocity.
   Procedure.f SineEaseOut(Fraction.f)
      ProcedureReturn Sin(Fraction * (#PI / 2))
    EndProcedure
  CompilerEndIf
  
   CompilerIf Defined(Easing_SineEaseIn,#PB_Constant) Or Defined(Easing_SineEaseOutIn,#PB_Constant) 
   ; Easing equation function for a sinusoidal (sin(t)) easing in:
   ; accelerating from zero velocity.
   Procedure.f SineEaseIn(Fraction.f)
      ProcedureReturn - Cos(Fraction * (#PI / 2)) + 1
    EndProcedure
   CompilerEndIf
   
   ; Easing equation function for a sinusoidal (sin(t)) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f SineEaseInOut(Fraction.f)
      ProcedureReturn -0.5 * (Cos(Fraction*#PI) - 1)
   EndProcedure
   
   CompilerIf Defined(Easing_SineEaseOutIn,#PB_Constant) 
   ; Easing equation function for a sinusoidal (sin(t)) easing in/out:
   ; deceleration until halfway, then acceleration.
   Procedure.f SineEaseOutIn(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5*SineEaseOut(Fraction * 2)
      Else
         ProcedureReturn 0.5 + 0.5*SineEaseIn((Fraction * 2) - 1)
      EndIf
    EndProcedure
  CompilerEndIf
   
   
 ;-Elastic
  
  CompilerIf Defined(Easing_ElasticEaseOut,#PB_Constant) Or Defined(Easing_ElasticEaseOutIn,#PB_Constant)
   ; Easing equation function for an elastic (exponentially decaying sine wave) easing out:
   ; decelerating from zero velocity.
   Procedure.f ElasticEaseOut(Fraction.f)
      If (Fraction=1)
         ProcedureReturn 1
      EndIf
      
      Protected p.f=0.3
      Protected s.f=p / 4
      ProcedureReturn Pow(2, -10 * Fraction) * Sin((Fraction - s) * (2 * #PI) / p) + 1
   EndProcedure
 CompilerEndIf
 
 CompilerIf Defined(Easing_ElasticEaseIn,#PB_Constant) Or Defined(Easing_ElasticEaseOutIn,#PB_Constant)
   ; Easing equation function for an elastic (exponentially decaying sine wave) easing in:
   ; accelerating from zero velocity.
   Procedure.f ElasticEaseIn(Fraction.f)
      If (Fraction=1)
         ProcedureReturn 1
      EndIf
      
      Protected p.f=0.3
      Protected s.f=p / 4
      Fraction - 1
      ProcedureReturn -Pow(2, 10 * Fraction) * Sin((Fraction - s) * (2 * #PI) / p)
    EndProcedure
  CompilerEndIf
  
   CompilerIf Defined(Easing_ElasticEaseInOut,#PB_Constant) 
   ; Easing equation function for an elastic (exponentially decaying sine wave) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f ElasticEaseInOut(Fraction.f)
      Fraction * 2
      If (Fraction=2)
         ProcedureReturn 1
      EndIf
      
      Protected p.f=(0.3 * 1.5)
      Protected s.f=p / 4
      If (Fraction<1)
         Fraction - 1
         ProcedureReturn -0.5 * (Pow(2, 10 * Fraction) * Sin((Fraction - s) * (2 * #PI) / p))
      Else
         Fraction - 1
         ProcedureReturn 0.5 * (Pow(2, -10 * Fraction) * Sin((Fraction - s) * (2 * #PI) / p)) + 1
      EndIf
    EndProcedure
  CompilerEndIf
  
   CompilerIf Defined(Easing_ElasticEaseOutIn,#PB_Constant)
   ; Easing equation function for an elastic (exponentially decaying sine wave) easing out/in:
   ; deceleration until halfway, then acceleration.
   Procedure.f ElasticEaseOutIn(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5*ElasticEaseOut(Fraction * 2)
      Else
         ProcedureReturn 0.5 + 0.5*ElasticEaseIn((Fraction * 2) - 1)
      EndIf
   EndProcedure
   CompilerEndIf  

   
;-Bounce
   
   CompilerIf Defined(Easing_BounceEaseOut,#PB_Constant) Or Defined(Easing_BounceEaseOutIn,#PB_Constant) Or Defined(Easing_BounceEaseInOut,#PB_Constant)
   ; Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out:
   ; decelerating from zero velocity.
   Procedure.f BounceEaseOut(Fraction.f)
      If (Fraction<(1 / 2.75))
         ProcedureReturn (7.5625 * Fraction * Fraction)
      ElseIf (Fraction<(2 / 2.75))
         Fraction - (1.5 / 2.75)
         ProcedureReturn (7.5625 * Fraction * Fraction + 0.75)
      ElseIf (Fraction<(2.5 / 2.75))
         Fraction - (2.25 / 2.75)
         ProcedureReturn (7.5625 * Fraction * Fraction + 0.9375)
      Else
         Fraction - (2.625 / 2.75)
         ProcedureReturn (7.5625 * Fraction * Fraction + 0.984375)
      EndIf
    EndProcedure
    CompilerEndIf 
    
    CompilerIf Defined(Easing_BounceEaseIn,#PB_Constant) Or Defined(Easing_BounceEaseOutIn,#PB_Constant) Or Defined(Easing_BounceEaseInOut,#PB_Constant)
   ; Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in:
   ; accelerating from zero velocity.
   Procedure.f BounceEaseIn(Fraction.f)
      ProcedureReturn 1 - BounceEaseOut(1 - Fraction)
    EndProcedure
    CompilerEndIf
    
    CompilerIf Defined(Easing_BounceEaseInOut,#PB_Constant)
   ; Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f BounceEaseInOut(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5*BounceEaseIn(Fraction * 2)
      Else
         ProcedureReturn 0.5 + 0.5*BounceEaseOut((Fraction * 2) - 1)
      EndIf
    EndProcedure
    CompilerEndIf
    
    CompilerIf Defined(Easing_BounceEaseOutIn,#PB_Constant)
   ; Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out/in:
   ; deceleration until halfway, then acceleration.
   Procedure.f BounceEaseOutIn(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5*BounceEaseOut(Fraction * 2)
      EndIf
      
      ProcedureReturn 0.5 + 0.5*BounceEaseIn(Fraction * 2 - 1)
    EndProcedure
    CompilerEndIf
   

   
   ;-Back
   CompilerIf Defined(Easing_BackEaseOut,#PB_Constant) Or Defined(Easing_BackEaseOutIn,#PB_Constant)
   ; Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out:
   ; decelerating from zero velocity.
   Procedure.f BackEaseOut(Fraction.f)
      Fraction - 1
      ProcedureReturn Fraction * Fraction * ((1.70158 + 1) * Fraction + 1.70158) + 1
    EndProcedure
   CompilerEndIf
   
   CompilerIf Defined(Easing_BackEaseIn,#PB_Constant) Or Defined(Easing_BackEaseOutIn,#PB_Constant)
   ; Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in:
   ; accelerating from zero velocity.
   Procedure.f BackEaseIn(Fraction.f)
      ProcedureReturn Fraction * Fraction * ((1.70158 + 1) * Fraction - 1.70158)
    EndProcedure
   CompilerEndIf  
   
   CompilerIf Defined(Easing_BackEaseInOut,#PB_Constant)
   ; Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in/out:
   ; acceleration until halfway, then deceleration.
   Procedure.f BackEaseInOut(Fraction.f)
      Protected s.f=1.70158
      Fraction * 2
      If (Fraction<1)
         s * (1.525)
         ProcedureReturn 0.5 * (Fraction * Fraction * ((s + 1) * Fraction - s))
      Else
         Fraction - 2
         s * (1.525)
         ProcedureReturn 0.5 * (Fraction * Fraction * ((s + 1) * Fraction + s) + 2)
      EndIf
    EndProcedure
  CompilerEndIf
  
  CompilerIf Defined(Easing_BackEaseOutIn,#PB_Constant)
   ; Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out/in:
   ; deceleration until halfway, then acceleration.
   Procedure.f BackEaseOutIn(Fraction.f)
      If (Fraction<0.5)
         ProcedureReturn 0.5*BackEaseOut(Fraction * 2)
      EndIf
      
      ProcedureReturn 0.5 + 0.5*BackEaseIn((Fraction * 2) - 1)
    EndProcedure
 CompilerEndIf
   ;-FIN procedure
 Procedure InitEase()
   Protected i
      For i=0 To #MAX_EASING
        CompilerIf Defined(Easing_Linear, #PB_Constant)
          EASING(#Easing_Linear,i)=i/#MAX_EASING
        CompilerEndIf
        
        CompilerIf Defined(Easing_ExpoEaseOut,#PB_Constant)
          EASING(#Easing_ExpoEaseOut,i)=ExpoEaseOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_ExpoEaseIn,#PB_Constant)
          EASING(#Easing_ExpoEaseIn,i)=ExpoEaseIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_ExpoEaseInOut,#PB_Constant)
          EASING(#Easing_ExpoEaseInOut,i)=ExpoEaseInOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_ExpoEaseOutIn,#PB_Constant)
          EASING(#Easing_ExpoEaseOutIn,i)=ExpoEaseOutIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_ExpoEaseOutIn,#PB_Constant)
          EASING(#Easing_ExpoEaseOutIn,i)=ExpoEaseOutIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_QuadEaseOut,#PB_Constant)
          EASING(#Easing_QuadEaseOut,i)=QuadEaseOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_QuadEaseIn,#PB_Constant)
          EASING(#Easing_QuadEaseIn,i)=QuadEaseIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_QuadEaseInOut,#PB_Constant)
          EASING(#Easing_QuadEaseInOut,i)=QuadEaseInOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_QuadEaseOutIn,#PB_Constant)
          EASING(#Easing_QuadEaseOutIn,i)=QuadEaseOutIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_CubicEaseOut,#PB_Constant)
          EASING(#Easing_CubicEaseOut,i)=CubicEaseOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_CubicEaseIn,#PB_Constant)
          EASING(#Easing_CubicEaseIn,i)=CubicEaseIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_CubicEaseInOut,#PB_Constant)
          EASING(#Easing_CubicEaseInOut,i)=CubicEaseInOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_CubicEaseOutIn,#PB_Constant)
          EASING(#Easing_CubicEaseOutIn,i)=CubicEaseOutIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_QuartEaseOut,#PB_Constant)
          EASING(#Easing_QuartEaseOut,i)=QuartEaseOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_QuartEaseIn,#PB_Constant)
          EASING(#Easing_QuartEaseIn,i)=QuartEaseIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_QuartEaseInOut,#PB_Constant)
          EASING(#Easing_QuartEaseInOut,i)=QuartEaseInOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_QuartEaseOutIn,#PB_Constant)
          EASING(#Easing_QuartEaseOutIn,i)=QuartEaseOutIn(i/#MAX_EASING)
        CompilerEndIf

        CompilerIf Defined(Easing_QuintEaseOut,#PB_Constant)
          EASING(#Easing_QuintEaseOut,i)=QuintEaseOut(i/#MAX_EASING)
        CompilerEndIf 
        
        CompilerIf Defined(Easing_QuintEaseIn,#PB_Constant)
          EASING(#Easing_QuintEaseIn,i)=QuintEaseIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_QuintEaseInOut,#PB_Constant)
          EASING(#Easing_QuintEaseInOut,i)=QuintEaseInOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_QuintEaseOutIn,#PB_Constant)
          EASING(#Easing_QuintEaseOutIn,i)=QuintEaseOutIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_CircEaseOut,#PB_Constant)
          EASING(#Easing_CircEaseOut,i)=CircEaseOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_CircEaseIn,#PB_Constant)
          EASING(#Easing_CircEaseIn,i)=CircEaseIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_CircEaseInOut,#PB_Constant)
          EASING(#Easing_CircEaseInOut,i)=CircEaseInOut(i/#MAX_EASING)
        CompilerEndIf
        
        
        
        CompilerIf Defined(Easing_CircEaseOutIn,#PB_Constant)
          EASING(#Easing_CircEaseOutIn,i)=CircEaseOutIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_SineEaseOut,#PB_Constant)
          EASING(#Easing_SineEaseOut,i)=SineEaseOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_SineEaseIn,#PB_Constant)
          EASING(#Easing_SineEaseIn,i)=SineEaseIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_SineEaseInOut,#PB_Constant)
          EASING(#Easing_SineEaseInOut,i)=SineEaseInOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_SineEaseOutIn,#PB_Constant)
          EASING(#Easing_SineEaseOutIn,i)=SineEaseOutIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_ElasticEaseOut,#PB_Constant)
          EASING(#Easing_ElasticEaseOut,i)=ElasticEaseOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_ElasticEaseIn,#PB_Constant)
          EASING(#Easing_ElasticEaseIn,i)=ElasticEaseIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_ElasticEaseInOut,#PB_Constant)
          EASING(#Easing_ElasticEaseInOut,i)=ElasticEaseInOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_ElasticEaseOutIn,#PB_Constant)
          EASING(#Easing_ElasticEaseOutIn,i)=ElasticEaseOutIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_BounceEaseOut,#PB_Constant)
          EASING(#Easing_BounceEaseOut,i)=BounceEaseOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_BounceEaseIn,#PB_Constant)
          EASING(#Easing_BounceEaseIn,i)=BounceEaseIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_BounceEaseInOut,#PB_Constant)
          EASING(#Easing_BounceEaseInOut,i)=BounceEaseInOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_BounceEaseOutIn,#PB_Constant)
          EASING(#Easing_BounceEaseOutIn,i)=BounceEaseOutIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_BackEaseOut,#PB_Constant)
          EASING(#Easing_BackEaseOut,i)=BackEaseOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_BackEaseIn,#PB_Constant)
          EASING(#Easing_BackEaseIn,i)=BackEaseIn(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_BackEaseInOut,#PB_Constant)
          EASING(#Easing_BackEaseInOut,i)=BackEaseInOut(i/#MAX_EASING)
        CompilerEndIf
        
        CompilerIf Defined(Easing_BackEaseOutIn,#PB_Constant)
          EASING(#Easing_BackEaseOutIn,i)=BackEaseOutIn(i/#MAX_EASING)
        CompilerEndIf

;         CompilerIf Defined(Easing_ElasticEaseOut, #PB_Constant)
;           EASING(#Easing_ElasticEaseOut,i)=ElasticEaseOut(i/#MAX_EASING)
;         CompilerEndIf
      Next
    EndProcedure
    
    InitEase()
    
    
Procedure.F FractionTimer(ExecutionTime, IsPingPong=#False, Duration=1000, LoopDuration=0)
  If ExecutionTime<0            ; Determines if timer has started
    ExecutionTime=0
  ElseIf ExecutionTime>Duration ; Determines if timer has ended
    ExecutionTime=Duration
  EndIf
  Protected Fraction.f
  ;Convert to Loop if necessary
  If LoopDuration
    Fraction=Mod(ExecutionTime, LoopDuration) / LoopDuration
  Else         
    Fraction=ExecutionTime / Duration
  EndIf      
  ;Convert to PingPong if necessary
  If IsPingPong
    Fraction=1-Abs(2*Fraction-1)
  EndIf
  ProcedureReturn Fraction
EndProcedure         

Procedure.f GetEasingPosValue(StartValue.f, FinishValue.f,StartTime.q, Duration.l, Easing.l)
  Protected CurrentTime.q=ElapsedMilliseconds()-StartTime
  Protected i=#MAX_EASING*CurrentTime/Duration
  Protected Result.f,Distance.f
  If i<0 
    Result=0
  ElseIf i>#MAX_EASING
     Result=1
  Else
      Result=EASING(Easing, i);#MAX_EASING
  EndIf
   Distance=FinishValue-StartValue
   Protected.f Position=StartValue+Distance*Result
   ProcedureReturn Position
EndProcedure
; IDE Options = PureBasic 6.00 Beta 6 (Windows - x64)
; CursorPosition = 739
; FirstLine = 676
; Folding = ---------------------
; EnableXP