// BLANKART
//-----------------------------------------------------------------------------
// Copyright (C) 2020-2021 by Jaime "Lactozilla" Passos.
//
// This program is free software distributed under the
// terms of the GNU General Public License, version 2.
// See the 'LICENSE' file for more details.
//-----------------------------------------------------------------------------
/// \file  m_easing.c
/// \brief Easing functions
///        Referenced from https://easings.net/

#include "m_easing.h"
#include "tables.h"
#include "doomdef.h"

/*
	For the computation of the logarithm, we choose, by trial and error, from among
	a sequence of particular factors those, that when multiplied with the function
	argument, normalize it to unity. For every factor chosen, we add up the
	corresponding logarithm value stored in a table. The sum then corresponds to
	the logarithm of the function argument.

	For the integer portion, we would want to choose
		2^i, i = 1, 2, 4, 8, ...
	and for the factional part we choose
		1+2^-i, i = 1, 2, 3, 4, 5 ...

	The algorithm for the exponential is closely related and quite literally the inverse
	of the logarithm algorithm. From among the sequence of tabulated logarithms for our
	chosen factors, we pick those that when subtracted from the function argument ultimately
	reduce it to zero. Starting with unity, we multiply with all the factors whose logarithms
	we have subtracted in the process. The resulting product corresponds to the result of the exponentiation.

	Logarithms of values greater than unity can be computed by applying the algorithm to the reciprocal
	of the function argument (with the negation of the result as appropriate), likewise exponentiation with
	negative function arguments requires us negate the function argument and compute the reciprocal at the end.
*/

static fixed_t logtabdec[FRACBITS] =
{
	0x95c1, 0x526a, 0x2b80, 0x1663,
	0xb5d, 0x5b9, 0x2e0, 0x170,
	0xb8, 0x5c, 0x2e, 0x17,
	0x0b, 0x06, 0x03, 0x01
};

static fixed_t fixlog2(fixed_t a)
{
	UINT32 x = a, y = 0;
	INT32 t, i, shift = 8;

	if (x > FRACUNIT)
		x = FixedDiv(FRACUNIT, x);

	// Integer part
	//   1<<19 = 0x80000
	//   1<<18 = 0x40000
	//   1<<17 = 0x20000
	//   1<<16 = 0x10000

#define dologtab(i) \
	t = (x << shift); \
	if (t < FRACUNIT) \
	{ \
		x = t; \
		y += (1 << (19 - i)); \
	} \
	shift /= 2;

	dologtab(0)
	dologtab(1)
	dologtab(2)
	dologtab(3)

#undef dologtab

	// Decimal part
	for (i = 0; i < FRACBITS; i++)
	{
		t = x + (x >> (i + 1));
		if (t < FRACUNIT)
		{
			x = t;
			y += logtabdec[i];
		}
	}

	if (a <= FRACUNIT)
		return -y;

	return y;
}

// Notice how this is symmetric to fixlog2.
static INT32 fixexp(fixed_t a)
{
	UINT32 x, y;
	fixed_t t, i, shift = 8;

	// Underflow prevention.
	if (a <= -15 * FRACUNIT)
		return 0;

	x = (a < 0) ? (-a) : (a);
	y = FRACUNIT;

	// Integer part (see fixlog2)
#define dologtab(i) \
	t = x - (1 << (19 - i)); \
	if (t >= 0) \
	{ \
		x = t; \
		y <<= shift; \
	} \
	shift /= 2;

	dologtab(0)
	dologtab(1)
	dologtab(2)
	dologtab(3)

#undef dologtab

	// Decimal part
	for (i = 0; i < FRACBITS; i++)
	{
		t = (x - logtabdec[i]);
		if (t >= 0)
		{
			x = t;
			y += (y >> (i + 1));
		}
	}

	if (a < 0)
		return FixedDiv(FRACUNIT, y);

	return y;
}

#define fixpow(x, y) fixexp(FixedMul((y), fixlog2(x)))
#define fixintmul(x, y) FixedMul((x) * FRACUNIT, y)
#define fixintdiv(x, y) FixedDiv(x, (y) * FRACUNIT)
#define fixinterp(start, end, t) FixedMul((FRACUNIT - (t)), start) + FixedMul(t, end)

