git.mutantstargoat.com Git - raydungeon/blob - libs/goat3d/src/track.c

   1 /*
   2 libanim - hierarchical keyframe animation library
   3 Copyright (C) 2012-2023 John Tsiombikas <nuclear@member.fsf.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published
   7 by the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <assert.h>
  22 #include "track.h"
  23 #include "dynarr.h"
  24
  25 #include "cgmath/cgmath.h"
  26
  27 static int find_prev_key(const struct anm_keyframe *arr, int start, int end, anm_time_t tm);
  28
  29 static float interp_step(float v0, float v1, float v2, float v3, float t);
  30 static float interp_linear(float v0, float v1, float v2, float v3, float t);
  31 static float interp_cubic(float v0, float v1, float v2, float v3, float t);
  32
  33 static anm_time_t remap_extend(anm_time_t tm, anm_time_t start, anm_time_t end);
  34 static anm_time_t remap_clamp(anm_time_t tm, anm_time_t start, anm_time_t end);
  35 static anm_time_t remap_repeat(anm_time_t tm, anm_time_t start, anm_time_t end);
  36 static anm_time_t remap_pingpong(anm_time_t tm, anm_time_t start, anm_time_t end);
  37
  38 /* XXX keep this in sync with enum anm_interpolator at track.h */
  39 static float (*interp[])(float, float, float, float, float) = {
  40         interp_step,
  41         interp_linear,
  42         interp_cubic,
  43         0
  44 };
  45
  46 /* XXX keep this in sync with enum anm_extrapolator at track.h */
  47 static anm_time_t (*remap_time[])(anm_time_t, anm_time_t, anm_time_t) = {
  48         remap_extend,
  49         remap_clamp,
  50         remap_repeat,
  51         remap_pingpong,
  52         0
  53 };
  54
  55 int anm_init_track(struct anm_track *track)
  56 {
  57         memset(track, 0, sizeof *track);
  58
  59         if(!(track->keys = dynarr_alloc(0, sizeof *track->keys))) {
  60                 return -1;
  61         }
  62         track->keys_sorted = 1;
  63         track->interp = ANM_INTERP_LINEAR;
  64         track->extrap = ANM_EXTRAP_CLAMP;
  65         return 0;
  66 }
  67
  68 void anm_destroy_track(struct anm_track *track)
  69 {
  70         dynarr_free(track->keys);
  71 }
  72
  73 struct anm_track *anm_create_track(void)
  74 {
  75         struct anm_track *track;
  76
  77         if((track = malloc(sizeof *track))) {
  78                 if(anm_init_track(track) == -1) {
  79                         free(track);
  80                         return 0;
  81                 }
  82         }
  83         return track;
  84 }
  85
  86 void anm_free_track(struct anm_track *track)
  87 {
  88         anm_destroy_track(track);
  89         free(track);
  90 }
  91
  92 void anm_copy_track(struct anm_track *dest, const struct anm_track *src)
  93 {
  94         free(dest->name);
  95         if(dest->keys) {
  96                 dynarr_free(dest->keys);
  97         }
  98
  99         if(src->name) {
 100                 dest->name = malloc(strlen(src->name) + 1);
 101                 strcpy(dest->name, src->name);
 102         }
 103
 104         dest->count = src->count;
 105         dest->keys = dynarr_alloc(src->count, sizeof *dest->keys);
 106         memcpy(dest->keys, src->keys, src->count * sizeof *dest->keys);
 107
 108         dest->def_val = src->def_val;
 109         dest->interp = src->interp;
 110         dest->extrap = src->extrap;
 111         dest->keys_sorted = src->keys_sorted;
 112 }
 113
 114 int anm_set_track_name(struct anm_track *track, const char *name)
 115 {
 116         char *tmp;
 117
 118         if(!(tmp = malloc(strlen(name) + 1))) {
 119                 return -1;
 120         }
 121         free(track->name);
 122         track->name = tmp;
 123         return 0;
 124 }
 125
 126 const char *anm_get_track_name(const struct anm_track *track)
 127 {
 128         return track->name;
 129 }
 130
 131 void anm_set_track_interpolator(struct anm_track *track, enum anm_interpolator in)
 132 {
 133         track->interp = in;
 134 }
 135
 136 void anm_set_track_extrapolator(struct anm_track *track, enum anm_extrapolator ex)
 137 {
 138         track->extrap = ex;
 139 }
 140
 141 anm_time_t anm_remap_time(const struct anm_track *track, anm_time_t tm, anm_time_t start, anm_time_t end)
 142 {
 143         return remap_time[track->extrap](tm, start, end);
 144 }
 145
 146 void anm_set_track_default(struct anm_track *track, float def)
 147 {
 148         track->def_val = def;
 149 }
 150
 151 static int keycmp(const void *a, const void *b)
 152 {
 153         return ((struct anm_keyframe*)a)->time - ((struct anm_keyframe*)b)->time;
 154 }
 155
 156 int anm_set_keyframe(struct anm_track *track, struct anm_keyframe *key)
 157 {
 158         int idx = anm_get_key_interval(track, key->time);
 159
 160         /* if we got a valid keyframe index, compare them... */
 161         if(idx >= 0 && idx < track->count && keycmp(key, track->keys + idx) == 0) {
 162                 /* ... it's the same key, just update the value */
 163                 track->keys[idx].val = key->val;
 164         } else {
 165                 /* ... it's a new key, add it and re-sort them if necessary */
 166                 void *tmp;
 167                 if(!(tmp = dynarr_push(track->keys, key))) {
 168                         return -1;
 169                 }
 170                 track->keys = tmp;
 171                 idx = track->count++;
 172                 if(idx > 0 && track->keys[idx - 1].time > key->time) {
 173                         /* key shold not go to the end, mark for re-sorting */
 174                         track->keys_sorted = 0;
 175                 }
 176         }
 177         return 0;
 178 }
 179
 180 #define lazysort_keys(track)    \
 181         if(track->count > 1 && !track->keys_sorted) { \
 182                 qsort(track->keys, track->count, sizeof *track->keys, keycmp); \
 183                 ((struct anm_track*)track)->keys_sorted = 1; \
 184         }
 185
 186 struct anm_keyframe *anm_get_keyframe(const struct anm_track *track, int idx)
 187 {
 188         if(idx < 0 || idx >= track->count) {
 189                 return 0;
 190         }
 191         lazysort_keys(track);
 192         return track->keys + idx;
 193 }
 194
 195 int anm_get_key_interval(const struct anm_track *track, anm_time_t tm)
 196 {
 197         int last;
 198
 199         lazysort_keys(track);
 200
 201         if(!track->count || tm < track->keys[0].time) {
 202                 return -1;
 203         }
 204
 205         last = track->count - 1;
 206         if(tm > track->keys[last].time) {
 207                 return last;
 208         }
 209
 210         return find_prev_key(track->keys, 0, last, tm);
 211 }
 212
 213 static int find_prev_key(const struct anm_keyframe *arr, int start, int end, anm_time_t tm)
 214 {
 215         int mid;
 216
 217         if(end - start <= 1) {
 218                 return start;
 219         }
 220
 221         mid = (start + end) / 2;
 222         if(tm < arr[mid].time) {
 223                 return find_prev_key(arr, start, mid, tm);
 224         }
 225         if(tm > arr[mid].time) {
 226                 return find_prev_key(arr, mid, end, tm);
 227         }
 228         return mid;
 229 }
 230
 231 int anm_set_value(struct anm_track *track, anm_time_t tm, float val)
 232 {
 233         struct anm_keyframe key;
 234         key.time = tm;
 235         key.val = val;
 236
 237         return anm_set_keyframe(track, &key);
 238 }
 239
 240 float anm_get_value(const struct anm_track *track, anm_time_t tm)
 241 {
 242         int idx0, idx1, last_idx;
 243         anm_time_t tstart, tend;
 244         float t, dt;
 245         float v0, v1, v2, v3;
 246
 247         if(!track->count) {
 248                 return track->def_val;
 249         }
 250         lazysort_keys(track);
 251
 252         last_idx = track->count - 1;
 253
 254         tstart = track->keys[0].time;
 255         tend = track->keys[last_idx].time;
 256
 257         if(tstart == tend) {
 258                 return track->keys[0].val;
 259         }
 260
 261         tm = remap_time[track->extrap](tm, tstart, tend);
 262
 263         idx0 = anm_get_key_interval(track, tm);
 264         assert(idx0 >= 0 && idx0 < track->count);
 265         idx1 = idx0 + 1;
 266
 267         if(idx0 == last_idx) {
 268                 return track->keys[idx0].val;
 269         }
 270
 271         dt = (float)(track->keys[idx1].time - track->keys[idx0].time);
 272         t = (float)(tm - track->keys[idx0].time) / dt;
 273
 274         v1 = track->keys[idx0].val;
 275         v2 = track->keys[idx1].val;
 276
 277         /* get the neigboring values to allow for cubic interpolation */
 278         v0 = idx0 > 0 ? track->keys[idx0 - 1].val : v1;
 279         v3 = idx1 < last_idx ? track->keys[idx1 + 1].val : v2;
 280
 281         return interp[track->interp](v0, v1, v2, v3, t);
 282 }
 283
 284
 285 void anm_get_quat(const struct anm_track *xtrk, const struct anm_track *ytrk,
 286                 const struct anm_track *ztrk, const struct anm_track *wtrk, anm_time_t tm, float *qres)
 287 {
 288         int idx0, idx1, last_idx;
 289         anm_time_t tstart, tend;
 290         float t, dt;
 291         cgm_quat q1, q2;
 292
 293         if(!xtrk->count) {
 294                 qres[0] = xtrk->def_val;
 295                 qres[1] = ytrk->def_val;
 296                 qres[2] = ztrk->def_val;
 297                 qres[3] = wtrk->def_val;
 298                 return;
 299         }
 300
 301         lazysort_keys(xtrk);
 302         lazysort_keys(ytrk);
 303         lazysort_keys(ztrk);
 304         lazysort_keys(wtrk);
 305
 306         last_idx = xtrk->count - 1;
 307
 308         tstart = xtrk->keys[0].time;
 309         tend = xtrk->keys[last_idx].time;
 310
 311         if(tstart == tend) {
 312                 qres[0] = xtrk->keys[0].val;
 313                 qres[1] = ytrk->keys[0].val;
 314                 qres[2] = ztrk->keys[0].val;
 315                 qres[3] = wtrk->keys[0].val;
 316                 return;
 317         }
 318
 319         tm = anm_remap_time(xtrk, tm, tstart, tend);
 320
 321         idx0 = anm_get_key_interval(xtrk, tm);
 322         assert(idx0 >= 0 && idx0 < xtrk->count);
 323         idx1 = idx0 + 1;
 324
 325         if(idx0 == last_idx) {
 326                 qres[0] = xtrk->keys[idx0].val;
 327                 qres[1] = ytrk->keys[idx0].val;
 328                 qres[2] = ztrk->keys[idx0].val;
 329                 qres[3] = wtrk->keys[idx0].val;
 330                 return;
 331         }
 332
 333         dt = (float)(xtrk->keys[idx1].time - xtrk->keys[idx0].time);
 334         t = (float)(tm - xtrk->keys[idx0].time) / dt;
 335
 336         q1.x = xtrk->keys[idx0].val;
 337         q1.y = ytrk->keys[idx0].val;
 338         q1.z = ztrk->keys[idx0].val;
 339         q1.w = wtrk->keys[idx0].val;
 340
 341         q2.x = xtrk->keys[idx1].val;
 342         q2.y = ytrk->keys[idx1].val;
 343         q2.z = ztrk->keys[idx1].val;
 344         q2.w = wtrk->keys[idx1].val;
 345
 346         cgm_qslerp((cgm_quat*)qres, &q1, &q2, t);
 347 }
 348
 349
 350 static float interp_step(float v0, float v1, float v2, float v3, float t)
 351 {
 352         return v1;
 353 }
 354
 355 static float interp_linear(float v0, float v1, float v2, float v3, float t)
 356 {
 357         return v1 + (v2 - v1) * t;
 358 }
 359
 360 static float interp_cubic(float a, float b, float c, float d, float t)
 361 {
 362         float x, y, z, w;
 363         float tsq = t * t;
 364
 365         x = -a + 3.0 * b - 3.0 * c + d;
 366         y = 2.0 * a - 5.0 * b + 4.0 * c - d;
 367         z = c - a;
 368         w = 2.0 * b;
 369
 370         return 0.5 * (x * tsq * t + y * tsq + z * t + w);
 371 }
 372
 373 static anm_time_t remap_extend(anm_time_t tm, anm_time_t start, anm_time_t end)
 374 {
 375         return remap_repeat(tm, start, end);
 376 }
 377
 378 static anm_time_t remap_clamp(anm_time_t tm, anm_time_t start, anm_time_t end)
 379 {
 380         if(start == end) {
 381                 return start;
 382         }
 383         return tm < start ? start : (tm >= end ? end : tm);
 384 }
 385
 386 static anm_time_t remap_repeat(anm_time_t tm, anm_time_t start, anm_time_t end)
 387 {
 388         anm_time_t x, interv = end - start;
 389
 390         if(interv == 0) {
 391                 return start;
 392         }
 393
 394         x = (tm - start) % interv;
 395         if(x < 0) {
 396                 x += interv;
 397         }
 398         return x + start;
 399
 400         /*if(tm < start) {
 401                 while(tm < start) {
 402                         tm += interv;
 403                 }
 404                 return tm;
 405         }
 406         return (tm - start) % interv + start;*/
 407 }
 408
 409 static anm_time_t remap_pingpong(anm_time_t tm, anm_time_t start, anm_time_t end)
 410 {
 411         anm_time_t interv = end - start;
 412         anm_time_t x = remap_repeat(tm, start, end + interv);
 413
 414         return x > end ? end + interv - x : x;
 415 }