852 lines
18 KiB
C#
852 lines
18 KiB
C#
/*************************************************************************************
|
|
|
|
Extended WPF Toolkit
|
|
|
|
Copyright (C) 2007-2013 Xceed Software Inc.
|
|
|
|
This program is provided to you under the terms of the Microsoft Public
|
|
License (Ms-PL) as published at http://wpftoolkit.codeplex.com/license
|
|
|
|
For more features, controls, and fast professional support,
|
|
pick up the Plus Edition at http://xceed.com/wpf_toolkit
|
|
|
|
Stay informed: follow @datagrid on Twitter or Like http://facebook.com/datagrids
|
|
|
|
***********************************************************************************/
|
|
|
|
using System;
|
|
|
|
namespace Xceed.Wpf.Toolkit.Media.Animation
|
|
{
|
|
public static class PennerEquations
|
|
{
|
|
#region BackEaseIn Static Property
|
|
|
|
public static PennerEquation BackEaseIn
|
|
{
|
|
get
|
|
{
|
|
if( _backEaseIn == null )
|
|
{
|
|
_backEaseIn = new PennerEquation( BackEaseInImpl );
|
|
}
|
|
return _backEaseIn;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _backEaseIn;
|
|
|
|
#endregion
|
|
|
|
#region BackEaseInOut Static Property
|
|
|
|
public static PennerEquation BackEaseInOut
|
|
{
|
|
get
|
|
{
|
|
if( _backEaseInOut == null )
|
|
{
|
|
_backEaseInOut = new PennerEquation( BackEaseInOutImpl );
|
|
}
|
|
return _backEaseInOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _backEaseInOut;
|
|
|
|
#endregion
|
|
|
|
#region BackEaseOut Static Property
|
|
|
|
public static PennerEquation BackEaseOut
|
|
{
|
|
get
|
|
{
|
|
if( _backEaseOut == null )
|
|
{
|
|
_backEaseOut = new PennerEquation( BackEaseOutImpl );
|
|
}
|
|
return _backEaseOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _backEaseOut;
|
|
|
|
#endregion
|
|
|
|
#region BounceEaseIn Static Property
|
|
|
|
public static PennerEquation BounceEaseIn
|
|
{
|
|
get
|
|
{
|
|
if( _bounceEaseIn == null )
|
|
{
|
|
_bounceEaseIn = new PennerEquation( BounceEaseInImpl );
|
|
}
|
|
return _bounceEaseIn;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _bounceEaseIn;
|
|
|
|
#endregion
|
|
|
|
#region BounceEaseInOut Static Property
|
|
|
|
public static PennerEquation BounceEaseInOut
|
|
{
|
|
get
|
|
{
|
|
if( _bounceEaseInOut == null )
|
|
{
|
|
_bounceEaseInOut = new PennerEquation( BounceEaseInOutImpl );
|
|
}
|
|
return _bounceEaseInOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _bounceEaseInOut;
|
|
|
|
#endregion
|
|
|
|
#region BounceEaseOut Static Property
|
|
|
|
public static PennerEquation BounceEaseOut
|
|
{
|
|
get
|
|
{
|
|
if( _bounceEaseOut == null )
|
|
{
|
|
_bounceEaseOut = new PennerEquation( BounceEaseOutImpl );
|
|
}
|
|
return _bounceEaseOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _bounceEaseOut;
|
|
|
|
#endregion
|
|
|
|
#region CircEaseIn Static Property
|
|
|
|
public static PennerEquation CircEaseIn
|
|
{
|
|
get
|
|
{
|
|
if( _circEaseIn == null )
|
|
{
|
|
_circEaseIn = new PennerEquation( CircEaseInImpl );
|
|
}
|
|
return _circEaseIn;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _circEaseIn;
|
|
|
|
#endregion
|
|
|
|
#region CircEaseInOut Static Property
|
|
|
|
public static PennerEquation CircEaseInOut
|
|
{
|
|
get
|
|
{
|
|
if( _circEaseInOut == null )
|
|
{
|
|
_circEaseInOut = new PennerEquation( CircEaseInOutImpl );
|
|
}
|
|
return _circEaseInOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _circEaseInOut;
|
|
|
|
#endregion
|
|
|
|
#region CircEaseOut Static Property
|
|
|
|
public static PennerEquation CircEaseOut
|
|
{
|
|
get
|
|
{
|
|
if( _circEaseOut == null )
|
|
{
|
|
_circEaseOut = new PennerEquation( CircEaseOutImpl );
|
|
}
|
|
return _circEaseOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _circEaseOut;
|
|
|
|
#endregion
|
|
|
|
#region CubicEaseIn Static Property
|
|
|
|
public static PennerEquation CubicEaseIn
|
|
{
|
|
get
|
|
{
|
|
if( _cubicEaseIn == null )
|
|
{
|
|
_cubicEaseIn = new PennerEquation( CubicEaseInImpl );
|
|
}
|
|
return _cubicEaseIn;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _cubicEaseIn;
|
|
|
|
#endregion
|
|
|
|
#region CubicEaseInOut Static Property
|
|
|
|
public static PennerEquation CubicEaseInOut
|
|
{
|
|
get
|
|
{
|
|
if( _cubicEaseInOut == null )
|
|
{
|
|
_cubicEaseInOut = new PennerEquation( CubicEaseInOutImpl );
|
|
}
|
|
return _cubicEaseInOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _cubicEaseInOut;
|
|
|
|
#endregion
|
|
|
|
#region CubicEaseOut Static Property
|
|
|
|
public static PennerEquation CubicEaseOut
|
|
{
|
|
get
|
|
{
|
|
if( _cubicEaseOut == null )
|
|
{
|
|
_cubicEaseOut = new PennerEquation( CubicEaseOutImpl );
|
|
}
|
|
return _cubicEaseOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _cubicEaseOut;
|
|
|
|
#endregion
|
|
|
|
#region ElasticEaseIn Static Property
|
|
|
|
public static PennerEquation ElasticEaseIn
|
|
{
|
|
get
|
|
{
|
|
if( _elasticEaseIn == null )
|
|
{
|
|
_elasticEaseIn = new PennerEquation( ElasticEaseInImpl );
|
|
}
|
|
return _elasticEaseIn;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _elasticEaseIn;
|
|
|
|
#endregion
|
|
|
|
#region ElasticEaseInOut Static Property
|
|
|
|
public static PennerEquation ElasticEaseInOut
|
|
{
|
|
get
|
|
{
|
|
if( _elasticEaseInOut == null )
|
|
{
|
|
_elasticEaseInOut = new PennerEquation( ElasticEaseInOutImpl );
|
|
}
|
|
return _elasticEaseInOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _elasticEaseInOut;
|
|
|
|
#endregion
|
|
|
|
#region ElasticEaseOut Static Property
|
|
|
|
public static PennerEquation ElasticEaseOut
|
|
{
|
|
get
|
|
{
|
|
if( _elasticEaseOut == null )
|
|
{
|
|
_elasticEaseOut = new PennerEquation( ElasticEaseOutImpl );
|
|
}
|
|
return _elasticEaseOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _elasticEaseOut;
|
|
|
|
#endregion
|
|
|
|
#region ExpoEaseIn Static Property
|
|
|
|
public static PennerEquation ExpoEaseIn
|
|
{
|
|
get
|
|
{
|
|
if( _expoEaseIn == null )
|
|
{
|
|
_expoEaseIn = new PennerEquation( ExpoEaseInImpl );
|
|
}
|
|
return _expoEaseIn;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _expoEaseIn;
|
|
|
|
#endregion
|
|
|
|
#region ExpoEaseInOut Static Property
|
|
|
|
public static PennerEquation ExpoEaseInOut
|
|
{
|
|
get
|
|
{
|
|
if( _expoEaseInOut == null )
|
|
{
|
|
_expoEaseInOut = new PennerEquation( ExpoEaseInOutImpl );
|
|
}
|
|
return _expoEaseInOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _expoEaseInOut;
|
|
|
|
#endregion
|
|
|
|
#region ExpoEaseOut Static Property
|
|
|
|
public static PennerEquation ExpoEaseOut
|
|
{
|
|
get
|
|
{
|
|
if( _expoEaseOut == null )
|
|
{
|
|
_expoEaseOut = new PennerEquation( ExpoEaseOutImpl );
|
|
}
|
|
return _expoEaseOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _expoEaseOut;
|
|
|
|
#endregion
|
|
|
|
#region Linear Static Property
|
|
|
|
public static PennerEquation Linear
|
|
{
|
|
get
|
|
{
|
|
if( _linear == null )
|
|
{
|
|
_linear = new PennerEquation( LinearImpl );
|
|
}
|
|
return _linear;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _linear;
|
|
|
|
#endregion
|
|
|
|
#region QuadEaseIn Static Property
|
|
|
|
public static PennerEquation QuadEaseIn
|
|
{
|
|
get
|
|
{
|
|
if( _quadEaseIn == null )
|
|
{
|
|
_quadEaseIn = new PennerEquation( QuadEaseInImpl );
|
|
}
|
|
return _quadEaseIn;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _quadEaseIn;
|
|
|
|
#endregion
|
|
|
|
#region QuadEaseInOut Static Property
|
|
|
|
public static PennerEquation QuadEaseInOut
|
|
{
|
|
get
|
|
{
|
|
if( _quadEaseInOut == null )
|
|
{
|
|
_quadEaseInOut = new PennerEquation( QuadEaseInOutImpl );
|
|
}
|
|
return _quadEaseInOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _quadEaseInOut;
|
|
|
|
#endregion
|
|
|
|
#region QuadEaseOut Static Property
|
|
|
|
public static PennerEquation QuadEaseOut
|
|
{
|
|
get
|
|
{
|
|
if( _quadEaseOut == null )
|
|
{
|
|
_quadEaseOut = new PennerEquation( QuadEaseOutImpl );
|
|
}
|
|
return _quadEaseOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _quadEaseOut;
|
|
|
|
#endregion
|
|
|
|
#region QuartEaseIn Static Property
|
|
|
|
public static PennerEquation QuartEaseIn
|
|
{
|
|
get
|
|
{
|
|
if( _quartEaseIn == null )
|
|
{
|
|
_quartEaseIn = new PennerEquation( QuartEaseInImpl );
|
|
}
|
|
return _quartEaseIn;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _quartEaseIn;
|
|
|
|
#endregion
|
|
|
|
#region QuartEaseInOut Static Property
|
|
|
|
public static PennerEquation QuartEaseInOut
|
|
{
|
|
get
|
|
{
|
|
if( _quartEaseInOut == null )
|
|
{
|
|
_quartEaseInOut = new PennerEquation( QuartEaseInOutImpl );
|
|
}
|
|
return _quartEaseInOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _quartEaseInOut;
|
|
|
|
#endregion
|
|
|
|
#region QuartEaseOut Static Property
|
|
|
|
public static PennerEquation QuartEaseOut
|
|
{
|
|
get
|
|
{
|
|
if( _quartEaseOut == null )
|
|
{
|
|
_quartEaseOut = new PennerEquation( QuartEaseOutImpl );
|
|
}
|
|
return _quartEaseOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _quartEaseOut;
|
|
|
|
#endregion
|
|
|
|
#region QuintEaseIn Static Property
|
|
|
|
public static PennerEquation QuintEaseIn
|
|
{
|
|
get
|
|
{
|
|
if( _quintEaseIn == null )
|
|
{
|
|
_quintEaseIn = new PennerEquation( QuintEaseInImpl );
|
|
}
|
|
return _quintEaseIn;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _quintEaseIn;
|
|
|
|
#endregion
|
|
|
|
#region QuintEaseInOut Static Property
|
|
|
|
public static PennerEquation QuintEaseInOut
|
|
{
|
|
get
|
|
{
|
|
if( _quintEaseInOut == null )
|
|
{
|
|
_quintEaseInOut = new PennerEquation( QuintEaseInOutImpl );
|
|
}
|
|
return _quintEaseInOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _quintEaseInOut;
|
|
|
|
#endregion
|
|
|
|
#region QuintEaseOut Static Property
|
|
|
|
public static PennerEquation QuintEaseOut
|
|
{
|
|
get
|
|
{
|
|
if( _quintEaseOut == null )
|
|
{
|
|
_quintEaseOut = new PennerEquation( QuintEaseOutImpl );
|
|
}
|
|
return _quintEaseOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _quintEaseOut;
|
|
|
|
#endregion
|
|
|
|
#region SineEaseIn Static Property
|
|
|
|
public static PennerEquation SineEaseIn
|
|
{
|
|
get
|
|
{
|
|
if( _sineEaseIn == null )
|
|
{
|
|
_sineEaseIn = new PennerEquation( SineEaseInImpl );
|
|
}
|
|
return _sineEaseIn;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _sineEaseIn;
|
|
|
|
#endregion
|
|
|
|
#region SineEaseInOut Static Property
|
|
|
|
public static PennerEquation SineEaseInOut
|
|
{
|
|
get
|
|
{
|
|
if( _sineEaseInOut == null )
|
|
{
|
|
_sineEaseInOut = new PennerEquation( SineEaseInOutImpl );
|
|
}
|
|
return _sineEaseInOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _sineEaseInOut;
|
|
|
|
#endregion
|
|
|
|
#region SineEaseOut Static Property
|
|
|
|
public static PennerEquation SineEaseOut
|
|
{
|
|
get
|
|
{
|
|
if( _sineEaseOut == null )
|
|
{
|
|
_sineEaseOut = new PennerEquation( SineEaseOutImpl );
|
|
}
|
|
return _sineEaseOut;
|
|
}
|
|
}
|
|
|
|
private static PennerEquation _sineEaseOut;
|
|
|
|
#endregion
|
|
|
|
#region Back Equations Methods
|
|
|
|
private static double BackEaseOutImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * ( ( t = t / d - 1 ) * t * ( ( 1.70158 + 1 ) * t + 1.70158 ) + 1 ) + b;
|
|
}
|
|
|
|
private static double BackEaseInImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * ( t /= d ) * t * ( ( 1.70158 + 1 ) * t - 1.70158 ) + b;
|
|
}
|
|
|
|
private static double BackEaseInOutImpl( double t, double b, double c, double d )
|
|
{
|
|
double s = 1.70158;
|
|
if( ( t /= d / 2 ) < 1 )
|
|
return c / 2 * ( t * t * ( ( ( s *= ( 1.525 ) ) + 1 ) * t - s ) ) + b;
|
|
return c / 2 * ( ( t -= 2 ) * t * ( ( ( s *= ( 1.525 ) ) + 1 ) * t + s ) + 2 ) + b;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Bounce Equations Methods
|
|
|
|
private static double BounceEaseOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( ( t /= d ) < ( 1 / 2.75 ) )
|
|
{
|
|
return c * ( 7.5625 * t * t ) + b;
|
|
}
|
|
else if( t < ( 2 / 2.75 ) )
|
|
{
|
|
return c * ( 7.5625 * ( t -= ( 1.5 / 2.75 ) ) * t + .75 ) + b;
|
|
}
|
|
else if( t < ( 2.5 / 2.75 ) )
|
|
{
|
|
return c * ( 7.5625 * ( t -= ( 2.25 / 2.75 ) ) * t + .9375 ) + b;
|
|
}
|
|
else
|
|
{
|
|
return c * ( 7.5625 * ( t -= ( 2.625 / 2.75 ) ) * t + .984375 ) + b;
|
|
}
|
|
}
|
|
|
|
private static double BounceEaseInImpl( double t, double b, double c, double d )
|
|
{
|
|
return c - PennerEquations.BounceEaseOutImpl( d - t, 0, c, d ) + b;
|
|
}
|
|
|
|
private static double BounceEaseInOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( t < d / 2 )
|
|
{
|
|
return PennerEquations.BounceEaseInImpl( t * 2, 0, c, d ) * .5 + b;
|
|
}
|
|
else
|
|
{
|
|
return PennerEquations.BounceEaseOutImpl( t * 2 - d, 0, c, d ) * .5 + c * .5 + b;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Circular Equations Methods
|
|
|
|
private static double CircEaseOutImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * Math.Sqrt( 1 - ( t = t / d - 1 ) * t ) + b;
|
|
}
|
|
|
|
private static double CircEaseInImpl( double t, double b, double c, double d )
|
|
{
|
|
return -c * ( Math.Sqrt( 1 - ( t /= d ) * t ) - 1 ) + b;
|
|
}
|
|
|
|
private static double CircEaseInOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( ( t /= d / 2 ) < 1 )
|
|
return -c / 2 * ( Math.Sqrt( 1 - t * t ) - 1 ) + b;
|
|
|
|
return c / 2 * ( Math.Sqrt( 1 - ( t -= 2 ) * t ) + 1 ) + b;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Cubic Equations Methods
|
|
|
|
private static double CubicEaseOutImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * ( ( t = t / d - 1 ) * t * t + 1 ) + b;
|
|
}
|
|
|
|
private static double CubicEaseInImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * ( t /= d ) * t * t + b;
|
|
}
|
|
|
|
private static double CubicEaseInOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( ( t /= d / 2 ) < 1 )
|
|
return c / 2 * t * t * t + b;
|
|
|
|
return c / 2 * ( ( t -= 2 ) * t * t + 2 ) + b;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Elastic Equations Methods
|
|
|
|
private static double ElasticEaseOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( ( t /= d ) == 1 )
|
|
return b + c;
|
|
|
|
double p = d * .3;
|
|
double s = p / 4;
|
|
|
|
return ( c * Math.Pow( 2, -10 * t ) * Math.Sin( ( t * d - s ) * ( 2 * Math.PI ) / p ) + c + b );
|
|
}
|
|
|
|
private static double ElasticEaseInImpl( double t, double b, double c, double d )
|
|
{
|
|
if( ( t /= d ) == 1 )
|
|
return b + c;
|
|
|
|
double p = d * .3;
|
|
double s = p / 4;
|
|
|
|
return -( c * Math.Pow( 2, 10 * ( t -= 1 ) ) * Math.Sin( ( t * d - s ) * ( 2 * Math.PI ) / p ) ) + b;
|
|
}
|
|
|
|
private static double ElasticEaseInOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( ( t /= d / 2 ) == 2 )
|
|
return b + c;
|
|
|
|
double p = d * ( .3 * 1.5 );
|
|
double s = p / 4;
|
|
|
|
if( t < 1 )
|
|
return -.5 * ( c * Math.Pow( 2, 10 * ( t -= 1 ) ) * Math.Sin( ( t * d - s ) * ( 2 * Math.PI ) / p ) ) + b;
|
|
return c * Math.Pow( 2, -10 * ( t -= 1 ) ) * Math.Sin( ( t * d - s ) * ( 2 * Math.PI ) / p ) * .5 + c + b;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Expo Equations Methods
|
|
|
|
private static double ExpoEaseOutImpl( double t, double b, double c, double d )
|
|
{
|
|
return ( t == d ) ? b + c : c * ( -Math.Pow( 2, -10 * t / d ) + 1 ) + b;
|
|
}
|
|
|
|
private static double ExpoEaseInImpl( double t, double b, double c, double d )
|
|
{
|
|
return ( t == 0 ) ? b : c * Math.Pow( 2, 10 * ( t / d - 1 ) ) + b;
|
|
}
|
|
|
|
private static double ExpoEaseInOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( t == 0 )
|
|
return b;
|
|
|
|
if( t == d )
|
|
return b + c;
|
|
|
|
if( ( t /= d / 2 ) < 1 )
|
|
return c / 2 * Math.Pow( 2, 10 * ( t - 1 ) ) + b;
|
|
|
|
return c / 2 * ( -Math.Pow( 2, -10 * --t ) + 2 ) + b;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Linear Equations Methods
|
|
|
|
private static double LinearImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * ( t / d ) + b;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Quad Equations Methods
|
|
|
|
private static double QuadEaseOutImpl( double t, double b, double c, double d )
|
|
{
|
|
return -c * ( t /= d ) * ( t - 2 ) + b;
|
|
}
|
|
|
|
private static double QuadEaseInImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * ( t /= d ) * t + b;
|
|
}
|
|
|
|
private static double QuadEaseInOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( ( t /= d / 2 ) < 1 )
|
|
return c / 2 * t * t + b;
|
|
|
|
return -c / 2 * ( ( --t ) * ( t - 2 ) - 1 ) + b;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Quartic Equations Methods
|
|
|
|
private static double QuartEaseOutImpl( double t, double b, double c, double d )
|
|
{
|
|
return -c * ( ( t = t / d - 1 ) * t * t * t - 1 ) + b;
|
|
}
|
|
|
|
private static double QuartEaseInImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * ( t /= d ) * t * t * t + b;
|
|
}
|
|
|
|
private static double QuartEaseInOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( ( t /= d / 2 ) < 1 )
|
|
return c / 2 * t * t * t * t + b;
|
|
|
|
return -c / 2 * ( ( t -= 2 ) * t * t * t - 2 ) + b;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Quintic Equations Methods
|
|
|
|
private static double QuintEaseOutImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * ( ( t = t / d - 1 ) * t * t * t * t + 1 ) + b;
|
|
}
|
|
|
|
private static double QuintEaseInImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * ( t /= d ) * t * t * t * t + b;
|
|
}
|
|
|
|
private static double QuintEaseInOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( ( t /= d / 2 ) < 1 )
|
|
return c / 2 * t * t * t * t * t + b;
|
|
return c / 2 * ( ( t -= 2 ) * t * t * t * t + 2 ) + b;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Sine Equations Methods
|
|
|
|
private static double SineEaseOutImpl( double t, double b, double c, double d )
|
|
{
|
|
return c * Math.Sin( t / d * ( Math.PI / 2 ) ) + b;
|
|
}
|
|
|
|
private static double SineEaseInImpl( double t, double b, double c, double d )
|
|
{
|
|
return -c * Math.Cos( t / d * ( Math.PI / 2 ) ) + c + b;
|
|
}
|
|
|
|
private static double SineEaseInOutImpl( double t, double b, double c, double d )
|
|
{
|
|
if( ( t /= d / 2 ) < 1 )
|
|
return c / 2 * ( Math.Sin( Math.PI * t / 2 ) ) + b;
|
|
|
|
return -c / 2 * ( Math.Cos( Math.PI * --t / 2 ) - 2 ) + b;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|