mirror of
https://git.do.srb2.org/STJr/SRB2.git
synced 2025-01-22 09:11:21 +00:00
Easing functions
This commit is contained in:
Jaime Ita Passos
parent
bcd3245b76
commit
b026a6991c
4 changed files with 497 additions and 0 deletions
|
|
@ -32,6 +32,7 @@ set(SRB2_CORE_SOURCES
|
|||
m_bbox.c
|
||||
m_cheat.c
|
||||
m_cond.c
|
||||
m_easing.c
|
||||
m_fixed.c
|
||||
m_menu.c
|
||||
m_misc.c
|
||||
|
|
@ -101,6 +102,7 @@ set(SRB2_CORE_HEADERS
|
|||
m_cheat.h
|
||||
m_cond.h
|
||||
m_dllist.h
|
||||
m_easing.h
|
||||
m_fixed.h
|
||||
m_menu.h
|
||||
m_misc.h
|
||||
|
|
|
|||
|
|
@ -503,6 +503,7 @@ OBJS:=$(i_main_o) \
|
|||
$(OBJDIR)/m_bbox.o \
|
||||
$(OBJDIR)/m_cheat.o \
|
||||
$(OBJDIR)/m_cond.o \
|
||||
$(OBJDIR)/m_easing.o \
|
||||
$(OBJDIR)/m_fixed.o \
|
||||
$(OBJDIR)/m_menu.o \
|
||||
$(OBJDIR)/m_misc.o \
|
||||
|
|
|
|||
399
src/m_easing.c
Normal file
399
src/m_easing.c
Normal file
|
|
@ -0,0 +1,399 @@
|
|||
// SONIC ROBO BLAST 2
|
||||
//-----------------------------------------------------------------------------
|
||||
// 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)
|
||||
|
||||
#define EASINGFUNC(type) fixed_t Easing_ ## type (fixed_t start, fixed_t end, fixed_t t)
|
||||
|
||||
//
|
||||
// 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
|
||||
|
||||
EASINGFUNC(InBack)
|
||||
{
|
||||
const fixed_t c1 = EASEBACKCONST1;
|
||||
const fixed_t c3 = c1 + FRACUNIT;
|
||||
fixed_t x = FixedMul(FixedMul(t, t), FixedMul(c3, t) - c1);
|
||||
return fixinterp(start, end, x);
|
||||
}
|
||||
|
||||
EASINGFUNC(OutBack)
|
||||
{
|
||||
const fixed_t c1 = EASEBACKCONST1;
|
||||
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);
|
||||
}
|
||||
|
||||
static fixed_t DoEaseInOutBack(fixed_t start, fixed_t end, fixed_t t, fixed_t c2)
|
||||
{
|
||||
fixed_t x;
|
||||
|
||||
c2 += FRACUNIT;
|
||||
|
||||
if (t < FRACUNIT / 2)
|
||||
{
|
||||
x = fixintmul(7, t) - c2;
|
||||
x = fixintmul(2, x);
|
||||
x = FixedMul(FixedMul(t, t), x);
|
||||
}
|
||||
else
|
||||
{
|
||||
t -= FRACUNIT;
|
||||
x = fixintmul(2, fixintmul(7, t) + c2);
|
||||
x = FixedMul(FixedMul(t, t), x);
|
||||
x = FRACUNIT + x;
|
||||
}
|
||||
|
||||
return fixinterp(start, end, x);
|
||||
}
|
||||
|
||||
EASINGFUNC(InOutBack)
|
||||
{
|
||||
return DoEaseInOutBack(start, end, t, EASEBACKCONST2);
|
||||
}
|
||||
|
||||
#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
|
||||
95
src/m_easing.h
Normal file
95
src/m_easing.h
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
// SONIC ROBO BLAST 2
|
||||
//-----------------------------------------------------------------------------
|
||||
// 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.h
|
||||
/// \brief Easing functions
|
||||
|
||||
#ifndef __M_EASING_H__
|
||||
#define __M_EASING_H__
|
||||
|
||||
#include "doomtype.h"
|
||||
#include "m_fixed.h"
|
||||
|
||||
typedef enum
|
||||
{
|
||||
EASE_LINEAR = 0,
|
||||
|
||||
EASE_INSINE,
|
||||
EASE_OUTSINE,
|
||||
EASE_INOUTSINE,
|
||||
|
||||
EASE_INQUAD,
|
||||
EASE_OUTQUAD,
|
||||
EASE_INOUTQUAD,
|
||||
|
||||
EASE_INCUBIC,
|
||||
EASE_OUTCUBIC,
|
||||
EASE_INOUTCUBIC,
|
||||
|
||||
EASE_INQUART,
|
||||
EASE_OUTQUART,
|
||||
EASE_INOUTQUART,
|
||||
|
||||
EASE_INQUINT,
|
||||
EASE_OUTQUINT,
|
||||
EASE_INOUTQUINT,
|
||||
|
||||
EASE_INEXPO,
|
||||
EASE_OUTEXPO,
|
||||
EASE_INOUTEXPO,
|
||||
|
||||
EASE_INBACK,
|
||||
EASE_OUTBACK,
|
||||
EASE_INOUTBACK,
|
||||
|
||||
EASE_MAX,
|
||||
} easing_t;
|
||||
|
||||
typedef fixed_t (*easingfunc_t)(fixed_t, fixed_t, fixed_t);
|
||||
|
||||
extern easingfunc_t easing_funclist[EASE_MAX];
|
||||
extern const char *easing_funcnames[EASE_MAX];
|
||||
|
||||
#define EASINGFUNCLIST(sep) \
|
||||
EASINGFUNC(Linear) sep \
|
||||
\
|
||||
EASINGFUNC(InSine) sep \
|
||||
EASINGFUNC(OutSine) sep \
|
||||
EASINGFUNC(InOutSine) sep \
|
||||
\
|
||||
EASINGFUNC(InQuad) sep \
|
||||
EASINGFUNC(OutQuad) sep \
|
||||
EASINGFUNC(InOutQuad) sep \
|
||||
\
|
||||
EASINGFUNC(InCubic) sep \
|
||||
EASINGFUNC(OutCubic) sep \
|
||||
EASINGFUNC(InOutCubic) sep \
|
||||
\
|
||||
EASINGFUNC(InQuart) sep \
|
||||
EASINGFUNC(OutQuart) sep \
|
||||
EASINGFUNC(InOutQuart) sep \
|
||||
\
|
||||
EASINGFUNC(InQuint) sep \
|
||||
EASINGFUNC(OutQuint) sep \
|
||||
EASINGFUNC(InOutQuint) sep \
|
||||
\
|
||||
EASINGFUNC(InExpo) sep \
|
||||
EASINGFUNC(OutExpo) sep \
|
||||
EASINGFUNC(InOutExpo) sep \
|
||||
\
|
||||
EASINGFUNC(InBack) sep \
|
||||
EASINGFUNC(OutBack) sep \
|
||||
EASINGFUNC(InOutBack) sep
|
||||
|
||||
#define EASINGFUNC(type) fixed_t Easing_ ## type (fixed_t start, fixed_t end, fixed_t t);
|
||||
|
||||
EASINGFUNCLIST()
|
||||
|
||||
#undef EASINGFUNC
|
||||
|
||||
#endif
|
||||
Loading…
Reference in a new issue