// ==================
//  EASING FUNCTIONS
// ==================

#define EASINGFUNC(type) fixed_t Easing_ ## type (fixed_t t, fixed_t start, fixed_t end)

//
// Linear
//

EASINGFUNC(Linear)
{
	return fixinterp(start, end, t);
}

//
// Sine
//

// This is equivalent to calculating (x * pi) and converting the result from radians into degrees.
#define fixang(x) FixedMul((x), 180*FRACUNIT)

EASINGFUNC(InSine)
{
	fixed_t c = fixang(t / 2);
	fixed_t x = FRACUNIT - FINECOSINE(FixedAngle(c)>>ANGLETOFINESHIFT);
	return fixinterp(start, end, x);
}

EASINGFUNC(OutSine)
{
	fixed_t c = fixang(t / 2);
	fixed_t x = FINESINE(FixedAngle(c)>>ANGLETOFINESHIFT);
	return fixinterp(start, end, x);
}

EASINGFUNC(InOutSine)
{
	fixed_t c = fixang(t);
	fixed_t x = -(FINECOSINE(FixedAngle(c)>>ANGLETOFINESHIFT) - FRACUNIT) / 2;
	return fixinterp(start, end, x);
}

#undef fixang

//
// Quad
//

EASINGFUNC(InQuad)
{
	return fixinterp(start, end, FixedMul(t, t));
}

EASINGFUNC(OutQuad)
{
	return fixinterp(start, end, FRACUNIT - FixedMul(FRACUNIT - t, FRACUNIT - t));
}

EASINGFUNC(InOutQuad)
{
	fixed_t x = t < (FRACUNIT/2)
	? fixintmul(2, FixedMul(t, t))
	: FRACUNIT - fixpow(FixedMul(-2*FRACUNIT, t) + 2*FRACUNIT, 2*FRACUNIT) / 2;
	return fixinterp(start, end, x);
}

//
// Cubic
//

EASINGFUNC(InCubic)
{
	fixed_t x = FixedMul(t, FixedMul(t, t));
	return fixinterp(start, end, x);
}

EASINGFUNC(OutCubic)
{
	return fixinterp(start, end, FRACUNIT - fixpow(FRACUNIT - t, 3*FRACUNIT));
}

EASINGFUNC(InOutCubic)
{
	fixed_t x = t < (FRACUNIT/2)
	? fixintmul(4, FixedMul(t, FixedMul(t, t)))
	: FRACUNIT - fixpow(fixintmul(-2, t) + 2*FRACUNIT, 3*FRACUNIT) / 2;
	return fixinterp(start, end, x);
}

//
// "Quart"
//

EASINGFUNC(InQuart)
{
	fixed_t x = FixedMul(FixedMul(t, t), FixedMul(t, t));
	return fixinterp(start, end, x);
}

EASINGFUNC(OutQuart)
{
	fixed_t x = FRACUNIT - fixpow(FRACUNIT - t, 4 * FRACUNIT);
	return fixinterp(start, end, x);
}

EASINGFUNC(InOutQuart)
{
	fixed_t x = t < (FRACUNIT/2)
	? fixintmul(8, FixedMul(FixedMul(t, t), FixedMul(t, t)))
	: FRACUNIT - fixpow(fixintmul(-2, t) + 2*FRACUNIT, 4*FRACUNIT) / 2;
	return fixinterp(start, end, x);
}

//
// "Quint"
//

EASINGFUNC(InQuint)
{
	fixed_t x = FixedMul(t, FixedMul(FixedMul(t, t), FixedMul(t, t)));
	return fixinterp(start, end, x);
}

EASINGFUNC(OutQuint)
{
	fixed_t x = FRACUNIT - fixpow(FRACUNIT - t, 5 * FRACUNIT);
	return fixinterp(start, end, x);
}

EASINGFUNC(InOutQuint)
{
	fixed_t x = t < (FRACUNIT/2)
	? FixedMul(16*FRACUNIT, FixedMul(t, FixedMul(FixedMul(t, t), FixedMul(t, t))))
	: FRACUNIT - fixpow(fixintmul(-2, t) + 2*FRACUNIT, 5*FRACUNIT) / 2;
	return fixinterp(start, end, x);
}

