Easing Class Reference

Input value between 0 and 1, returns value adjusted by easing, no automatic clamping of input(do your own !!) More...

Static Private Member Functions
static float	EaseInSine (float t)
static float	EaseOutSine (float t)
static float	EaseInOutSine (float t)
static float	EaseInQuad (float t)
static float	EaseOutQuad (float t)
static float	EaseInOutQuad (float t)
static float	EaseInCubic (float t)
static float	EaseOutCubic (float t)
static float	EaseInOutCubic (float t)
static float	EaseInQuart (float t)
static float	EaseOutQuart (float t)
static float	EaseInOutQuart (float t)
static float	EaseInQuint (float t)
static float	EaseOutQuint (float t)
static float	EaseInOutQuint (float t)
static float	EaseInExpo (float t)
static float	EaseOutExpo (float t)
static float	EaseInOutExpo (float t)
static float	EaseInCirc (float t)
static float	EaseOutCirc (float t)
static float	EaseInOutCirc (float t)
static float	EaseInBack (float t, float magnitude=1.70158)
static float	EaseOutBack (float t, float magnitude=1.70158)
static float	EaseInOutBack (float t, float magnitude=1.70158)
static float	EaseInElastic (float t, float magnitude=0.7)
static float	EaseOutElastic (float t, float magnitude=0.7)
static float	EaseInOutElastic (float t, float magnitude=0.65)
static float	EaseOutBounce (float t)
static float	EaseInBounce (float t)
static float	EaseInOutBounce (float t)

Detailed Description

Input value between 0 and 1, returns value adjusted by easing, no automatic clamping of input(do your own !!)

Definition at line 2 of file Easing.c.

Member Function Documentation

EaseInBack()

static float Easing::EaseInBack ( float t, float magnitude = 1.70158 )

inlinestaticprivate

Definition at line 155 of file Easing.c.

  {
    return t * t * ((magnitude + 1) * t - magnitude);
  }

EaseInBounce()

static float Easing::EaseInBounce ( float t )

inlinestaticprivate

Definition at line 256 of file Easing.c.

  {
    return 1 - EaseOutBounce(1 - t);
  }

References EaseOutBounce().

Referenced by EaseInOutBounce().

EaseInCirc()

static float Easing::EaseInCirc ( float t )

inlinestaticprivate

Definition at line 131 of file Easing.c.

  {
    float scaledTime = t / 1;
    return -1 * (Math.Sqrt(1 - scaledTime * t) - 1);
  }

References Math::Sqrt().

Referenced by PoisoningMdfr::OnTick().

EaseInCubic()

static float Easing::EaseInCubic ( float t )

inlinestaticprivate

Definition at line 37 of file Easing.c.

  {
    return t * t * t;
  }

Referenced by PPERequester_GameplayBase::OnStart().

EaseInElastic()

static float Easing::EaseInElastic ( float t, float magnitude = 0.7 )

inlinestaticprivate

Definition at line 180 of file Easing.c.

  {
    if (t == 0 || t == 1)
      return t;
 
    float scaledTime = t / 1;
    float scaledTime1 = scaledTime - 1;
 
    float p = 1 - magnitude;
    float s = p / (2 * Math.PI) * Math.Asin(1);
 
    return -(Math.Pow(2, 10 * scaledTime1) * Math.Sin((scaledTime1 - s) * (2 * Math.PI) / p));
  }

References Math::Asin(), Math::PI, Math::Pow(), and Math::Sin().

EaseInExpo()

static float Easing::EaseInExpo ( float t )

inlinestaticprivate

Definition at line 99 of file Easing.c.

  {
    if (t == 0)
      return 0;
 
    return Math.Pow(2, 10 * (t - 1));
  }

References Math::Pow().

Referenced by PPERequester_GameplayBase::OnUpdate().

EaseInOutBack()

static float Easing::EaseInOutBack ( float t, float magnitude = 1.70158 )

inlinestaticprivate

Definition at line 166 of file Easing.c.

  {
 
    float scaledTime = t * 2;
    float scaledTime2 = scaledTime - 2;
 
    float s = magnitude * 1.525;
 
    if (scaledTime < 1)
      return 0.5 * scaledTime * scaledTime * (((s + 1) * scaledTime) - s);
 
    return 0.5 * (scaledTime2 * scaledTime2 * ((s + 1) * scaledTime2 + s) + 2);
  }

EaseInOutBounce()

static float Easing::EaseInOutBounce ( float t )

