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

   1 /*
   2 libanim - hierarchical keyframe animation library
   3 Copyright (C) 2012-2018 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 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <limits.h>
  21 #include <assert.h>
  22 #include "anim.h"
  23 #include "dynarr.h"
  24
  25 #include "cgmath/cgmath.h"
  26
  27 #define ROT_USE_SLERP
  28
  29 static void invalidate_cache(struct anm_node *node);
  30
  31 int anm_init_animation(struct anm_animation *anim)
  32 {
  33         int i, j;
  34         static const float defaults[] = {
  35                 0.0f, 0.0f, 0.0f,               /* default position */
  36                 0.0f, 0.0f, 0.0f, 1.0f, /* default rotation quat */
  37                 1.0f, 1.0f, 1.0f                /* default scale factor */
  38         };
  39
  40         anim->name = 0;
  41
  42         for(i=0; i<ANM_NUM_TRACKS; i++) {
  43                 if(anm_init_track(anim->tracks + i) == -1) {
  44                         for(j=0; j<i; j++) {
  45                                 anm_destroy_track(anim->tracks + i);
  46                         }
  47                 }
  48                 anm_set_track_default(anim->tracks + i, defaults[i]);
  49         }
  50         return 0;
  51 }
  52
  53 void anm_destroy_animation(struct anm_animation *anim)
  54 {
  55         int i;
  56         for(i=0; i<ANM_NUM_TRACKS; i++) {
  57                 anm_destroy_track(anim->tracks + i);
  58         }
  59         free(anim->name);
  60 }
  61
  62 void anm_set_animation_name(struct anm_animation *anim, const char *name)
  63 {
  64         char *newname = malloc(strlen(name) + 1);
  65         if(!newname) return;
  66
  67         strcpy(newname, name);
  68
  69         free(anim->name);
  70         anim->name = newname;
  71 }
  72
  73 /* ---- node implementation ----- */
  74
  75 int anm_init_node(struct anm_node *node)
  76 {
  77         memset(node, 0, sizeof *node);
  78
  79         node->cur_anim[1] = -1;
  80
  81         if(!(node->animations = dynarr_alloc(1, sizeof *node->animations))) {
  82                 return -1;
  83         }
  84         if(anm_init_animation(node->animations) == -1) {
  85                 dynarr_free(node->animations);
  86                 return -1;
  87         }
  88
  89 #ifdef ANIM_THREAD_SAFE
  90         /* initialize thread-local matrix cache */
  91         pthread_key_create(&node->cache_key, 0);
  92         pthread_mutex_init(&node->cache_list_lock, 0);
  93 #endif
  94
  95         return 0;
  96 }
  97
  98 void anm_destroy_node(struct anm_node *node)
  99 {
 100         int i, num_anim;
 101         free(node->name);
 102
 103         num_anim = anm_get_animation_count(node);
 104         for(i=0; i<num_anim; i++) {
 105                 anm_destroy_animation(node->animations + i);
 106         }
 107         dynarr_free(node->animations);
 108
 109 #ifdef ANIM_THREAD_SAFE
 110         /* destroy thread-specific cache */
 111         pthread_key_delete(node->cache_key);
 112
 113         while(node->cache_list) {
 114                 struct mat_cache *tmp = node->cache_list;
 115                 node->cache_list = tmp->next;
 116                 free(tmp);
 117         }
 118 #endif
 119 }
 120
 121 void anm_destroy_node_tree(struct anm_node *tree)
 122 {
 123         struct anm_node *c, *tmp;
 124
 125         if(!tree) return;
 126
 127         c = tree->child;
 128         while(c) {
 129                 tmp = c;
 130                 c = c->next;
 131
 132                 anm_destroy_node_tree(tmp);
 133         }
 134         anm_destroy_node(tree);
 135 }
 136
 137 struct anm_node *anm_create_node(void)
 138 {
 139         struct anm_node *n;
 140
 141         if((n = malloc(sizeof *n))) {
 142                 if(anm_init_node(n) == -1) {
 143                         free(n);
 144                         return 0;
 145                 }
 146         }
 147         return n;
 148 }
 149
 150 void anm_free_node(struct anm_node *node)
 151 {
 152         anm_destroy_node(node);
 153         free(node);
 154 }
 155
 156 void anm_free_node_tree(struct anm_node *tree)
 157 {
 158         struct anm_node *c, *tmp;
 159
 160         if(!tree) return;
 161
 162         c = tree->child;
 163         while(c) {
 164                 tmp = c;
 165                 c = c->next;
 166
 167                 anm_free_node_tree(tmp);
 168         }
 169
 170         anm_free_node(tree);
 171 }
 172
 173 int anm_set_node_name(struct anm_node *node, const char *name)
 174 {
 175         char *str;
 176
 177         if(!(str = malloc(strlen(name) + 1))) {
 178                 return -1;
 179         }
 180         strcpy(str, name);
 181         free(node->name);
 182         node->name = str;
 183         return 0;
 184 }
 185
 186 const char *anm_get_node_name(struct anm_node *node)
 187 {
 188         return node->name ? node->name : "";
 189 }
 190
 191 void anm_link_node(struct anm_node *p, struct anm_node *c)
 192 {
 193         c->next = p->child;
 194         p->child = c;
 195
 196         c->parent = p;
 197         invalidate_cache(c);
 198 }
 199
 200 int anm_unlink_node(struct anm_node *p, struct anm_node *c)
 201 {
 202         struct anm_node *iter;
 203
 204         if(p->child == c) {
 205                 p->child = c->next;
 206                 c->next = 0;
 207                 invalidate_cache(c);
 208                 return 0;
 209         }
 210
 211         iter = p->child;
 212         while(iter->next) {
 213                 if(iter->next == c) {
 214                         iter->next = c->next;
 215                         c->next = 0;
 216                         invalidate_cache(c);
 217                         return 0;
 218                 }
 219         }
 220         return -1;
 221 }
 222
 223 void anm_set_pivot(struct anm_node *node, float x, float y, float z)
 224 {
 225         node->pivot[0] = x;
 226         node->pivot[1] = y;
 227         node->pivot[2] = z;
 228 }
 229
 230 void anm_get_pivot(struct anm_node *node, float *x, float *y, float *z)
 231 {
 232         *x = node->pivot[0];
 233         *y = node->pivot[1];
 234         *z = node->pivot[2];
 235 }
 236
 237
 238 /* animation management */
 239
 240 int anm_use_node_animation(struct anm_node *node, int aidx)
 241 {
 242         if(aidx == node->cur_anim[0] && node->cur_anim[1] == -1) {
 243                 return 0;       /* no change, no invalidation */
 244         }
 245
 246         if(aidx < 0 || aidx >= anm_get_animation_count(node)) {
 247                 return -1;
 248         }
 249
 250         node->cur_anim[0] = aidx;
 251         node->cur_anim[1] = -1;
 252         node->cur_mix = 0;
 253         node->blend_dur = -1;
 254
 255         invalidate_cache(node);
 256         return 0;
 257 }
 258
 259 int anm_use_node_animations(struct anm_node *node, int aidx, int bidx, float t)
 260 {
 261         int num_anim;
 262
 263         if(node->cur_anim[0] == aidx && node->cur_anim[1] == bidx &&
 264                         fabs(t - node->cur_mix) < 1e-6) {
 265                 return 0;       /* no change, no invalidation */
 266         }
 267
 268         num_anim = anm_get_animation_count(node);
 269         if(aidx < 0 || aidx >= num_anim) {
 270                 return anm_use_animation(node, bidx);
 271         }
 272         if(bidx < 0 || bidx >= num_anim) {
 273                 return anm_use_animation(node, aidx);
 274         }
 275         node->cur_anim[0] = aidx;
 276         node->cur_anim[1] = bidx;
 277         node->cur_mix = t;
 278
 279         invalidate_cache(node);
 280         return 0;
 281 }
 282
 283 int anm_use_animation(struct anm_node *node, int aidx)
 284 {
 285         struct anm_node *child;
 286
 287         if(anm_use_node_animation(node, aidx) == -1) {
 288                 return -1;
 289         }
 290
 291         child = node->child;
 292         while(child) {
 293                 if(anm_use_animation(child, aidx) == -1) {
 294                         return -1;
 295                 }
 296                 child = child->next;
 297         }
 298         return 0;
 299 }
 300
 301 int anm_use_animations(struct anm_node *node, int aidx, int bidx, float t)
 302 {
 303         struct anm_node *child;
 304
 305         if(anm_use_node_animations(node, aidx, bidx, t) == -1) {
 306                 return -1;
 307         }
 308
 309         child = node->child;
 310         while(child) {
 311                 if(anm_use_animations(child, aidx, bidx, t) == -1) {
 312                         return -1;
 313                 }
 314                 child = child->next;
 315         }
 316         return 0;
 317
 318 }
 319
 320 void anm_set_node_animation_offset(struct anm_node *node, anm_time_t offs, int which)
 321 {
 322         if(which < 0 || which >= 2) {
 323                 return;
 324         }
 325         node->cur_anim_offset[which] = offs;
 326 }
 327
 328 anm_time_t anm_get_animation_offset(const struct anm_node *node, int which)
 329 {
 330         if(which < 0 || which >= 2) {
 331                 return 0;
 332         }
 333         return node->cur_anim_offset[which];
 334 }
 335
 336 void anm_set_animation_offset(struct anm_node *node, anm_time_t offs, int which)
 337 {
 338         struct anm_node *c = node->child;
 339         while(c) {
 340                 anm_set_animation_offset(c, offs, which);
 341                 c = c->next;
 342         }
 343
 344         anm_set_node_animation_offset(node, offs, which);
 345 }
 346
 347 int anm_get_active_animation_index(const struct anm_node *node, int which)
 348 {
 349         if(which < 0 || which >= 2) return -1;
 350         return node->cur_anim[which];
 351 }
 352
 353 struct anm_animation *anm_get_active_animation(const struct anm_node *node, int which)
 354 {
 355         int idx = anm_get_active_animation_index(node, which);
 356         if(idx < 0 || idx >= anm_get_animation_count(node)) {
 357                 return 0;
 358         }
 359         return node->animations + idx;
 360 }
 361
 362 float anm_get_active_animation_mix(const struct anm_node *node)
 363 {
 364         return node->cur_mix;
 365 }
 366
 367 int anm_get_animation_count(const struct anm_node *node)
 368 {
 369         return dynarr_size(node->animations);
 370 }
 371
 372 int anm_add_node_animation(struct anm_node *node)
 373 {
 374         struct anm_animation newanim;
 375         anm_init_animation(&newanim);
 376
 377         node->animations = dynarr_push(node->animations, &newanim);
 378         return 0;
 379 }
 380
 381 int anm_remove_node_animation(struct anm_node *node, int idx)
 382 {
 383         fprintf(stderr, "anm_remove_animation: unimplemented!");
 384         abort();
 385         return 0;
 386 }
 387
 388 int anm_add_animation(struct anm_node *node)
 389 {
 390         struct anm_node *child;
 391
 392         if(anm_add_node_animation(node) == -1) {
 393                 return -1;
 394         }
 395
 396         child = node->child;
 397         while(child) {
 398                 if(anm_add_animation(child)) {
 399                         return -1;
 400                 }
 401                 child = child->next;
 402         }
 403         return 0;
 404 }
 405
 406 int anm_remove_animation(struct anm_node *node, int idx)
 407 {
 408         struct anm_node *child;
 409
 410         if(anm_remove_node_animation(node, idx) == -1) {
 411                 return -1;
 412         }
 413
 414         child = node->child;
 415         while(child) {
 416                 if(anm_remove_animation(child, idx) == -1) {
 417                         return -1;
 418                 }
 419                 child = child->next;
 420         }
 421         return 0;
 422 }
 423
 424 struct anm_animation *anm_get_animation(struct anm_node *node, int idx)
 425 {
 426         if(idx < 0 || idx > anm_get_animation_count(node)) {
 427                 return 0;
 428         }
 429         return node->animations + idx;
 430 }
 431
 432 struct anm_animation *anm_get_animation_by_name(struct anm_node *node, const char *name)
 433 {
 434         return anm_get_animation(node, anm_find_animation(node, name));
 435 }
 436
 437 int anm_find_animation(struct anm_node *node, const char *name)
 438 {
 439         int i, count = anm_get_animation_count(node);
 440         for(i=0; i<count; i++) {
 441                 if(strcmp(node->animations[i].name, name) == 0) {
 442                         return i;
 443                 }
 444         }
 445         return -1;
 446 }
 447
 448 /* all the rest act on the current animation(s) */
 449
 450 void anm_set_interpolator(struct anm_node *node, enum anm_interpolator in)
 451 {
 452         int i;
 453         struct anm_animation *anim = anm_get_active_animation(node, 0);
 454         if(!anim) return;
 455
 456         for(i=0; i<ANM_NUM_TRACKS; i++) {
 457                 anm_set_track_interpolator(anim->tracks + i, in);
 458         }
 459         invalidate_cache(node);
 460 }
 461
 462 void anm_set_extrapolator(struct anm_node *node, enum anm_extrapolator ex)
 463 {
 464         int i;
 465         struct anm_animation *anim = anm_get_active_animation(node, 0);
 466         if(!anim) return;
 467
 468         for(i=0; i<ANM_NUM_TRACKS; i++) {
 469                 anm_set_track_extrapolator(anim->tracks + i, ex);
 470         }
 471         invalidate_cache(node);
 472 }
 473
 474 void anm_set_node_active_animation_name(struct anm_node *node, const char *name)
 475 {
 476         struct anm_animation *anim = anm_get_active_animation(node, 0);
 477         if(!anim) return;
 478
 479         anm_set_animation_name(anim, name);
 480 }
 481
 482 void anm_set_active_animation_name(struct anm_node *node, const char *name)
 483 {
 484         struct anm_node *child;
 485
 486         anm_set_node_active_animation_name(node, name);
 487
 488         child = node->child;
 489         while(child) {
 490                 anm_set_active_animation_name(child, name);
 491                 child = child->next;
 492         }
 493 }
 494
 495 const char *anm_get_active_animation_name(struct anm_node *node)
 496 {
 497         struct anm_animation *anim = anm_get_active_animation(node, 0);
 498         if(anim) {
 499                 return anim->name;
 500         }
 501         return 0;
 502 }
 503
 504 /* ---- high level animation blending ---- */
 505 void anm_transition(struct anm_node *node, int anmidx, anm_time_t start, anm_time_t dur)
 506 {
 507         struct anm_node *c = node->child;
 508
 509         if(anmidx == node->cur_anim[0]) {
 510                 return;
 511         }
 512
 513         while(c) {
 514                 anm_transition(c, anmidx, start, dur);
 515                 c = c->next;
 516         }
 517
 518         anm_node_transition(node, anmidx, start, dur);
 519 }
 520
 521 void anm_node_transition(struct anm_node *node, int anmidx, anm_time_t start, anm_time_t dur)
 522 {
 523         if(anmidx == node->cur_anim[0]) {
 524                 return;
 525         }
 526
 527         node->cur_anim[1] = anmidx;
 528         node->cur_anim_offset[1] = start;
 529         node->blend_dur = dur;
 530 }
 531
 532
 533 #define BLEND_START_TM  node->cur_anim_offset[1]
 534
 535 static anm_time_t animation_time(struct anm_node *node, anm_time_t tm, int which)
 536 {
 537         float t;
 538
 539         if(node->blend_dur >= 0) {
 540                 /* we're in transition... */
 541                 t = (float)(tm - BLEND_START_TM) / (float)node->blend_dur;
 542                 if(t < 0.0) t = 0.0;
 543
 544                 node->cur_mix = t;
 545
 546                 if(t > 1.0) {
 547                         /* switch completely over to the target animation and stop blending */
 548                         anm_use_node_animation(node, node->cur_anim[1]);
 549                         node->cur_anim_offset[0] = node->cur_anim_offset[1];
 550                 }
 551         }
 552
 553         return tm - node->cur_anim_offset[which];
 554 }
 555
 556
 557 void anm_set_position(struct anm_node *node, const float *pos, anm_time_t tm)
 558 {
 559         anm_set_position3f(node, pos[0], pos[1], pos[2], tm);
 560 }
 561
 562 void anm_set_position3f(struct anm_node *node, float x, float y, float z, anm_time_t tm)
 563 {
 564         struct anm_animation *anim = anm_get_active_animation(node, 0);
 565         if(!anim) return;
 566
 567         anm_set_value(anim->tracks + ANM_TRACK_POS_X, tm, x);
 568         anm_set_value(anim->tracks + ANM_TRACK_POS_Y, tm, y);
 569         anm_set_value(anim->tracks + ANM_TRACK_POS_Z, tm, z);
 570         invalidate_cache(node);
 571 }
 572
 573 void anm_get_node_position(struct anm_node *node, float *pos, anm_time_t tm)
 574 {
 575         anm_time_t tm0 = animation_time(node, tm, 0);
 576         struct anm_animation *anim0 = anm_get_active_animation(node, 0);
 577         struct anm_animation *anim1 = anm_get_active_animation(node, 1);
 578
 579         if(!anim0) {
 580                 pos[0] = pos[1] = pos[2] = 0.0f;
 581                 return;
 582         }
 583
 584         pos[0] = anm_get_value(anim0->tracks + ANM_TRACK_POS_X, tm0);
 585         pos[1] = anm_get_value(anim0->tracks + ANM_TRACK_POS_Y, tm0);
 586         pos[2] = anm_get_value(anim0->tracks + ANM_TRACK_POS_Z, tm0);
 587
 588         if(anim1) {
 589                 anm_time_t tm1 = animation_time(node, tm, 1);
 590                 float x1 = anm_get_value(anim1->tracks + ANM_TRACK_POS_X, tm1);
 591                 float y1 = anm_get_value(anim1->tracks + ANM_TRACK_POS_Y, tm1);
 592                 float z1 = anm_get_value(anim1->tracks + ANM_TRACK_POS_Z, tm1);
 593
 594                 pos[0] = pos[0] + (x1 - pos[0]) * node->cur_mix;
 595                 pos[1] = pos[1] + (y1 - pos[1]) * node->cur_mix;
 596                 pos[2] = pos[2] + (z1 - pos[2]) * node->cur_mix;
 597         }
 598 }
 599
 600 void anm_set_rotation(struct anm_node *node, const float *qrot, anm_time_t tm)
 601 {
 602         anm_set_rotation4f(node, qrot[0], qrot[1], qrot[2], qrot[3], tm);
 603 }
 604
 605 void anm_set_rotation4f(struct anm_node *node, float x, float y, float z, float w, anm_time_t tm)
 606 {
 607         struct anm_animation *anim = anm_get_active_animation(node, 0);
 608         if(!anim) return;
 609
 610         anm_set_value(anim->tracks + ANM_TRACK_ROT_X, tm, x);
 611         anm_set_value(anim->tracks + ANM_TRACK_ROT_Y, tm, y);
 612         anm_set_value(anim->tracks + ANM_TRACK_ROT_Z, tm, z);
 613         anm_set_value(anim->tracks + ANM_TRACK_ROT_W, tm, w);
 614         invalidate_cache(node);
 615 }
 616
 617 void anm_set_rotation_axis(struct anm_node *node, float angle, float x, float y, float z, anm_time_t tm)
 618 {
 619         cgm_quat q;
 620
 621         cgm_qrotation(&q, angle, x, y, z);
 622         anm_set_rotation(node, (float*)&q, tm);
 623 }
 624
 625 static void get_node_rotation(cgm_quat *qres, struct anm_node *node, anm_time_t tm, struct anm_animation *anim)
 626 {
 627 #ifndef ROT_USE_SLERP
 628         qres->x = anm_get_value(anim->tracks + ANM_TRACK_ROT_X, tm);
 629         qres->y = anm_get_value(anim->tracks + ANM_TRACK_ROT_Y, tm);
 630         qres->z = anm_get_value(anim->tracks + ANM_TRACK_ROT_Z, tm);
 631         qres->w = anm_get_value(anim->tracks + ANM_TRACK_ROT_W, tm);
 632 #else
 633         int idx0, idx1, last_idx;
 634         anm_time_t tstart, tend;
 635         float t, dt;
 636         struct anm_track *track_x, *track_y, *track_z, *track_w;
 637         cgm_quat q1, q2;
 638
 639         track_x = anim->tracks + ANM_TRACK_ROT_X;
 640         track_y = anim->tracks + ANM_TRACK_ROT_Y;
 641         track_z = anim->tracks + ANM_TRACK_ROT_Z;
 642         track_w = anim->tracks + ANM_TRACK_ROT_W;
 643
 644         if(!track_x->count) {
 645                 qres->x = track_x->def_val;
 646                 qres->y = track_y->def_val;
 647                 qres->z = track_z->def_val;
 648                 qres->w = track_w->def_val;
 649                 return;
 650         }
 651
 652         last_idx = track_x->count - 1;
 653
 654         tstart = track_x->keys[0].time;
 655         tend = track_x->keys[last_idx].time;
 656
 657         if(tstart == tend) {
 658                 qres->x = track_x->keys[0].val;
 659                 qres->y = track_y->keys[0].val;
 660                 qres->z = track_z->keys[0].val;
 661                 qres->w = track_w->keys[0].val;
 662                 return;
 663         }
 664
 665         tm = anm_remap_time(track_x, tm, tstart, tend);
 666
 667         idx0 = anm_get_key_interval(track_x, tm);
 668         assert(idx0 >= 0 && idx0 < track_x->count);
 669         idx1 = idx0 + 1;
 670
 671         if(idx0 == last_idx) {
 672                 qres->x = track_x->keys[idx0].val;
 673                 qres->y = track_y->keys[idx0].val;
 674                 qres->z = track_z->keys[idx0].val;
 675                 qres->w = track_w->keys[idx0].val;
 676                 return;
 677         }
 678
 679         dt = (float)(track_x->keys[idx1].time - track_x->keys[idx0].time);
 680         t = (float)(tm - track_x->keys[idx0].time) / dt;
 681
 682         q1.x = track_x->keys[idx0].val;
 683         q1.y = track_y->keys[idx0].val;
 684         q1.z = track_z->keys[idx0].val;
 685         q1.w = track_w->keys[idx0].val;
 686
 687         q2.x = track_x->keys[idx1].val;
 688         q2.y = track_y->keys[idx1].val;
 689         q2.z = track_z->keys[idx1].val;
 690         q2.w = track_w->keys[idx1].val;
 691
 692         cgm_qslerp(qres, &q1, &q2, t);
 693 #endif
 694 }
 695
 696 //get_node_rotation(cgm_quat *qres, struct anm_node *node, anm_time_t tm, struct anm_animation *anim)
 697 void anm_get_node_rotation(struct anm_node *node, float *qrot, anm_time_t tm)
 698 {
 699         anm_time_t tm0 = animation_time(node, tm, 0);
 700         struct anm_animation *anim0 = anm_get_active_animation(node, 0);
 701         struct anm_animation *anim1 = anm_get_active_animation(node, 1);
 702
 703         if(!anim0) {
 704                 qrot[0] = qrot[1] = qrot[2] = 0.0f;
 705                 qrot[3] = 1.0f;
 706                 return;
 707         }
 708
 709
 710         if(anim1) {
 711                 cgm_quat q0, q1;
 712                 anm_time_t tm1 = animation_time(node, tm, 1);
 713
 714                 get_node_rotation(&q0, node, tm0, anim0);
 715                 get_node_rotation(&q1, node, tm1, anim1);
 716
 717                 cgm_qslerp((cgm_quat*)qrot, &q0, &q1, node->cur_mix);
 718         } else {
 719                 get_node_rotation((cgm_quat*)qrot, node, tm0, anim0);
 720         }
 721 }
 722
 723 void anm_set_scaling(struct anm_node *node, const float *scale, anm_time_t tm)
 724 {
 725         anm_set_scaling3f(node, scale[0], scale[1], scale[2], tm);
 726 }
 727
 728 void anm_set_scaling3f(struct anm_node *node, float x, float y, float z, anm_time_t tm)
 729 {
 730         struct anm_animation *anim = anm_get_active_animation(node, 0);
 731         if(!anim) return;
 732
 733         anm_set_value(anim->tracks + ANM_TRACK_SCL_X, tm, x);
 734         anm_set_value(anim->tracks + ANM_TRACK_SCL_Y, tm, y);
 735         anm_set_value(anim->tracks + ANM_TRACK_SCL_Z, tm, z);
 736         invalidate_cache(node);
 737 }
 738
 739 void anm_get_node_scaling(struct anm_node *node, float *scale, anm_time_t tm)
 740 {
 741         anm_time_t tm0 = animation_time(node, tm, 0);
 742         struct anm_animation *anim0 = anm_get_active_animation(node, 0);
 743         struct anm_animation *anim1 = anm_get_active_animation(node, 1);
 744
 745         if(!anim0) {
 746                 scale[0] = scale[1] = scale[2] = 1.0f;
 747                 return;
 748         }
 749
 750         scale[0] = anm_get_value(anim0->tracks + ANM_TRACK_SCL_X, tm0);
 751         scale[1] = anm_get_value(anim0->tracks + ANM_TRACK_SCL_Y, tm0);
 752         scale[2] = anm_get_value(anim0->tracks + ANM_TRACK_SCL_Z, tm0);
 753
 754         if(anim1) {
 755                 anm_time_t tm1 = animation_time(node, tm, 1);
 756                 float x1 = anm_get_value(anim1->tracks + ANM_TRACK_SCL_X, tm1);
 757                 float y1 = anm_get_value(anim1->tracks + ANM_TRACK_SCL_Y, tm1);
 758                 float z1 = anm_get_value(anim1->tracks + ANM_TRACK_SCL_Z, tm1);
 759
 760                 scale[0] = scale[0] + (x1 - scale[0]) * node->cur_mix;
 761                 scale[1] = scale[1] + (y1 - scale[1]) * node->cur_mix;
 762                 scale[2] = scale[2] + (z1 - scale[2]) * node->cur_mix;
 763         }
 764 }
 765
 766 void anm_get_position(struct anm_node *node, float *pos, anm_time_t tm)
 767 {
 768         if(!node->parent) {
 769                 anm_get_node_position(node, pos, tm);
 770         } else {
 771                 float xform[16];
 772                 anm_get_matrix(node, xform, tm);
 773                 cgm_mget_translation(xform, (cgm_vec3*)pos);
 774         }
 775 }
 776
 777 void anm_get_rotation(struct anm_node *node, float *qrot, anm_time_t tm)
 778 {
 779         if(!node->parent) {
 780                 anm_get_node_rotation(node, qrot, tm);
 781         } else {
 782                 cgm_quat rot;
 783                 anm_get_node_rotation(node, &rot.x, tm);
 784                 anm_get_rotation(node->parent, qrot, tm);
 785                 cgm_qmul((cgm_quat*)qrot, &rot);
 786         }
 787 }
 788
 789 void anm_get_scaling(struct anm_node *node, float *scale, anm_time_t tm)
 790 {
 791         anm_get_node_scaling(node, scale, tm);
 792         if(node->parent) {
 793                 cgm_vec3 ps;
 794                 anm_get_scaling(node->parent, &ps.x, tm);
 795                 cgm_vmul((cgm_vec3*)scale, &ps);
 796         }
 797 }
 798
 799 void anm_get_node_matrix(struct anm_node *node, float *mat, anm_time_t tm)
 800 {
 801         int i;
 802         float rmat[16];
 803         cgm_vec3 pos, scale;
 804         cgm_quat rot;
 805
 806         anm_get_node_position(node, &pos.x, tm);
 807         anm_get_node_rotation(node, &rot.x, tm);
 808         anm_get_node_scaling(node, &scale.x, tm);
 809
 810         cgm_mtranslation(mat, node->pivot[0], node->pivot[1], node->pivot[2]);
 811         cgm_mrotation_quat(rmat, &rot);
 812
 813         /*
 814         for(i=0; i<3; i++) {
 815                 mat[i * 4] = rmat[i * 4];
 816                 mat[i * 4 + 1] = rmat[i * 4 + 1];
 817                 mat[i * 4 + 2] = rmat[i * 4 + 2];
 818         }
 819         */
 820         for(i=0; i<3; i++) {
 821                 mat[i] = rmat[i];
 822                 mat[4 + i] = rmat[4 + i];
 823                 mat[8 + i] = rmat[8 + i];
 824         }
 825
 826         mat[0] *= scale.x; mat[4] *= scale.y; mat[8] *= scale.z; mat[12] += pos.x;
 827         mat[1] *= scale.x; mat[5] *= scale.y; mat[9] *= scale.z; mat[13] += pos.y;
 828         mat[2] *= scale.x; mat[6] *= scale.y; mat[10] *= scale.z; mat[14] += pos.z;
 829
 830         cgm_mpretranslate(mat, -node->pivot[0], -node->pivot[1], -node->pivot[2]);
 831
 832         /* that's basically: pivot * rotation * translation * scaling * -pivot */
 833 }
 834
 835 void anm_get_node_inv_matrix(struct anm_node *node, float *mat, anm_time_t tm)
 836 {
 837         anm_get_node_matrix(node, mat, tm);
 838         cgm_minverse(mat);
 839 }
 840
 841 void anm_eval_node(struct anm_node *node, anm_time_t tm)
 842 {
 843         anm_get_node_matrix(node, node->matrix, tm);
 844 }
 845
 846 void anm_eval(struct anm_node *node, anm_time_t tm)
 847 {
 848         struct anm_node *c;
 849
 850         anm_eval_node(node, tm);
 851
 852         if(node->parent) {
 853                 /* due to post-order traversal, the parent matrix is already evaluated */
 854                 cgm_mmul(node->matrix, node->parent->matrix);
 855         }
 856
 857         /* recersively evaluate all children */
 858         c = node->child;
 859         while(c) {
 860                 anm_eval(c, tm);
 861                 c = c->next;
 862         }
 863 }
 864
 865 float *anm_get_matrix(struct anm_node *node, float *mat, anm_time_t tm)
 866 {
 867 #ifdef ANIM_THREAD_SAFE
 868         struct mat_cache *cache = pthread_getspecific(node->cache_key);
 869         if(!cache) {
 870                 cache = malloc(sizeof *cache);
 871                 assert(cache);
 872
 873                 pthread_mutex_lock(&node->cache_list_lock);
 874                 cache->next = node->cache_list;
 875                 node->cache_list = cache;
 876                 pthread_mutex_unlock(&node->cache_list_lock);
 877
 878                 cache->time = ANM_TIME_INVAL;
 879                 cache->inv_time = ANM_TIME_INVAL;
 880                 pthread_setspecific(node->cache_key, cache);
 881         }
 882 #else
 883         struct mat_cache *cache = &node->cache;
 884 #endif
 885
 886         if(cache->time != tm) {
 887                 anm_get_node_matrix(node, cache->matrix, tm);
 888
 889                 if(node->parent) {
 890                         float parent_mat[16];
 891
 892                         anm_get_matrix(node->parent, parent_mat, tm);
 893                         cgm_mmul(cache->matrix, parent_mat);
 894                 }
 895                 cache->time = tm;
 896         }
 897
 898         if(mat) {
 899                 cgm_mcopy(mat, cache->matrix);
 900         }
 901         return cache->matrix;
 902 }
 903
 904 float *anm_get_inv_matrix(struct anm_node *node, float *mat, anm_time_t tm)
 905 {
 906 #ifdef ANIM_THREAD_SAFE
 907         struct mat_cache *cache = pthread_getspecific(node->cache_key);
 908         if(!cache) {
 909                 cache = malloc(sizeof *cache);
 910                 assert(cache);
 911
 912                 pthread_mutex_lock(&node->cache_list_lock);
 913                 cache->next = node->cache_list;
 914                 node->cache_list = cache;
 915                 pthread_mutex_unlock(&node->cache_list_lock);
 916
 917                 cache->inv_time = ANM_TIME_INVAL;
 918                 cache->inv_time = ANM_TIME_INVAL;
 919                 pthread_setspecific(node->cache_key, cache);
 920         }
 921 #else
 922         struct mat_cache *cache = &node->cache;
 923 #endif
 924
 925         if(cache->inv_time != tm) {
 926                 anm_get_matrix(node, cache->inv_matrix, tm);
 927                 cgm_minverse(cache->inv_matrix);
 928                 cache->inv_time = tm;
 929         }
 930
 931         if(mat) {
 932                 cgm_mcopy(mat, cache->inv_matrix);
 933         }
 934         return cache->inv_matrix;
 935 }
 936
 937 anm_time_t anm_get_start_time(struct anm_node *node)
 938 {
 939         int i, j;
 940         struct anm_node *c;
 941         anm_time_t res = LONG_MAX;
 942
 943         for(j=0; j<2; j++) {
 944                 struct anm_animation *anim = anm_get_active_animation(node, j);
 945                 if(!anim) break;
 946
 947                 for(i=0; i<ANM_NUM_TRACKS; i++) {
 948                         if(anim->tracks[i].count) {
 949                                 anm_time_t tm = anim->tracks[i].keys[0].time;
 950                                 if(tm < res) {
 951                                         res = tm;
 952                                 }
 953                         }
 954                 }
 955         }
 956
 957         c = node->child;
 958         while(c) {
 959                 anm_time_t tm = anm_get_start_time(c);
 960                 if(tm < res) {
 961                         res = tm;
 962                 }
 963                 c = c->next;
 964         }
 965         return res;
 966 }
 967
 968 anm_time_t anm_get_end_time(struct anm_node *node)
 969 {
 970         int i, j;
 971         struct anm_node *c;
 972         anm_time_t res = LONG_MIN;
 973
 974         for(j=0; j<2; j++) {
 975                 struct anm_animation *anim = anm_get_active_animation(node, j);
 976                 if(!anim) break;
 977
 978                 for(i=0; i<ANM_NUM_TRACKS; i++) {
 979                         if(anim->tracks[i].count) {
 980                                 anm_time_t tm = anim->tracks[i].keys[anim->tracks[i].count - 1].time;
 981                                 if(tm > res) {
 982                                         res = tm;
 983                                 }
 984                         }
 985                 }
 986         }
 987
 988         c = node->child;
 989         while(c) {
 990                 anm_time_t tm = anm_get_end_time(c);
 991                 if(tm > res) {
 992                         res = tm;
 993                 }
 994                 c = c->next;
 995         }
 996         return res;
 997 }
 998
 999 static void invalidate_cache(struct anm_node *node)
1000 {
1001         struct anm_node *c;
1002
1003 #ifdef ANIM_THREAD_SAFE
1004         struct mat_cache *cache = pthread_getspecific(node->cache_key);
1005         if(cache) {
1006            cache->time = cache->inv_time = ANM_TIME_INVAL;
1007         }
1008 #else
1009         node->cache.time = node->cache.inv_time = ANM_TIME_INVAL;
1010 #endif
1011
1012         c = node->child;
1013         while(c) {
1014                 invalidate_cache(c);
1015                 c = c->next;
1016         }
1017 }