//
// Exponential
//

EASINGFUNC(InExpo)
{
	fixed_t x = (!t) ? 0 : fixpow(2*FRACUNIT, fixintmul(10, t) - 10*FRACUNIT);
	return fixinterp(start, end, x);
}

EASINGFUNC(OutExpo)
{
	fixed_t x = (t >= FRACUNIT) ? FRACUNIT
	: FRACUNIT - fixpow(2*FRACUNIT, fixintmul(-10, t));
	return fixinterp(start, end, x);
}

EASINGFUNC(InOutExpo)
{
	fixed_t x;

	if (!t)
		x = 0;
	else if (t >= FRACUNIT)
		x = FRACUNIT;
	else
	{
		if (t < FRACUNIT / 2)
		{
			x = fixpow(2*FRACUNIT, fixintmul(20, t) - 10*FRACUNIT);
			x = fixintdiv(x, 2);
		}
		else
		{
			x = fixpow(2*FRACUNIT, fixintmul(-20, t) + 10*FRACUNIT);
			x = fixintdiv((2*FRACUNIT) - x, 2);
		}
	}

	return fixinterp(start, end, x);
}

//
// "Back"
//

#define EASEBACKCONST1 111514 // 1.70158
#define EASEBACKCONST2 99942 // 1.525

static fixed_t EaseInBack(fixed_t t, fixed_t start, fixed_t end, fixed_t c1)
{
	const fixed_t c3 = c1 + FRACUNIT;
	fixed_t x = FixedMul(FixedMul(t, t), FixedMul(c3, t) - c1);
	return fixinterp(start, end, x);
}

EASINGFUNC(InBack)
{
	return EaseInBack(t, start, end, EASEBACKCONST1);
}

static fixed_t EaseOutBack(fixed_t t, fixed_t start, fixed_t end, fixed_t c1)
{
	const fixed_t c3 = c1 + FRACUNIT;
	fixed_t x;
	t -= FRACUNIT;
	x = FRACUNIT + FixedMul(FixedMul(t, t), FixedMul(c3, t) + c1);
	return fixinterp(start, end, x);
}

EASINGFUNC(OutBack)
{
	return EaseOutBack(t, start, end, EASEBACKCONST1);
}

static fixed_t EaseInOutBack(fixed_t t, fixed_t start, fixed_t end, fixed_t c2)
{
	fixed_t x, y;
	const fixed_t f2 = 2*FRACUNIT;

	if (t < FRACUNIT / 2)
	{
		x = fixpow(FixedMul(t, f2), f2);
		y = FixedMul(c2 + FRACUNIT, FixedMul(t, f2));
		x = FixedMul(x, y - c2);
	}
	else
	{
		x = fixpow(-(FixedMul(t, f2) - f2), f2);
		y = FixedMul(c2 + FRACUNIT, FixedMul(t, f2) - f2);
		x = FixedMul(x, y + c2);
		x += f2;
	}

	x /= 2;

	return fixinterp(start, end, x);
}

EASINGFUNC(InOutBack)
{
	return EaseInOutBack(t, start, end, EASEBACKCONST2);
}

#undef EASINGFUNC
#define EASINGFUNC(type) fixed_t Easing_ ## type (fixed_t t, fixed_t start, fixed_t end, fixed_t param)

EASINGFUNC(InBackParameterized)
{
	return EaseInBack(t, start, end, param);
}

EASINGFUNC(OutBackParameterized)
{
	return EaseOutBack(t, start, end, param);
}

EASINGFUNC(InOutBackParameterized)
{
	return EaseInOutBack(t, start, end, param);
}

#undef EASINGFUNC

// Function list

#define EASINGFUNC(type) Easing_ ## type
#define COMMA ,

easingfunc_t easing_funclist[EASE_MAX] =
{
	EASINGFUNCLIST(COMMA)
};

// Function names

#undef EASINGFUNC
#define EASINGFUNC(type) #type

const char *easing_funcnames[EASE_MAX] =
{
	EASINGFUNCLIST(COMMA)
};

#undef COMMA
#undef EASINGFUNC