inlinestaticprivate

Definition at line 261 of file Easing.c.

  {
    if (t < 0.5)
      return EaseInBounce(t * 2) * 0.5;
    return (EaseOutBounce((t * 2) - 1) * 0.5) + 0.5;
  }

References EaseInBounce(), and EaseOutBounce().

EaseInOutCirc()

static float Easing::EaseInOutCirc ( float t )

inlinestaticprivate

Definition at line 143 of file Easing.c.

  {
 
    float scaledTime = t * 2;
    float scaledTime1 = scaledTime - 2;
 
    if (scaledTime < 1)
      return -0.5 * (Math.Sqrt(1 - scaledTime * scaledTime) - 1);
 
    return 0.5 * (Math.Sqrt(1 - scaledTime1 * scaledTime1) + 1);
  }

References Math::Sqrt().

EaseInOutCubic()

static float Easing::EaseInOutCubic ( float t )

inlinestaticprivate

Definition at line 48 of file Easing.c.

  {
    if (t < 0.5)
      return 4 * t * t * t;
    else
      return (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
  }

EaseInOutElastic()

static float Easing::EaseInOutElastic ( float t, float magnitude = 0.65 )

inlinestaticprivate

Definition at line 206 of file Easing.c.

  {
    float p = 1 - magnitude;
 
    if (t == 0 || t == 1)
      return t;
 
    float scaledTime = t * 2;
    float scaledTime1 = scaledTime - 1;
 
    float s = p / (2 * Math.PI) * Math.Asin(1);
 
    if (scaledTime < 1)
      return -0.5 * (Math.Pow(2, 10 * scaledTime1) * Math.Sin((scaledTime1 - s) * (2 * Math.PI) / p));
 
    return (Math.Pow(2, -10 * scaledTime1) * Math.Sin((scaledTime1 - s) * (2 * Math.PI) / p) * 0.5) + 1;
  }

References Math::Asin(), Math::PI, Math::Pow(), and Math::Sin().

EaseInOutExpo()

static float Easing::EaseInOutExpo ( float t )

inlinestaticprivate

Definition at line 115 of file Easing.c.

  {
 
    if (t == 0 || t == 1)
      return t;
 
    float scaledTime = t * 2;
    float scaledTime1 = scaledTime - 1;
 
    if (scaledTime < 1)
      return 0.5 * Math.Pow(2, 10 * scaledTime1);
 
    return 0.5 * (-Math.Pow(2, -10 * scaledTime1) + 2);
 
  }

References Math::Pow().

EaseInOutQuad()

static float Easing::EaseInOutQuad ( float t )

inlinestaticprivate

Definition at line 29 of file Easing.c.

  {
    if (t < 0.5)
      return 2 * t * t;
    else
      return -1 + (4 - 2 * t) * t;
  }

EaseInOutQuart()

static float Easing::EaseInOutQuart ( float t )

inlinestaticprivate

Definition at line 68 of file Easing.c.

  {
    float t1 = t - 1;
 
    if (t < 0.5)
      return 8 * t * t * t * t;
    else
      return 1 - 8 * t1 * t1 * t1 * t1;
  }

EaseInOutQuint()

static float Easing::EaseInOutQuint ( float t )

inlinestaticprivate

Definition at line 89 of file Easing.c.

  {
    float t1 = t - 1;
 
    if (t < 0.5)
      return 16 * t * t * t * t * t;
    else
      return 1 + 16 * t1 * t1 * t1 * t1 * t1;
  }

EaseInOutSine()

static float Easing::EaseInOutSine ( float t )

inlinestaticprivate

Definition at line 14 of file Easing.c.

  {
    return -0.5 * (Math.Cos(Math.PI * t) - 1);
  }

References Math::Cos(), and Math::PI.

Referenced by ApplyForce(), EOnPostSimulate(), and PPERequester_GameplayBase::FadeColourMult().

EaseInQuad()

static float Easing::EaseInQuad ( float t )

inlinestaticprivate

Definition at line 19 of file Easing.c.

  {
    return t * t;
  }

EaseInQuart()

static float Easing::EaseInQuart ( float t )

inlinestaticprivate

Definition at line 56 of file Easing.c.

  {
    return t * t * t * t;
  }

Referenced by PPERequester_GameplayBase::SetFlashbangIntensity(), ShockHandler::Update(), and Update().

EaseInQuint()

static float Easing::EaseInQuint ( float t )

inlinestaticprivate

Definition at line 78 of file Easing.c.

  {
    return t * t * t * t * t;
  }

Referenced by OnUpdateTimerIn(), and KuruShake::Update().

EaseInSine()

static float Easing::EaseInSine ( float t )

inlinestaticprivate

Definition at line 4 of file Easing.c.

  {
    return -1 * Math.Cos(t * (Math.PI / 2)) + 1;
  }

References Math::Cos(), and Math::PI.

EaseOutBack()

static float Easing::EaseOutBack ( float t, float magnitude = 1.70158 )

inlinestaticprivate

Definition at line 160 of file Easing.c.

  {
    float scaledTime = (t / 1) - 1;
    return (scaledTime * scaledTime * ((magnitude + 1) * scaledTime + magnitude)) + 1;
  }

Referenced by RecoilBase::ApplyCamOffset().

EaseOutBounce()

static float Easing::EaseOutBounce ( float t )

inlinestaticprivate

Definition at line 224 of file Easing.c.

  {
 
    float scaledTime = t / 1;
 
    if (scaledTime < (1 / 2.75))
 
      return 7.5625 * scaledTime * scaledTime;
 
    else if (scaledTime < (2 / 2.75))
    {
 
      float scaledTime2 = scaledTime - (1.5 / 2.75);
      return (7.5625 * scaledTime2 * scaledTime2) + 0.75;
 
    }
    else if (scaledTime < (2.5 / 2.75))
    {
 
      scaledTime2 = scaledTime - (2.25 / 2.75);
      return (7.5625 * scaledTime2 * scaledTime2) + 0.9375;
 
    }
    else
    {
 
      scaledTime2 = scaledTime - (2.625 / 2.75);
      return (7.5625 * scaledTime2 * scaledTime2) + 0.984375;
 
    }
  }

Referenced by EaseInBounce(), and EaseInOutBounce().

EaseOutCirc()

static float Easing::EaseOutCirc ( float t )

inlinestaticprivate

Definition at line 137 of file Easing.c.

  {
    float t1 = t - 1;
    return Math.Sqrt(1 - t1 * t1);
  }

References Math::Sqrt().

EaseOutCubic()

static float Easing::EaseOutCubic ( float t )

inlinestaticprivate

Definition at line 42 of file Easing.c.

  {
    float t1 = t - 1;
    return t1 * t1 * t1 + 1;
  }

Referenced by OnUpdateTimerOut().

EaseOutElastic()

static float Easing::EaseOutElastic ( float t, float magnitude = 0.7 )

inlinestaticprivate

Definition at line 194 of file Easing.c.

  {
    float p = 1 - magnitude;
    float scaledTime = t * 2;
 
    if (t == 0 || t == 1)
      return t;
 
    float s = p / (2 * Math.PI) * Math.Asin(1);
    return (Math.Pow(2, -10 * scaledTime) * Math.Sin((scaledTime - s) * (2 * Math.PI) / p)) + 1;
  }

References Math::Asin(), Math::PI, Math::Pow(), and Math::Sin().

EaseOutExpo()

static float Easing::EaseOutExpo ( float t )

inlinestaticprivate

Definition at line 107 of file Easing.c.

  {
    if (t == 1)
      return 1;
 
    return (-Math.Pow(2, -10 * t) + 1);
  }

References Math::Pow().

EaseOutQuad()

static float Easing::EaseOutQuad ( float t )

inlinestaticprivate

Definition at line 24 of file Easing.c.

  {
    return t * (2 - t);
  }

EaseOutQuart()

static float Easing::EaseOutQuart ( float t )

inlinestaticprivate

Definition at line 61 of file Easing.c.

  {
    float t1 = t - 1;
    return 1 - t1 * t1 * t1 * t1;
  }

EaseOutQuint()

static float Easing::EaseOutQuint ( float t )

inlinestaticprivate

Definition at line 83 of file Easing.c.

  {
    float t1 = t - 1;
    return 1 + t1 * t1 * t1 * t1 * t1;
  }

EaseOutSine()

static float Easing::EaseOutSine ( float t )

inlinestaticprivate

Definition at line 9 of file Easing.c.

  {
    return Math.Sin(t * (Math.PI / 2));
  }

References Math::PI, and Math::Sin().

Referenced by BleedingIndicatorDropData::AdjustColorSaturation(), and PPEMatClassParameterColor::ModifyResultValues().

---

The documentation for this class was generated from the following file:

• scripts/3_Game/Static/Easing.c