git.mutantstargoat.com Git - dosdemo/blob - libs/anim/src/track.c

   1 /*
   2 libanim - hierarchical keyframe animation library
   3 Copyright (C) 2012-2015 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 static int keycmp(const void *a, const void *b);
  26 static int find_prev_key(struct anm_keyframe *arr, int start, int end, anm_time_t tm);
  27
  28 static float interp_step(float v0, float v1, float v2, float v3, float t);
  29 static float interp_linear(float v0, float v1, float v2, float v3, float t);
  30 static float interp_cubic(float v0, float v1, float v2, float v3, float t);
  31
  32 static anm_time_t remap_extend(anm_time_t tm, anm_time_t start, anm_time_t end);
  33 static anm_time_t remap_clamp(anm_time_t tm, anm_time_t start, anm_time_t end);
  34 static anm_time_t remap_repeat(anm_time_t tm, anm_time_t start, anm_time_t end);
  35 static anm_time_t remap_pingpong(anm_time_t tm, anm_time_t start, anm_time_t end);
  36
  37 /* XXX keep this in sync with enum anm_interpolator at track.h */
  38 static float (*interp[])(float, float, float, float, float) = {
  39         interp_step,
  40         interp_linear,
  41         interp_cubic,
  42         0
  43 };
  44
  45 /* XXX keep this in sync with enum anm_extrapolator at track.h */
  46 static anm_time_t (*remap_time[])(anm_time_t, anm_time_t, anm_time_t) = {
  47         remap_extend,
  48         remap_clamp,
  49         remap_repeat,
  50         remap_pingpong,
  51         0
  52 };
  53
  54 int anm_init_track(struct anm_track *track)
  55 {
  56         memset(track, 0, sizeof *track);
  57
  58         if(!(track->keys = dynarr_alloc(0, sizeof *track->keys))) {
  59                 return -1;
  60         }
  61         track->interp = ANM_INTERP_LINEAR;
  62         track->extrap = ANM_EXTRAP_CLAMP;
  63         return 0;
  64 }
  65
  66 void anm_destroy_track(struct anm_track *track)
  67 {
  68         dynarr_free(track->keys);
  69 }
  70
  71 struct anm_track *anm_create_track(void)
  72 {
  73         struct anm_track *track;
  74
  75         if((track = malloc(sizeof *track))) {
  76                 if(anm_init_track(track) == -1) {
  77                         free(track);
  78                         return 0;
  79                 }
  80         }
  81         return track;
  82 }
  83
  84 void anm_free_track(struct anm_track *track)
  85 {
  86         anm_destroy_track(track);
  87         free(track);
  88 }
  89
  90 void anm_copy_track(struct anm_track *dest, const struct anm_track *src)
  91 {
  92         free(dest->name);
  93         if(dest->keys) {
  94                 dynarr_free(dest->keys);
  95         }
  96
  97         if(src->name) {
  98                 dest->name = malloc(strlen(src->name) + 1);
  99                 strcpy(dest->name, src->name);
 100         }
 101
 102         dest->count = src->count;
 103         dest->keys = dynarr_alloc(src->count, sizeof *dest->keys);
 104         memcpy(dest->keys, src->keys, src->count * sizeof *dest->keys);
 105
 106         dest->def_val = src->def_val;
 107         dest->interp = src->interp;
 108         dest->extrap = src->extrap;
 109 }
 110
 111 int anm_set_track_name(struct anm_track *track, const char *name)
 112 {
 113         char *tmp;
 114
 115         if(!(tmp = malloc(strlen(name) + 1))) {
 116                 return -1;
 117         }
 118         free(track->name);
 119         track->name = tmp;
 120         return 0;
 121 }
 122
 123 const char *anm_get_track_name(struct anm_track *track)
 124 {
 125         return track->name;
 126 }
 127
 128 void anm_set_track_interpolator(struct anm_track *track, enum anm_interpolator in)
 129 {
 130         track->interp = in;
 131 }
 132
 133 void anm_set_track_extrapolator(struct anm_track *track, enum anm_extrapolator ex)
 134 {
 135         track->extrap = ex;
 136 }
 137
 138 anm_time_t anm_remap_time(struct anm_track *track, anm_time_t tm, anm_time_t start, anm_time_t end)
 139 {
 140         return remap_time[track->extrap](tm, start, end);
 141 }
 142
 143 void anm_set_track_default(struct anm_track *track, float def)
 144 {
 145         track->def_val = def;
 146 }
 147
 148 int anm_set_keyframe(struct anm_track *track, struct anm_keyframe *key)
 149 {
 150         int idx = anm_get_key_interval(track, key->time);
 151
 152         /* if we got a valid keyframe index, compare them... */
 153         if(idx >= 0 && idx < track->count && keycmp(key, track->keys + idx) == 0) {
 154                 /* ... it's the same key, just update the value */
 155                 track->keys[idx].val = key->val;
 156         } else {
 157                 /* ... it's a new key, add it and re-sort them */
 158                 void *tmp;
 159                 if(!(tmp = dynarr_push(track->keys, key))) {
 160                         return -1;
 161                 }
 162                 track->keys = tmp;
 163                 /* TODO lazy qsort */
 164                 qsort(track->keys, ++track->count, sizeof *track->keys, keycmp);
 165         }
 166         return 0;
 167 }
 168
 169 static int keycmp(const void *a, const void *b)
 170 {
 171         return ((struct anm_keyframe*)a)->time - ((struct anm_keyframe*)b)->time;
 172 }
 173
 174 struct anm_keyframe *anm_get_keyframe(struct anm_track *track, int idx)
 175 {
 176         if(idx < 0 || idx >= track->count) {
 177                 return 0;
 178         }
 179         return track->keys + idx;
 180 }
 181
 182 int anm_get_key_interval(struct anm_track *track, anm_time_t tm)
 183 {
 184         int last;
 185
 186         if(!track->count || tm < track->keys[0].time) {
 187                 return -1;
 188         }
 189
 190         last = track->count - 1;
 191         if(tm > track->keys[last].time) {
 192                 return last;
 193         }
 194
 195         return find_prev_key(track->keys, 0, last, tm);
 196 }
 197
 198 static int find_prev_key(struct anm_keyframe *arr, int start, int end, anm_time_t tm)
 199 {
 200         int mid;
 201
 202         if(end - start <= 1) {
 203                 return start;
 204         }
 205
 206         mid = (start + end) / 2;
 207         if(tm < arr[mid].time) {
 208                 return find_prev_key(arr, start, mid, tm);
 209         }
 210         if(tm > arr[mid].time) {
 211                 return find_prev_key(arr, mid, end, tm);
 212         }
 213         return mid;
 214 }
 215
 216 int anm_set_value(struct anm_track *track, anm_time_t tm, float val)
 217 {
 218         struct anm_keyframe key;
 219         key.time = tm;
 220         key.val = val;
 221
 222         return anm_set_keyframe(track, &key);
 223 }
 224
 225 float anm_get_value(struct anm_track *track, anm_time_t tm)
 226 {
 227         int idx0, idx1, last_idx;
 228         anm_time_t tstart, tend;
 229         float t, dt;
 230         float v0, v1, v2, v3;
 231
 232         if(!track->count) {
 233                 return track->def_val;
 234         }
 235
 236         last_idx = track->count - 1;
 237
 238         tstart = track->keys[0].time;
 239         tend = track->keys[last_idx].time;
 240
 241         if(tstart == tend) {
 242                 return track->keys[0].val;
 243         }
 244
 245         tm = remap_time[track->extrap](tm, tstart, tend);
 246
 247         idx0 = anm_get_key_interval(track, tm);
 248         assert(idx0 >= 0 && idx0 < track->count);
 249         idx1 = idx0 + 1;
 250
 251         if(idx0 == last_idx) {
 252                 return track->keys[idx0].val;
 253         }
 254
 255         dt = (float)(track->keys[idx1].time - track->keys[idx0].time);
 256         t = (float)(tm - track->keys[idx0].time) / dt;
 257
 258         v1 = track->keys[idx0].val;
 259         v2 = track->keys[idx1].val;
 260
 261         /* get the neigboring values to allow for cubic interpolation */
 262         v0 = idx0 > 0 ? track->keys[idx0 - 1].val : v1;
 263         v3 = idx1 < last_idx ? track->keys[idx1 + 1].val : v2;
 264
 265         return interp[track->interp](v0, v1, v2, v3, t);
 266 }
 267
 268
 269 static float interp_step(float v0, float v1, float v2, float v3, float t)
 270 {
 271         return v1;
 272 }
 273
 274 static float interp_linear(float v0, float v1, float v2, float v3, float t)
 275 {
 276         return v1 + (v2 - v1) * t;
 277 }
 278
 279 static float interp_cubic(float a, float b, float c, float d, float t)
 280 {
 281         float x, y, z, w;
 282         float tsq = t * t;
 283
 284         x = -a + 3.0 * b - 3.0 * c + d;
 285         y = 2.0 * a - 5.0 * b + 4.0 * c - d;
 286         z = c - a;
 287         w = 2.0 * b;
 288
 289         return 0.5 * (x * tsq * t + y * tsq + z * t + w);
 290 }
 291
 292 static anm_time_t remap_extend(anm_time_t tm, anm_time_t start, anm_time_t end)
 293 {
 294         return remap_repeat(tm, start, end);
 295 }
 296
 297 static anm_time_t remap_clamp(anm_time_t tm, anm_time_t start, anm_time_t end)
 298 {
 299         if(start == end) {
 300                 return start;
 301         }
 302         return tm < start ? start : (tm >= end ? end : tm);
 303 }
 304
 305 static anm_time_t remap_repeat(anm_time_t tm, anm_time_t start, anm_time_t end)
 306 {
 307         anm_time_t x, interv = end - start;
 308
 309         if(interv == 0) {
 310                 return start;
 311         }
 312
 313         x = (tm - start) % interv;
 314         if(x < 0) {
 315                 x += interv;
 316         }
 317         return x + start;
 318
 319         /*if(tm < start) {
 320                 while(tm < start) {
 321                         tm += interv;
 322                 }
 323                 return tm;
 324         }
 325         return (tm - start) % interv + start;*/
 326 }
 327
 328 static anm_time_t remap_pingpong(anm_time_t tm, anm_time_t start, anm_time_t end)
 329 {
 330         anm_time_t interv = end - start;
 331         anm_time_t x = remap_repeat(tm, start, end + interv);
 332
 333         return x > end ? end + interv - x : x;
 334 }