638 lines
18 KiB
C
638 lines
18 KiB
C
// ----------------------------------------------------------------------------
|
|
// time
|
|
|
|
#if 0
|
|
uint64_t time_gpu() {
|
|
GLint64 t = 123456789;
|
|
glGetInteger64v(GL_TIMESTAMP, &t);
|
|
return (uint64_t)t;
|
|
}
|
|
#endif
|
|
uint64_t date() {
|
|
time_t epoch = time(0);
|
|
struct tm *ti = localtime(&epoch);
|
|
return atoi64(va("%04d%02d%02d%02d%02d%02d",ti->tm_year+1900,ti->tm_mon+1,ti->tm_mday,ti->tm_hour,ti->tm_min,ti->tm_sec));
|
|
}
|
|
char *date_string() {
|
|
time_t epoch = time(0);
|
|
struct tm *ti = localtime(&epoch);
|
|
return va("%04d-%02d-%02d %02d:%02d:%02d",ti->tm_year+1900,ti->tm_mon+1,ti->tm_mday,ti->tm_hour,ti->tm_min,ti->tm_sec);
|
|
}
|
|
uint64_t date_epoch() {
|
|
time_t epoch = time(0);
|
|
return epoch;
|
|
}
|
|
#if 0
|
|
double time_ss() {
|
|
return glfwGetTime();
|
|
}
|
|
double time_ms() {
|
|
return glfwGetTime() * 1000.0;
|
|
}
|
|
uint64_t time_us() {
|
|
return (uint64_t)(glfwGetTime() * 1000000.0); // @fixme: use a high resolution timer instead, or time_gpu below
|
|
}
|
|
uint64_t sleep_us(uint64_t us) { // @fixme: use a high resolution sleeper instead
|
|
return sleep_ms( us / 1000.0 );
|
|
}
|
|
double sleep_ms(double ms) {
|
|
double now = time_ms();
|
|
if( ms <= 0 ) {
|
|
#if is(win32)
|
|
Sleep(0); // yield
|
|
#else
|
|
usleep(0);
|
|
#endif
|
|
} else {
|
|
#if is(win32)
|
|
Sleep(ms);
|
|
#else
|
|
usleep(ms * 1000);
|
|
#endif
|
|
}
|
|
return time_ms() - now;
|
|
}
|
|
double sleep_ss(double ss) {
|
|
return sleep_ms( ss * 1000 ) / 1000.0;
|
|
}
|
|
#endif
|
|
|
|
// high-perf functions
|
|
|
|
#define TIMER_E3 1000ULL
|
|
#define TIMER_E6 1000000ULL
|
|
#define TIMER_E9 1000000000ULL
|
|
|
|
#ifdef CLOCK_MONOTONIC_RAW
|
|
#define TIME_MONOTONIC CLOCK_MONOTONIC_RAW
|
|
#elif defined CLOCK_MONOTONIC
|
|
#define TIME_MONOTONIC CLOCK_MONOTONIC
|
|
#else
|
|
// #define TIME_MONOTONIC CLOCK_REALTIME // untested
|
|
#endif
|
|
|
|
static uint64_t nanotimer(uint64_t *out_freq) {
|
|
if( out_freq ) {
|
|
#if is(win32)
|
|
LARGE_INTEGER li;
|
|
QueryPerformanceFrequency(&li);
|
|
*out_freq = li.QuadPart;
|
|
//#elif is(ANDROID)
|
|
// *out_freq = CLOCKS_PER_SEC;
|
|
#elif defined TIME_MONOTONIC
|
|
*out_freq = TIMER_E9;
|
|
#else
|
|
*out_freq = TIMER_E6;
|
|
#endif
|
|
}
|
|
#if is(win32)
|
|
LARGE_INTEGER li;
|
|
QueryPerformanceCounter(&li);
|
|
return (uint64_t)li.QuadPart;
|
|
//#elif is(ANDROID)
|
|
// return (uint64_t)clock();
|
|
#elif defined TIME_MONOTONIC
|
|
struct timespec ts;
|
|
clock_gettime(TIME_MONOTONIC, &ts);
|
|
return (TIMER_E9 * (uint64_t)ts.tv_sec) + ts.tv_nsec;
|
|
#else
|
|
struct timeval tv;
|
|
gettimeofday(&tv, NULL);
|
|
return (TIMER_E6 * (uint64_t)tv.tv_sec) + tv.tv_usec;
|
|
#endif
|
|
}
|
|
|
|
uint64_t time_ns() {
|
|
static uint64_t epoch = 0;
|
|
static uint64_t freq = 0;
|
|
if( !freq ) {
|
|
epoch = nanotimer(&freq);
|
|
}
|
|
|
|
uint64_t a = nanotimer(NULL) - epoch;
|
|
uint64_t b = TIMER_E9;
|
|
uint64_t c = freq;
|
|
|
|
// Computes (a*b)/c without overflow, as long as both (a*b) and the overall result fit into 64-bits.
|
|
// [ref] https://github.com/rust-lang/rust/blob/3809bbf47c8557bd149b3e52ceb47434ca8378d5/src/libstd/sys_common/mod.rs#L124
|
|
uint64_t q = a / c;
|
|
uint64_t r = a % c;
|
|
return q * b + r * b / c;
|
|
}
|
|
uint64_t time_us() {
|
|
return time_ns() / TIMER_E3;
|
|
}
|
|
uint64_t time_ms() {
|
|
return time_ns() / TIMER_E6;
|
|
}
|
|
double time_ss() {
|
|
return time_ns() / 1e9; // TIMER_E9;
|
|
}
|
|
double time_mm() {
|
|
return time_ss() / 60;
|
|
}
|
|
double time_hh() {
|
|
return time_mm() / 60;
|
|
}
|
|
|
|
void sleep_ns( double ns ) {
|
|
#if is(win32)
|
|
if( ns >= 100 ) {
|
|
LARGE_INTEGER li; // Windows sleep in 100ns units
|
|
HANDLE timer = CreateWaitableTimer(NULL, TRUE, NULL);
|
|
li.QuadPart = (LONGLONG)(__int64)(-ns/100); // Negative for relative time
|
|
SetWaitableTimer(timer, &li, 0, NULL, NULL, FALSE);
|
|
WaitForSingleObject(timer, INFINITE);
|
|
CloseHandle(timer);
|
|
#else
|
|
if( ns > 0 ) {
|
|
struct timespec wait = {0};
|
|
wait.tv_sec = ns / 1e9;
|
|
wait.tv_nsec = ns - wait.tv_sec * 1e9;
|
|
nanosleep(&wait, NULL);
|
|
#endif
|
|
} else {
|
|
#if is(win32)
|
|
Sleep(0); // yield, Sleep(0), SwitchToThread
|
|
#else
|
|
usleep(0);
|
|
#endif
|
|
}
|
|
}
|
|
void sleep_us( double us ) {
|
|
sleep_ns(us * 1e3);
|
|
}
|
|
void sleep_ms( double ms ) {
|
|
sleep_ns(ms * 1e6);
|
|
}
|
|
void sleep_ss( double ss ) {
|
|
sleep_ns(ss * 1e9);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// timer
|
|
|
|
struct timer_internal_t {
|
|
unsigned ms;
|
|
unsigned (*callback)(unsigned interval, void *arg);
|
|
void *arg;
|
|
thread_ptr_t thd;
|
|
};
|
|
|
|
static int timer_func(void *arg) {
|
|
struct timer_internal_t *p = (struct timer_internal_t*)arg;
|
|
|
|
sleep_ms( p->ms );
|
|
|
|
for( ;; ) {
|
|
unsigned then = time_ms();
|
|
|
|
p->ms = p->callback(p->ms, p->arg);
|
|
if( !p->ms ) break;
|
|
|
|
unsigned now = time_ms();
|
|
unsigned lapse = now - then;
|
|
int diff = p->ms - lapse;
|
|
sleep_ms( diff <= 0 ? 0 : diff );
|
|
}
|
|
|
|
thread_exit(0);
|
|
return 0;
|
|
}
|
|
|
|
static __thread array(struct timer_internal_t *) timers;
|
|
|
|
unsigned timer(unsigned ms, unsigned (*callback)(unsigned ms, void *arg), void *arg) {
|
|
struct timer_internal_t *p = MALLOC( sizeof(struct timer_internal_t) );
|
|
p->ms = ms;
|
|
p->callback = callback;
|
|
p->arg = arg;
|
|
p->thd = thread_init( timer_func, p, "", 0 );
|
|
|
|
array_push(timers, p);
|
|
return array_count(timers);
|
|
}
|
|
void timer_destroy(unsigned i) {
|
|
if( i-- ) {
|
|
thread_join(timers[i]->thd);
|
|
thread_term(timers[i]->thd);
|
|
FREE(timers[i]);
|
|
timers[i] = 0;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// guid
|
|
|
|
//typedef vec3i guid;
|
|
|
|
guid guid_create() {
|
|
static __thread unsigned counter = 0;
|
|
static uint64_t appid = 0; do_once appid = hash_str(app_name());
|
|
|
|
union conv {
|
|
struct {
|
|
unsigned timestamp : 32;
|
|
unsigned threadid : 16; // inverted order in LE
|
|
unsigned appid : 16; //
|
|
unsigned counter : 32;
|
|
};
|
|
vec3i v3;
|
|
} c;
|
|
c.timestamp = date_epoch() - 0x65000000;
|
|
c.appid = (unsigned)appid;
|
|
c.threadid = (unsigned)(uintptr_t)thread_current_thread_id();
|
|
c.counter = ++counter;
|
|
|
|
return c.v3;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ease
|
|
|
|
float ease_nop(float t) { return 0; }
|
|
float ease_linear(float t) { return t; }
|
|
|
|
float ease_out_sine(float t) { return sinf(t*(C_PI*0.5f)); }
|
|
float ease_out_quad(float t) { return -(t*(t-2)); }
|
|
float ease_out_cubic(float t) { float f=t-1; return f*f*f+1; }
|
|
float ease_out_quart(float t) { float f=t-1; return f*f*f*(1-t)+1; }
|
|
float ease_out_quint(float t) { float f=(t-1); return f*f*f*f*f+1; }
|
|
float ease_out_expo(float t) { return (t >= 1) ? t : 1-powf(2,-10*t); }
|
|
float ease_out_circ(float t) { return sqrtf((2-t)*t); }
|
|
float ease_out_back(float t) { float f=1-t; return 1-(f*f*f-f*sinf(f*C_PI)); }
|
|
float ease_out_elastic(float t) { return sinf(-13*(C_PI*0.5f)*(t+1))*powf(2,-10*t)+1; }
|
|
float ease_out_bounce(float t) { return (t < 4.f/11) ? (121.f*t*t)/16 : (t < 8.f/11) ? (363.f/40*t*t)-(99.f/10*t)+17.f/5 : (t < 9.f/10) ? (4356.f/361*t*t)-(35442.f/1805*t)+16061.f/1805 : (54.f/5*t*t)-(513.f/25*t)+268.f/25; }
|
|
|
|
float ease_in_sine(float t) { return 1+sinf((t-1)*(C_PI*0.5f)); }
|
|
float ease_in_quad(float t) { return t*t; }
|
|
float ease_in_cubic(float t) { return t*t*t; }
|
|
float ease_in_quart(float t) { return t*t*t*t; }
|
|
float ease_in_quint(float t) { return t*t*t*t*t; }
|
|
float ease_in_expo(float t) { return (t <= 0) ? t : powf(2,10*(t-1)); }
|
|
float ease_in_circ(float t) { return 1-sqrtf(1-(t*t)); }
|
|
float ease_in_back(float t) { return t*t*t-t*sinf(t*C_PI); }
|
|
float ease_in_elastic(float t) { return sinf(13*(C_PI*0.5f)*t)*powf(2,10*(t-1)); }
|
|
float ease_in_bounce(float t) { return 1-ease_out_bounce(1-t); }
|
|
|
|
float ease_inout_sine(float t) { return 0.5f*(1-cosf(t*C_PI)); }
|
|
float ease_inout_quad(float t) { return (t < 0.5f) ? 2*t*t : (-2*t*t)+(4*t)-1; }
|
|
float ease_inout_cubic(float t) { float f; return (t < 0.5f) ? 4*t*t*t : (f=(2*t)-2,0.5f*f*f*f+1); }
|
|
float ease_inout_quart(float t) { float f; return (t < 0.5f) ? 8*t*t*t*t : (f=(t-1),-8*f*f*f*f+1); }
|
|
float ease_inout_quint(float t) { float f; return (t < 0.5f) ? 16*t*t*t*t*t : (f=((2*t)-2),0.5f*f*f*f*f*f+1); }
|
|
float ease_inout_expo(float t) { return (t <= 0 || t >= 1) ? t : t < 0.5f ? 0.5f*powf(2,(20*t)-10) : -0.5f*powf(2,(-20*t)+10)+1; }
|
|
float ease_inout_circ(float t) { return t < 0.5f ? 0.5f*(1-sqrtf(1-4*(t*t))) : 0.5f*(sqrtf(-((2*t)-3)*((2*t)-1))+1); }
|
|
float ease_inout_back(float t) { float f; return t < 0.5f ? (f=2*t,0.5f*(f*f*f-f*sinf(f*C_PI))) : (f=(1-(2*t-1)),0.5f*(1-(f*f*f-f*sinf(f*C_PI)))+0.5f); }
|
|
float ease_inout_elastic(float t) { return t < 0.5f ? 0.5f*sinf(13*(C_PI*0.5f)*(2*t))*powf(2,10*((2*t)-1)) : 0.5f*(sinf(-13*(C_PI*0.5f)*((2*t-1)+1))*powf(2,-10*(2*t-1))+2); }
|
|
float ease_inout_bounce(float t) { return t < 0.5f ? 0.5f*ease_in_bounce(t*2) : 0.5f*ease_out_bounce(t*2-1)+0.5f; }
|
|
|
|
float ease_inout_perlin(float t) { float t3=t*t*t,t4=t3*t,t5=t4*t; return 6*t5-15*t4+10*t3; }
|
|
|
|
float ease(float t01, unsigned mode) {
|
|
typedef float (*easing)(float);
|
|
easing modes[] = {
|
|
ease_out_sine,
|
|
ease_out_quad,
|
|
ease_out_cubic,
|
|
ease_out_quart,
|
|
ease_out_quint,
|
|
ease_out_expo,
|
|
ease_out_circ,
|
|
ease_out_back,
|
|
ease_out_elastic,
|
|
ease_out_bounce,
|
|
|
|
ease_in_sine,
|
|
ease_in_quad,
|
|
ease_in_cubic,
|
|
ease_in_quart,
|
|
ease_in_quint,
|
|
ease_in_expo,
|
|
ease_in_circ,
|
|
ease_in_back,
|
|
ease_in_elastic,
|
|
ease_in_bounce,
|
|
|
|
ease_inout_sine,
|
|
ease_inout_quad,
|
|
ease_inout_cubic,
|
|
ease_inout_quart,
|
|
ease_inout_quint,
|
|
ease_inout_expo,
|
|
ease_inout_circ,
|
|
ease_inout_back,
|
|
ease_inout_elastic,
|
|
ease_inout_bounce,
|
|
|
|
ease_nop,
|
|
ease_linear,
|
|
ease_inout_perlin,
|
|
};
|
|
return modes[clampi(mode, 0, countof(modes))](clampf(t01,0,1));
|
|
}
|
|
|
|
float ease_pong(float t, unsigned fn) { return 1 - ease(t, fn); }
|
|
float ease_ping_pong(float t, unsigned fn1, unsigned fn2) { return t < 0.5 ? ease(t*2,fn1) : ease(1-(t-0.5)*2,fn2); }
|
|
float ease_pong_ping(float t, unsigned fn1, unsigned fn2) { return 1 - ease_ping_pong(t,fn1,fn2); }
|
|
|
|
|
|
const char **ease_enums() {
|
|
static const char *list[] = {
|
|
"ease_out_sine",
|
|
"ease_out_quad",
|
|
"ease_out_cubic",
|
|
"ease_out_quart",
|
|
"ease_out_quint",
|
|
"ease_out_expo",
|
|
"ease_out_circ",
|
|
"ease_out_back",
|
|
"ease_out_elastic",
|
|
"ease_out_bounce",
|
|
|
|
"ease_in_sine",
|
|
"ease_in_quad",
|
|
"ease_in_cubic",
|
|
"ease_in_quart",
|
|
"ease_in_quint",
|
|
"ease_in_expo",
|
|
"ease_in_circ",
|
|
"ease_in_back",
|
|
"ease_in_elastic",
|
|
"ease_in_bounce",
|
|
|
|
"ease_inout_sine",
|
|
"ease_inout_quad",
|
|
"ease_inout_cubic",
|
|
"ease_inout_quart",
|
|
"ease_inout_quint",
|
|
"ease_inout_expo",
|
|
"ease_inout_circ",
|
|
"ease_inout_back",
|
|
"ease_inout_elastic",
|
|
"ease_inout_bounce",
|
|
|
|
"ease_nop",
|
|
"ease_linear",
|
|
"ease_inout_perlin",
|
|
|
|
0
|
|
};
|
|
return list;
|
|
}
|
|
|
|
const char *ease_enum(unsigned mode) {
|
|
return mode[ ease_enums() ];
|
|
}
|
|
|
|
/*AUTORUN {
|
|
ENUM(EASE_LINEAR|EASE_OUT);
|
|
ENUM(EASE_SINE|EASE_OUT);
|
|
ENUM(EASE_QUAD|EASE_OUT);
|
|
ENUM(EASE_CUBIC|EASE_OUT);
|
|
ENUM(EASE_QUART|EASE_OUT);
|
|
ENUM(EASE_QUINT|EASE_OUT);
|
|
ENUM(EASE_EXPO|EASE_OUT);
|
|
ENUM(EASE_CIRC|EASE_OUT);
|
|
ENUM(EASE_BACK|EASE_OUT);
|
|
ENUM(EASE_ELASTIC|EASE_OUT);
|
|
ENUM(EASE_BOUNCE|EASE_OUT);
|
|
|
|
ENUM(EASE_SINE|EASE_IN);
|
|
ENUM(EASE_QUAD|EASE_IN);
|
|
ENUM(EASE_CUBIC|EASE_IN);
|
|
ENUM(EASE_QUART|EASE_IN);
|
|
ENUM(EASE_QUINT|EASE_IN);
|
|
ENUM(EASE_EXPO|EASE_IN);
|
|
ENUM(EASE_CIRC|EASE_IN);
|
|
ENUM(EASE_BACK|EASE_IN);
|
|
ENUM(EASE_ELASTIC|EASE_IN);
|
|
ENUM(EASE_BOUNCE|EASE_IN);
|
|
|
|
ENUM(EASE_SINE|EASE_INOUT);
|
|
ENUM(EASE_QUAD|EASE_INOUT);
|
|
ENUM(EASE_CUBIC|EASE_INOUT);
|
|
ENUM(EASE_QUART|EASE_INOUT);
|
|
ENUM(EASE_QUINT|EASE_INOUT);
|
|
ENUM(EASE_EXPO|EASE_INOUT);
|
|
ENUM(EASE_CIRC|EASE_INOUT);
|
|
ENUM(EASE_BACK|EASE_INOUT);
|
|
ENUM(EASE_ELASTIC|EASE_INOUT);
|
|
ENUM(EASE_BOUNCE|EASE_INOUT);
|
|
|
|
ENUM(EASE_NOP);
|
|
ENUM(EASE_LINEAR);
|
|
ENUM(EASE_INOUT_PERLIN);
|
|
};*/
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// tween
|
|
|
|
tween_t tween() {
|
|
tween_t tw = {0};
|
|
return tw;
|
|
}
|
|
|
|
float tween_update(tween_t *tw, float dt) {
|
|
if( !array_count(tw->keyframes) ) return 0.0f;
|
|
|
|
for( int i = 0, end = array_count(tw->keyframes) - 1; i < end; ++i ) {
|
|
tween_keyframe_t *kf1 = &tw->keyframes[i];
|
|
tween_keyframe_t *kf2 = &tw->keyframes[i + 1];
|
|
if (tw->time >= kf1->t && tw->time <= kf2->t) {
|
|
float localT = (tw->time - kf1->t) / (kf2->t - kf1->t);
|
|
float easedT = ease(localT, kf1->ease);
|
|
tw->result = mix3(kf1->v, kf2->v, easedT);
|
|
break;
|
|
}
|
|
}
|
|
|
|
float done = (tw->time / tw->duration);
|
|
tw->time += dt;
|
|
return clampf(done, 0.0f, 1.0f);
|
|
}
|
|
|
|
void tween_reset(tween_t *tw) {
|
|
tw->time = 0.0f;
|
|
}
|
|
|
|
void tween_destroy(tween_t *tw) {
|
|
tween_t tw_ = {0};
|
|
array_free(tw->keyframes);
|
|
*tw = tw_;
|
|
}
|
|
|
|
static INLINE
|
|
int tween_comp_keyframes(const void *a, const void *b) {
|
|
float t1 = ((const tween_keyframe_t*)a)->t;
|
|
float t2 = ((const tween_keyframe_t*)b)->t;
|
|
return (t1 > t2) - (t1 < t2);
|
|
}
|
|
|
|
void tween_setkey(tween_t *tw, float t, vec3 v, unsigned mode) {
|
|
tween_keyframe_t keyframe = { t, v, mode };
|
|
array_push(tw->keyframes, keyframe);
|
|
array_sort(tw->keyframes, tween_comp_keyframes);
|
|
tw->duration = array_back(tw->keyframes)->t;
|
|
}
|
|
|
|
void tween_delkey(tween_t *tw, float t) { // @todo: untested
|
|
for( int i = 0, end = array_count(tw->keyframes); i < end; i++ ) {
|
|
if( tw->keyframes[i].t == t ) {
|
|
array_erase_slow(tw->keyframes, i);
|
|
tw->duration = array_back(tw->keyframes)->t;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// curve
|
|
|
|
curve_t curve() {
|
|
curve_t c = {0};
|
|
return c;
|
|
}
|
|
|
|
static INLINE
|
|
vec3 catmull( vec3 p0, vec3 p1, vec3 p2, vec3 p3, float t ) {
|
|
float t2 = t*t;
|
|
float t3 = t*t*t;
|
|
|
|
vec3 c;
|
|
c.x = 0.5 * ((2 * p1.x) + (-p0.x + p2.x) * t + (2 * p0.x - 5 * p1.x + 4 * p2.x - p3.x) * t2 + (-p0.x + 3 * p1.x - 3 * p2.x + p3.x) * t3);
|
|
c.y = 0.5 * ((2 * p1.y) + (-p0.y + p2.y) * t + (2 * p0.y - 5 * p1.y + 4 * p2.y - p3.y) * t2 + (-p0.y + 3 * p1.y - 3 * p2.y + p3.y) * t3);
|
|
c.z = 0.5 * ((2 * p1.z) + (-p0.z + p2.z) * t + (2 * p0.z - 5 * p1.z + 4 * p2.z - p3.z) * t2 + (-p0.z + 3 * p1.z - 3 * p2.z + p3.z) * t3);
|
|
return c;
|
|
}
|
|
|
|
void curve_add(curve_t *c, vec3 p) {
|
|
array_push(c->points, p);
|
|
}
|
|
|
|
void curve_end( curve_t *c, int k ) {
|
|
ASSERT( k > 0 );
|
|
|
|
array_free(c->lengths);
|
|
array_free(c->samples);
|
|
array_free(c->indices);
|
|
array_free(c->colors);
|
|
|
|
// refit points[N] to samples[K]
|
|
int N = array_count(c->points);
|
|
if( k < N ) {
|
|
// truncate: expected k-points lesser or equal than existing N points
|
|
for( int i = 0; i <= k; ++i ) {
|
|
float s = (float)i / k;
|
|
int t = s * (N-1);
|
|
array_push(c->samples, c->points[t]);
|
|
|
|
float p = fmod(i, N-1) / (N-1); // [0..1)
|
|
int is_control_point = p <= 0 || p >= 1;
|
|
array_push(c->colors, is_control_point ? ORANGE: BLUE);
|
|
}
|
|
|
|
} else {
|
|
// interpolate: expected k-points greater than existing N-points
|
|
--N;
|
|
int upper = N - (k%N);
|
|
int lower = (k%N);
|
|
if(upper < lower)
|
|
k += upper;
|
|
else
|
|
k -= lower;
|
|
|
|
int points_per_segment = (k / N);
|
|
++N;
|
|
|
|
int looped = len3sq(sub3(c->points[0], *array_back(c->points))) < 0.1;
|
|
|
|
for( int i = 0; i <= k; ++i ) {
|
|
int point = i % points_per_segment;
|
|
float p = point / (float)points_per_segment; // [0..1)
|
|
int t = i / points_per_segment;
|
|
|
|
// linear
|
|
vec3 l = mix3(c->points[t], c->points[t+(i!=k)], p);
|
|
|
|
// printf("%d) %d>%d %f\n", i, t, t+(i!=k), p);
|
|
ASSERT(p <= 1);
|
|
|
|
// catmull
|
|
int p0 = t - 1;
|
|
int p1 = t + 0;
|
|
int p2 = t + 1;
|
|
int p3 = t + 2;
|
|
if( looped )
|
|
{
|
|
int M = N-1;
|
|
if(p0<0) p0+=M; else if(p0>=M) p0-=M;
|
|
if(p1<0) p1+=M; else if(p1>=M) p1-=M;
|
|
if(p2<0) p2+=M; else if(p2>=M) p2-=M;
|
|
if(p3<0) p3+=M; else if(p3>=M) p3-=M;
|
|
}
|
|
else
|
|
{
|
|
int M = N-1;
|
|
if(p0<0) p0=0; else if(p0>=M) p0=M;
|
|
if(p1<0) p1=0; else if(p1>=M) p1=M;
|
|
if(p2<0) p2=0; else if(p2>=M) p2=M;
|
|
if(p3<0) p3=0; else if(p3>=M) p3=M;
|
|
}
|
|
vec3 m = catmull(c->points[p0],c->points[p1],c->points[p2],c->points[p3],p);
|
|
l = m;
|
|
|
|
array_push(c->samples, l);
|
|
|
|
int is_control_point = p <= 0 || p >= 1;
|
|
array_push(c->colors, is_control_point ? ORANGE: BLUE);
|
|
}
|
|
}
|
|
|
|
array_push(c->lengths, 0 );
|
|
for( int i = 1; i <= k; ++i ) {
|
|
// approximate curve length at every sample point
|
|
array_push(c->lengths, len3(sub3(c->samples[i], c->samples[i-1])) + c->lengths[i-1] );
|
|
}
|
|
// normalize lengths to be between 0 and 1
|
|
float maxv = c->lengths[k];
|
|
for( int i = 1; i <= k; ++i ) c->lengths[i] /= maxv;
|
|
|
|
array_push(c->indices, 0 );
|
|
for( int i = 0/*1*/; i </*=*/ k; ++i ) {
|
|
float s = (float)i / (k-1); //k;
|
|
int j; // j = so that lengths[j] <= s < lengths[j+1];
|
|
|
|
// j = Index of the highest length that is less or equal to s
|
|
// Can be optimized with a binary search instead
|
|
for( j = *array_back(c->indices) + 1; j </*=*/ k; ++j ) {
|
|
if( c->lengths[j] </*=*/ s ) continue;
|
|
break;
|
|
}
|
|
|
|
if (c->lengths[j] > 0.01)
|
|
array_push(c->indices, j );
|
|
}
|
|
}
|
|
|
|
vec3 curve_eval(curve_t *c, float dt, unsigned *color) {
|
|
unsigned nil; if(!color) color = &nil;
|
|
dt = clampf(dt, 0.0f, 1.0f);
|
|
int l = (int)(array_count(c->indices) - 1);
|
|
int p = (int)(dt * l);
|
|
int t = c->indices[p];
|
|
|
|
t %= (array_count(c->indices)-1);
|
|
vec3 pos = mix3(c->samples[t], c->samples[t+1], dt * l - p);
|
|
*color = c->colors[t];
|
|
|
|
return pos;
|
|
}
|
|
|
|
void curve_destroy(curve_t *c) {
|
|
array_free(c->lengths);
|
|
array_free(c->colors);
|
|
array_free(c->samples);
|
|
array_free(c->points);
|
|
array_free(c->indices);
|
|
}
|