753 lines
26 KiB
Plaintext
753 lines
26 KiB
Plaintext
;- 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 |