_tween.h

#pragma once
#include "_math.h"
 
namespace njin {

struct timer {
  f32 duration = 1.0f; 
  bool repeat = false; 
  f32 time = 0.0f;     
  bool finished = false; 

  bool tick(f32 dt) {
    if (finished || duration <= 0.0f)
      return false;
    time += dt;
    if (time < duration)
      return false;
    if (repeat) {
      while (time >= duration)
        time -= duration;
    } else {
      time = duration;
      finished = true;
    }
    return true;
  }

  f32 progress() const {
    return duration > 0.0f ? clamp(time / duration, 0.0f, 1.0f) : 1.0f;
  }

  void reset() {
    time = 0.0f;
    finished = false;
  }
};

enum class ease {
  linear,       
  in_quad,      
  out_quad,     
  in_out_quad,  
  in_cubic,     
  out_cubic,    
  in_out_cubic, 
  in_sine,      
  out_sine,     
  in_out_sine,  
  in_back,      
  out_back,     
  out_bounce,   
  out_elastic,  
};

inline f32 ease_apply(ease curve, f32 t) {
  t = clamp(t, 0.0f, 1.0f);
  switch (curve) {
  case ease::linear:
    return t;
  case ease::in_quad:
    return t * t;
  case ease::out_quad:
    return t * (2.0f - t);
  case ease::in_out_quad:
    return t < 0.5f ? 2.0f * t * t : 1.0f - 2.0f * (1.0f - t) * (1.0f - t);
  case ease::in_cubic:
    return t * t * t;
  case ease::out_cubic: {
    const f32 u = 1.0f - t;
    return 1.0f - u * u * u;
  }
  case ease::in_out_cubic: {
    const f32 u = 1.0f - t;
    return t < 0.5f ? 4.0f * t * t * t : 1.0f - 4.0f * u * u * u;
  }
  case ease::in_sine:
    return 1.0f - std::cos(t * pi * 0.5f);
  case ease::out_sine:
    return std::sin(t * pi * 0.5f);
  case ease::in_out_sine:
    return 0.5f - 0.5f * std::cos(t * pi);
  case ease::in_back: {
    const f32 s = 1.70158f;
    return t * t * ((s + 1.0f) * t - s);
  }
  case ease::out_back: {
    const f32 s = 1.70158f;
    const f32 u = t - 1.0f;
    return 1.0f + u * u * ((s + 1.0f) * u + s);
  }
  case ease::out_bounce: {
    const f32 n = 7.5625f;
    const f32 d = 2.75f;
    if (t < 1.0f / d)
      return n * t * t;
    if (t < 2.0f / d) {
      t -= 1.5f / d;
      return n * t * t + 0.75f;
    }
    if (t < 2.5f / d) {
      t -= 2.25f / d;
      return n * t * t + 0.9375f;
    }
    t -= 2.625f / d;
    return n * t * t + 0.984375f;
  }
  case ease::out_elastic:
    if (t <= 0.0f || t >= 1.0f)
      return t;
    return std::pow(2.0f, -10.0f * t) *
               std::sin((t * 10.0f - 0.75f) * (2.0f * pi / 3.0f)) +
           1.0f;
  }
  return t;
}

template <class T> struct tween {
  T from{};                  
  T to{};                    
  f32 duration = 1.0f;       
  ease curve = ease::linear; 
  f32 time = 0.0f;           

  T value() const {
    const f32 t = duration > 0.0f ? time / duration : 1.0f;
    return lerp(from, to, ease_apply(curve, t));
  }

  T tick(f32 dt) {
    time = time + dt > duration ? duration : time + dt;
    return value();
  }

  bool done() const { return time >= duration; }

  void reset() { time = 0.0f; }
};

} // namespace njin