rayeasings.nelua

require 'math'

global rle = @record{}

--[[
  
 *   How to use:
 *   The four inputs t,b,c,d are defined as follows:
 *   t = current time (in any unit measure, but same unit as duration)
 *   b = starting value to interpolate
 *   c = the total change in value of b that needs to occur
 *   d = total time it should take to complete (duration)
 
]]

--[[ Linear Easing functions ]]

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.linearNone(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  return c*t/d + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.linearIn(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  return c*t/d + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.linearOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  return c*t/d + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.linearInOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  return c*t/d + b
end

--[[ Sine Easing functions ]]

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.sineIn(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  return -c*math.cos(t/d*(math.pi/2)) + c + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.sineOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  return c*math.sin(t/d*(math.pi/2)) + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.sineInOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  return -c/2*(math.cos(math.pi*t/d) - 1) + b
end

--[[ Circular Easing functions ]]

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.circIn(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  t = t / d 
  return -c*(math.sqrt(1 - t*t) - 1) + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.circOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  t = t/d - 1 
  return (c*math.sqrt(1 - t*t) + b)
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.circInOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  t = t / d * 2
  if t < 1 then
    return -c/2*(math.sqrt(1 - t*t) - 1) + b
  end

  t = t - 2
  return c/2*(math.sqrt(1 - t*t) + 1) + b
end

--[[ Cubic Easing functions ]]

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.cubicIn(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  t = t / d 
  return c*t*t*t + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.cubicOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  t = t/d - 1
  return c*(t*t*t + 1) + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.cubicInOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  t = t / d * 2
  if t < 1 then
    return (c/2*t*t*t + b)
  end
  
  t = t - 2
  return c/2*(t*t*t + 2) + b
end

--[[ Quadratic Easing functions ]]

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.quadIn(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  t = t / d 
  return c*t*t + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.quadOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  t = t / d 
  return (-c*t*(t - 2) + b)
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.quadInOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  t = t / d * 2
  if t < 1 then
    return ((c / 2) * (t * t)) + b
  end

  return -c/2*((t-1)*(t-3)-1) + b
end

--[[ Exponential Easing functions ]]

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.expoIn(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  if t == 0 then
    return b
  else 
    return c * math.pow(2, 10 * (t/d - 1)) + b
  end
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.expoOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  if t == d then
    return (b + c)
  else
    return c*(-math.pow(2, -10*t/d) + 1) + b
  end
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.expoInOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  if t == 0 then return b end
  if t == d then return (b + c) end

  t = t / d * 2
  
  if t < 1 then return (c/2*math.pow(2, 10*(t - 1)) + b) end
  
  t = t - 1
  return (c/2*(-math.pow(2, -10*(t)) + 2) + b)
end

--[[ Back Easing functions ]]

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.backIn(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  local s: float32 = 1.70158
  local postFix: float32 = t / d
  
  return c*(postFix)*t*((s + 1.0)*t - s) + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.backOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  local s: float32 = 1.70158
  t = t / d - 1
  return c*(t*t*((s + 1)*t + s) + 1) + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.backInOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  local s: float32 = 1.70158
  s = s * 1.525
  t = t / d * 2
  
  if t < 1 then
    return c/2*(t*t*((s + 1)*t-s)) + b
  end

  t = t - 2
  return c/2*(t*t*((s + 1)*t+s)+2) + b
end

--[[ Bounce Easing functions ]]

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.bounceOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  t = t / d

  if t < (1/2.75) then
   return (c*(7.5625*t*t) + b)
   
  elseif t < (2/2.75) then
    t = t - (1.5/2.75)
    return c*(7.5625*t*t + 0.75) + b
    
  elseif t < (2.5/2.75) then
    
    t = t - (2.25 / 2.75)
		return c*(7.5625*t*t + 0.9375) + b
	end

	t = t - (2.625 / 2.75)
	return c*(7.5625*t*t+0.984375) + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.bounceIn(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  return (c - rle.bounceOut(d - t, 0, c, d) + b)
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.bounceInOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  if t < d / 2 then 
    return rle.bounceIn(t*2, 0, c, d)*0.5 + b
  else
    return rle.bounceOut(t*2 - d, 0, c, d)*0.5 + c*0.5 + b
  end
end

--[[ Elastic Easing functions ]]

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.elasticIn(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  if t == 0 then return b end
  t = t / d
  if t == 1 then return (b + c) end

  local p: float32 = d * 0.3
  local a: float32 = c
  local s: float32 = p/4
  local postFix: float32 = a * math.pow(2, 10*(t - 1))

  return -(postFix*math.sin((t*d-s)*(2.0*math.pi)/p)) + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.elasticOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  if t == 0 then return b end
  t = t / d
  if t == 1 then return b + c end

  local p: float32 = d * 0.3
  local a: float32 = c
  local s: float32 = p/4
  local postFix: float32 = a * math.pow(2, 10*(t - 1))

  return a*math.pow(2,-10*t)*math.sin((t*d-s)*(2*math.pi)/p) + c + b
end

-- t: current time, b: begInnIng value, c: change In value, d: duration
function rle.elasticInOut(t: float32, b: float32, c: float32, d: float32): float32 <inline>
  if t == 0 then return b end
  t = t / d * 2
  if t == 2 then return b + c end

  local p: float32 = d * (0.3 * 1.5)
  local a: float32 = c
  local s: float32 = p/4

  if t < 1 then
    t = t - 1
    local postFix: float32 = a * math.pow(2, 10*t)
    return -0.5*(postFix*math.sin((t*d-s)*(2*math.pi)/p)) + b
  end

  t = t - 1
  local postFix: float32 = a * math.pow(2, 10*t)
  return (postFix*math.sin((t*d-s)*(2*math.pi)/p)*0.5 + c + b)
end