2 * The 3D Studio File Format Library
3 * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published by
8 * the Free Software Foundation; either version 2.1 of the License, or (at
9 * your option) any later version.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14 * License for more details.
16 * You should have received a copy of the GNU Lesser General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 * $Id: tracks.c,v 1.14 2004/11/20 09:00:38 efalk Exp $
23 #include <lib3ds/tracks.h>
24 #include <lib3ds/io.h>
25 #include <lib3ds/chunk.h>
26 #include <lib3ds/float.h>
27 #include <lib3ds/vector.h>
28 #include <lib3ds/quat.h>
29 #include <lib3ds/node.h>
39 * \defgroup tracks Keyframing Tracks
41 * \author J.E. Hoffmann <je-h@gmx.net>
52 k=(Lib3dsBoolKey*)calloc(sizeof(Lib3dsBoolKey), 1);
61 lib3ds_bool_key_free(Lib3dsBoolKey *key)
72 lib3ds_bool_track_free_keys(Lib3dsBoolTrack *track)
77 for (p=track->keyL; p; p=q) {
79 lib3ds_bool_key_free(p);
88 lib3ds_bool_track_insert(Lib3dsBoolTrack *track, Lib3dsBoolKey *key)
101 for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
102 if (k->tcb.frame>key->tcb.frame) {
107 key->next=track->keyL;
115 if (k && (key->tcb.frame==k->tcb.frame)) {
117 lib3ds_bool_key_free(k);
127 lib3ds_bool_track_remove(Lib3dsBoolTrack *track, Lib3dsIntd frame)
135 for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
136 if (k->tcb.frame==frame) {
138 track->keyL=track->keyL->next;
143 lib3ds_bool_key_free(k);
154 lib3ds_bool_track_eval(Lib3dsBoolTrack *track, Lib3dsBool *p, Lib3dsFloat t)
164 if (!track->keyL->next) {
171 while ((t<(Lib3dsFloat)k->tcb.frame) && (t>=(Lib3dsFloat)k->next->tcb.frame)) {
179 if (track->flags&LIB3DS_REPEAT) {
180 t-=(Lib3dsFloat)k->tcb.frame;
199 lib3ds_bool_track_read(Lib3dsBoolTrack *track, Lib3dsIo *io)
205 track->flags=lib3ds_io_read_word(io);
206 lib3ds_io_read_dword(io);
207 lib3ds_io_read_dword(io);
208 keys=lib3ds_io_read_intd(io);
210 for (i=0; i<keys; ++i) {
211 k=lib3ds_bool_key_new();
212 if (!lib3ds_tcb_read(&k->tcb, io)) {
213 return(LIB3DS_FALSE);
215 lib3ds_bool_track_insert(track, k);
226 lib3ds_bool_track_write(Lib3dsBoolTrack *track, Lib3dsIo *io)
230 for (k=track->keyL; k; k=k->next) {
233 lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
234 lib3ds_io_write_dword(io, 0);
235 lib3ds_io_write_dword(io, 0);
236 lib3ds_io_write_dword(io, num);
238 for (k=track->keyL; k; k=k->next) {
239 if (!lib3ds_tcb_write(&k->tcb,io)) {
240 return(LIB3DS_FALSE);
251 lib3ds_lin1_key_new()
254 k=(Lib3dsLin1Key*)calloc(sizeof(Lib3dsLin1Key), 1);
263 lib3ds_lin1_key_free(Lib3dsLin1Key *key)
274 lib3ds_lin1_track_free_keys(Lib3dsLin1Track *track)
279 for (p=track->keyL; p; p=q) {
281 lib3ds_lin1_key_free(p);
290 lib3ds_lin1_key_setup(Lib3dsLin1Key *p, Lib3dsLin1Key *cp, Lib3dsLin1Key *c,
291 Lib3dsLin1Key *cn, Lib3dsLin1Key *n)
294 Lib3dsFloat ksm,ksp,kdm,kdp;
310 lib3ds_tcb(&p->tcb, &cp->tcb, &c->tcb, &cn->tcb, &n->tcb, &ksm, &ksp, &kdm, &kdp);
311 np = c->value - p->value;
312 nn = n->value - c->value;
314 c->ds=ksm*np + ksp*nn;
315 c->dd=kdm*np + kdp*nn;
319 np = c->value - p->value;
324 nn = n->value - c->value;
336 lib3ds_lin1_track_setup(Lib3dsLin1Track *track)
338 Lib3dsLin1Key *pp,*pc,*pn,*pl;
351 if (track->flags&LIB3DS_SMOOTH) {
352 for (pl=track->keyL; pl->next->next; pl=pl->next);
353 lib3ds_lin1_key_setup(pl, pl->next, pc, 0, pc->next);
356 lib3ds_lin1_key_setup(0, 0, pc, 0, pc->next);
365 lib3ds_lin1_key_setup(pp, 0, pc, 0, pn);
368 if (track->flags&LIB3DS_SMOOTH) {
369 lib3ds_lin1_key_setup(pp, 0, pc, track->keyL, track->keyL->next);
372 lib3ds_lin1_key_setup(pp, 0, pc, 0, 0);
381 lib3ds_lin1_track_insert(Lib3dsLin1Track *track, Lib3dsLin1Key *key)
394 for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
395 if (k->tcb.frame>key->tcb.frame) {
400 key->next=track->keyL;
408 if (k && (key->tcb.frame==k->tcb.frame)) {
410 lib3ds_lin1_key_free(k);
420 lib3ds_lin1_track_remove(Lib3dsLin1Track *track, Lib3dsIntd frame)
428 for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
429 if (k->tcb.frame==frame) {
431 track->keyL=track->keyL->next;
436 lib3ds_lin1_key_free(k);
447 lib3ds_lin1_track_eval(Lib3dsLin1Track *track, Lib3dsFloat *p, Lib3dsFloat t)
458 if (!track->keyL->next) {
459 *p = track->keyL->value;
463 for (k=track->keyL; k->next!=0; k=k->next) {
464 if ((t>=(Lib3dsFloat)k->tcb.frame) && (t<(Lib3dsFloat)k->next->tcb.frame)) {
469 if (track->flags&LIB3DS_REPEAT) {
470 nt=(Lib3dsFloat)fmod(t, k->tcb.frame);
471 for (k=track->keyL; k->next!=0; k=k->next) {
472 if ((nt>=(Lib3dsFloat)k->tcb.frame) && (nt<(Lib3dsFloat)k->next->tcb.frame)) {
486 u=nt - (Lib3dsFloat)k->tcb.frame;
487 u/=(Lib3dsFloat)(k->next->tcb.frame - k->tcb.frame);
489 *p = lib3ds_float_cubic(
503 lib3ds_lin1_track_read(Lib3dsLin1Track *track, Lib3dsIo *io)
509 track->flags=lib3ds_io_read_word(io);
510 lib3ds_io_read_dword(io);
511 lib3ds_io_read_dword(io);
512 keys=lib3ds_io_read_intd(io);
514 for (i=0; i<keys; ++i) {
515 k=lib3ds_lin1_key_new();
516 if (!lib3ds_tcb_read(&k->tcb, io)) {
517 return(LIB3DS_FALSE);
519 k->value=lib3ds_io_read_float(io);
520 lib3ds_lin1_track_insert(track, k);
522 lib3ds_lin1_track_setup(track);
531 lib3ds_lin1_track_write(Lib3dsLin1Track *track, Lib3dsIo *io)
535 for (k=track->keyL; k; k=k->next) {
538 lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
539 lib3ds_io_write_dword(io, 0);
540 lib3ds_io_write_dword(io, 0);
541 lib3ds_io_write_dword(io, num);
543 for (k=track->keyL; k; k=k->next) {
544 if (!lib3ds_tcb_write(&k->tcb,io)) {
545 return(LIB3DS_FALSE);
547 lib3ds_io_write_float(io, k->value);
554 * Create and return one keyframe in a Lin3 track. All values are
555 * initialized to zero.
560 lib3ds_lin3_key_new()
563 k=(Lib3dsLin3Key*)calloc(sizeof(Lib3dsLin3Key), 1);
569 * Free a Lin3 keyframe.
574 lib3ds_lin3_key_free(Lib3dsLin3Key *key)
582 * Free all keyframes in a Lin3 track.
587 lib3ds_lin3_track_free_keys(Lib3dsLin3Track *track)
592 for (p=track->keyL; p; p=q) {
594 lib3ds_lin3_key_free(p);
603 lib3ds_lin3_key_setup(Lib3dsLin3Key *p, Lib3dsLin3Key *cp, Lib3dsLin3Key *c,
604 Lib3dsLin3Key *cn, Lib3dsLin3Key *n)
607 Lib3dsFloat ksm,ksp,kdm,kdp;
618 lib3ds_vector_zero(c->ds);
619 lib3ds_vector_zero(c->dd);
624 lib3ds_tcb(&p->tcb, &cp->tcb, &c->tcb, &cn->tcb, &n->tcb, &ksm, &ksp, &kdm, &kdp);
625 lib3ds_vector_sub(np, c->value, p->value);
626 lib3ds_vector_sub(nn, n->value, c->value);
629 c->ds[i]=ksm*np[i] + ksp*nn[i];
630 c->dd[i]=kdm*np[i] + kdp*nn[i];
635 lib3ds_vector_sub(np, c->value, p->value);
636 lib3ds_vector_copy(c->ds, np);
637 lib3ds_vector_copy(c->dd, np);
640 lib3ds_vector_sub(nn, n->value, c->value);
641 lib3ds_vector_copy(c->ds, nn);
642 lib3ds_vector_copy(c->dd, nn);
652 lib3ds_lin3_track_setup(Lib3dsLin3Track *track)
654 Lib3dsLin3Key *pp,*pc,*pn,*pl;
662 lib3ds_vector_zero(pc->ds);
663 lib3ds_vector_zero(pc->dd);
667 if (track->flags&LIB3DS_SMOOTH) {
668 for (pl=track->keyL; pl->next->next; pl=pl->next);
669 lib3ds_lin3_key_setup(pl, pl->next, pc, 0, pc->next);
672 lib3ds_lin3_key_setup(0, 0, pc, 0, pc->next);
681 lib3ds_lin3_key_setup(pp, 0, pc, 0, pn);
684 if (track->flags&LIB3DS_SMOOTH) {
685 lib3ds_lin3_key_setup(pp, 0, pc, track->keyL, track->keyL->next);
688 lib3ds_lin3_key_setup(pp, 0, pc, 0, 0);
697 lib3ds_lin3_track_insert(Lib3dsLin3Track *track, Lib3dsLin3Key *key)
710 for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
711 if (k->tcb.frame>key->tcb.frame) {
716 key->next=track->keyL;
724 if (k && (key->tcb.frame==k->tcb.frame)) {
726 lib3ds_lin3_key_free(k);
736 lib3ds_lin3_track_remove(Lib3dsLin3Track *track, Lib3dsIntd frame)
744 for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
745 if (k->tcb.frame==frame) {
747 track->keyL=track->keyL->next;
752 lib3ds_lin3_key_free(k);
763 lib3ds_lin3_track_eval(Lib3dsLin3Track *track, Lib3dsVector p, Lib3dsFloat t)
770 lib3ds_vector_zero(p);
773 if (!track->keyL->next) {
774 lib3ds_vector_copy(p, track->keyL->value);
778 for (k=track->keyL; k->next!=0; k=k->next) {
779 if ((t>=(Lib3dsFloat)k->tcb.frame) && (t<(Lib3dsFloat)k->next->tcb.frame)) {
784 if (track->flags&LIB3DS_REPEAT) {
785 nt=(Lib3dsFloat)fmod(t, k->tcb.frame);
786 for (k=track->keyL; k->next!=0; k=k->next) {
787 if ((nt>=(Lib3dsFloat)k->tcb.frame) && (nt<(Lib3dsFloat)k->next->tcb.frame)) {
794 lib3ds_vector_copy(p, k->value);
801 u=nt - (Lib3dsFloat)k->tcb.frame;
802 u/=(Lib3dsFloat)(k->next->tcb.frame - k->tcb.frame);
819 lib3ds_lin3_track_read(Lib3dsLin3Track *track, Lib3dsIo *io)
825 track->flags=lib3ds_io_read_word(io);
826 lib3ds_io_read_dword(io);
827 lib3ds_io_read_dword(io);
828 keys=lib3ds_io_read_intd(io);
830 for (i=0; i<keys; ++i) {
831 k=lib3ds_lin3_key_new();
832 if (!lib3ds_tcb_read(&k->tcb, io)) {
833 return(LIB3DS_FALSE);
835 for (j=0; j<3; ++j) {
836 k->value[j]=lib3ds_io_read_float(io);
838 lib3ds_lin3_track_insert(track, k);
840 lib3ds_lin3_track_setup(track);
849 lib3ds_lin3_track_write(Lib3dsLin3Track *track, Lib3dsIo *io)
853 for (k=track->keyL; k; k=k->next) {
856 lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
857 lib3ds_io_write_dword(io, 0);
858 lib3ds_io_write_dword(io, 0);
859 lib3ds_io_write_dword(io, num);
861 for (k=track->keyL; k; k=k->next) {
862 if (!lib3ds_tcb_write(&k->tcb,io)) {
863 return(LIB3DS_FALSE);
865 lib3ds_io_write_vector(io, k->value);
875 lib3ds_quat_key_new()
878 k=(Lib3dsQuatKey*)calloc(sizeof(Lib3dsQuatKey), 1);
887 lib3ds_quat_key_free(Lib3dsQuatKey *key)
898 lib3ds_quat_track_free_keys(Lib3dsQuatTrack *track)
903 for (p=track->keyL; p; p=q) {
905 lib3ds_quat_key_free(p);
914 lib3ds_quat_key_setup(Lib3dsQuatKey *p, Lib3dsQuatKey *cp, Lib3dsQuatKey *c,
915 Lib3dsQuatKey *cn, Lib3dsQuatKey *n)
917 Lib3dsFloat ksm,ksp,kdm,kdp;
918 Lib3dsQuat q,qp,qn,qa,qb;
929 lib3ds_quat_copy(c->ds, c->q);
930 lib3ds_quat_copy(c->dd, c->q);
935 if (p->angle>LIB3DS_TWOPI-LIB3DS_EPSILON) {
936 lib3ds_quat_axis_angle(qp, p->axis, 0.0f);
940 lib3ds_quat_copy(q, p->q);
941 if (lib3ds_quat_dot(q,c->q)<0) lib3ds_quat_neg(q);
942 lib3ds_quat_ln_dif(qp, c->q, q);
946 if (n->angle>LIB3DS_TWOPI-LIB3DS_EPSILON) {
947 lib3ds_quat_axis_angle(qn, n->axis, 0.0f);
951 lib3ds_quat_copy(q, n->q);
952 if (lib3ds_quat_dot(q,c->q)<0) lib3ds_quat_neg(q);
953 lib3ds_quat_ln_dif(qn, c->q, q);
958 lib3ds_tcb(&p->tcb, &cp->tcb, &c->tcb, &cn->tcb, &n->tcb, &ksm, &ksp, &kdm, &kdp);
960 qa[i]=-0.5f*(kdm*qn[i]+kdp*qp[i]);
961 qb[i]=-0.5f*(ksm*qn[i]+ksp*qp[i]);
966 lib3ds_quat_mul(c->ds, c->q, qa);
967 lib3ds_quat_mul(c->dd, c->q, qb);
972 lib3ds_quat_mul(c->ds, c->q, qp);
973 lib3ds_quat_mul(c->dd, c->q, qp);
977 lib3ds_quat_mul(c->ds, c->q, qn);
978 lib3ds_quat_mul(c->dd, c->q, qn);
988 lib3ds_quat_track_setup(Lib3dsQuatTrack *track)
990 Lib3dsQuatKey *pp,*pc,*pn,*pl;
994 for (pp=0,pc=track->keyL; pc; pp=pc,pc=pc->next) {
995 lib3ds_quat_axis_angle(q, pc->axis, pc->angle);
997 lib3ds_quat_mul(pc->q, q, pp->q);
1000 lib3ds_quat_copy(pc->q, q);
1009 lib3ds_quat_copy(pc->ds, pc->q);
1010 lib3ds_quat_copy(pc->dd, pc->q);
1014 if (track->flags&LIB3DS_SMOOTH) {
1015 for (pl=track->keyL; pl->next->next; pl=pl->next);
1016 lib3ds_quat_key_setup(pl, pl->next, pc, 0, pc->next);
1019 lib3ds_quat_key_setup(0, 0, pc, 0, pc->next);
1028 lib3ds_quat_key_setup(pp, 0, pc, 0, pn);
1031 if (track->flags&LIB3DS_SMOOTH) {
1032 lib3ds_quat_key_setup(pp, 0, pc, track->keyL, track->keyL->next);
1035 lib3ds_quat_key_setup(pp, 0, pc, 0, 0);
1044 lib3ds_quat_track_insert(Lib3dsQuatTrack *track, Lib3dsQuatKey *key)
1055 Lib3dsQuatKey *k,*p;
1057 for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
1058 if (k->tcb.frame>key->tcb.frame) {
1063 key->next=track->keyL;
1071 if (k && (key->tcb.frame==k->tcb.frame)) {
1073 lib3ds_quat_key_free(k);
1083 lib3ds_quat_track_remove(Lib3dsQuatTrack *track, Lib3dsIntd frame)
1085 Lib3dsQuatKey *k,*p;
1091 for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
1092 if (k->tcb.frame==frame) {
1094 track->keyL=track->keyL->next;
1099 lib3ds_quat_key_free(k);
1110 lib3ds_quat_track_eval(Lib3dsQuatTrack *track, Lib3dsQuat q, Lib3dsFloat t)
1117 lib3ds_quat_identity(q);
1120 if (!track->keyL->next) {
1121 lib3ds_quat_copy(q, track->keyL->q);
1125 for (k=track->keyL; k->next!=0; k=k->next) {
1126 if ((t>=k->tcb.frame) && (t<k->next->tcb.frame)) {
1131 if (track->flags&LIB3DS_REPEAT) {
1132 nt=(Lib3dsFloat)fmod(t, k->tcb.frame);
1133 for (k=track->keyL; k->next!=0; k=k->next) {
1134 if ((nt>=k->tcb.frame) && (nt<k->next->tcb.frame)) {
1141 lib3ds_quat_copy(q, k->q);
1148 u=nt - k->tcb.frame;
1149 u/=(k->next->tcb.frame - k->tcb.frame);
1166 lib3ds_quat_track_read(Lib3dsQuatTrack *track, Lib3dsIo *io)
1170 Lib3dsQuatKey *p,*k;
1172 track->flags=lib3ds_io_read_word(io);
1173 lib3ds_io_read_dword(io);
1174 lib3ds_io_read_dword(io);
1175 keys=lib3ds_io_read_intd(io);
1177 for (p=0,i=0; i<keys; p=k,++i) {
1178 k=lib3ds_quat_key_new();
1179 if (!lib3ds_tcb_read(&k->tcb, io)) {
1180 return(LIB3DS_FALSE);
1182 k->angle=lib3ds_io_read_float(io);
1183 for (j=0; j<3; ++j) {
1184 k->axis[j]=lib3ds_io_read_float(io);
1186 lib3ds_quat_track_insert(track, k);
1188 lib3ds_quat_track_setup(track);
1189 return(LIB3DS_TRUE);
1197 lib3ds_quat_track_write(Lib3dsQuatTrack *track, Lib3dsIo *io)
1201 for (k=track->keyL; k; k=k->next) {
1204 lib3ds_io_write_word(io, (Lib3dsWord)track->flags);
1205 lib3ds_io_write_dword(io, 0);
1206 lib3ds_io_write_dword(io, 0);
1207 lib3ds_io_write_dword(io, num);
1209 for (k=track->keyL; k; k=k->next) {
1210 if (!lib3ds_tcb_write(&k->tcb,io)) {
1211 return(LIB3DS_FALSE);
1213 lib3ds_io_write_float(io, k->angle);
1214 lib3ds_io_write_vector(io, k->axis);
1216 return(LIB3DS_TRUE);
1224 lib3ds_morph_key_new()
1227 k=(Lib3dsMorphKey*)calloc(sizeof(Lib3dsMorphKey), 1);
1236 lib3ds_morph_key_free(Lib3dsMorphKey *key)
1247 lib3ds_morph_track_free_keys(Lib3dsMorphTrack *track)
1249 Lib3dsMorphKey *p,*q;
1252 for (p=track->keyL; p; p=q) {
1254 lib3ds_morph_key_free(p);
1263 lib3ds_morph_track_insert(Lib3dsMorphTrack *track, Lib3dsMorphKey *key)
1274 Lib3dsMorphKey *k,*p;
1276 for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
1277 if (k->tcb.frame>key->tcb.frame) {
1282 key->next=track->keyL;
1290 if (k && (key->tcb.frame==k->tcb.frame)) {
1292 lib3ds_morph_key_free(k);
1302 lib3ds_morph_track_remove(Lib3dsMorphTrack *track, Lib3dsIntd frame)
1304 Lib3dsMorphKey *k,*p;
1310 for (p=0,k=track->keyL; k!=0; p=k, k=k->next) {
1311 if (k->tcb.frame==frame) {
1313 track->keyL=track->keyL->next;
1318 lib3ds_morph_key_free(k);
1329 lib3ds_morph_track_eval(Lib3dsMorphTrack *track, char *p, Lib3dsFloat t)
1339 if (!track->keyL->next) {
1340 strcpy(p,track->keyL->name);
1345 /* TODO: this function finds the mesh frame that corresponds to this
1346 * timeframe. It would be better to actually interpolate the mesh.
1351 for(k = track->keyL;
1352 k->next != NULL && t >= k->next->tcb.frame;
1370 lib3ds_morph_track_read(Lib3dsMorphTrack *track, Lib3dsIo *io)
1372 /* This function was written by Stephane Denis on 5-18-04 */
1374 Lib3dsMorphKey *k, *pk = 0;
1376 track->flags=lib3ds_io_read_word(io);
1377 lib3ds_io_read_dword(io);
1378 lib3ds_io_read_dword(io);
1379 keys=lib3ds_io_read_intd(io);
1381 for (i=0; i<keys; ++i) {
1382 k=lib3ds_morph_key_new();
1383 if (!lib3ds_tcb_read(&k->tcb, io)) {
1384 return(LIB3DS_FALSE);
1386 if (!lib3ds_io_read_string(io, k->name, 11)) {
1387 return(LIB3DS_FALSE);
1395 return(LIB3DS_TRUE);
1403 lib3ds_morph_track_write(Lib3dsMorphTrack *track, Lib3dsIo *io)
1407 return(LIB3DS_FALSE);
1413 tcb_dump(Lib3dsTcb *tcb)
1415 printf(" tcb: frame=%d, flags=%04x, tens=%g, cont=%g, ",
1416 (int)tcb->frame, tcb->flags, tcb->tens, tcb->cont);
1417 printf("bias=%g, ease_to=%g, ease_from=%g\n",
1418 tcb->bias, tcb->ease_to, tcb->ease_from);
1423 lib3ds_boolTrack_dump(Lib3dsBoolTrack *track)
1426 printf("flags: %08x, keys:\n", (unsigned int)track->flags);
1427 for( key = track->keyL; key != NULL; key = key->next)
1429 tcb_dump(&key->tcb);
1435 lib3ds_lin1Track_dump(Lib3dsLin1Track *track)
1438 printf("flags: %08x, keys:\n", (unsigned int)track->flags);
1439 for( key = track->keyL; key != NULL; key = key->next)
1441 tcb_dump(&key->tcb);
1442 printf(" value = %g, dd=%g, ds=%g\n",
1443 key->value, key->dd, key->ds);
1449 lib3ds_lin3Track_dump(Lib3dsLin3Track *track)
1452 printf("flags: %08x, keys:\n", (unsigned int)track->flags);
1453 for( key = track->keyL; key != NULL; key = key->next)
1455 tcb_dump(&key->tcb);
1456 printf(" value = %g,%g,%g, dd=%g,%g,%g, ds=%g,%g,%g\n",
1457 key->value[0], key->value[1], key->value[2],
1458 key->dd[0], key->dd[1], key->dd[2],
1459 key->ds[0], key->ds[1], key->ds[2]);
1465 lib3ds_quatTrack_dump(Lib3dsQuatTrack *track)
1468 printf("flags: %08x, keys:\n", (unsigned int)track->flags);
1469 for( key = track->keyL; key != NULL; key = key->next)
1471 tcb_dump(&key->tcb);
1472 printf(" axis = %g,%g,%g, angle=%g, q=%g,%g,%g,%g\n",
1473 key->axis[0], key->axis[1], key->axis[2], key->angle,
1474 key->q[0], key->q[1], key->q[2], key->q[3]);
1475 printf(" dd = %g,%g,%g,%g, ds=%g,%g,%g,%g\n",
1476 key->dd[0], key->dd[1], key->dd[2], key->dd[3],
1477 key->ds[0], key->ds[1], key->ds[2], key->ds[3]);
1483 lib3ds_morphTrack_dump(Lib3dsMorphTrack *track)
1485 Lib3dsMorphKey *key;
1486 printf("flags: %08x, keys:\n", (unsigned int)track->flags);
1487 for( key = track->keyL; key != NULL; key = key->next)
1489 tcb_dump(&key->tcb);
1490 printf(" name = %s\n", key->name);
1497 lib3ds_dump_tracks(Lib3dsNode *node)
1499 switch( node->type ) {
1500 case LIB3DS_AMBIENT_NODE:
1501 printf("ambient: ");
1502 lib3ds_lin3Track_dump(&node->data.ambient.col_track);
1504 case LIB3DS_OBJECT_NODE:
1506 lib3ds_lin3Track_dump(&node->data.object.pos_track);
1508 lib3ds_quatTrack_dump(&node->data.object.rot_track);
1510 lib3ds_lin3Track_dump(&node->data.object.scl_track);
1512 lib3ds_morphTrack_dump(&node->data.object.morph_track);
1514 lib3ds_boolTrack_dump(&node->data.object.hide_track);
1516 case LIB3DS_CAMERA_NODE:
1518 lib3ds_lin3Track_dump(&node->data.camera.pos_track);
1520 lib3ds_lin1Track_dump(&node->data.camera.fov_track);
1522 lib3ds_lin1Track_dump(&node->data.camera.roll_track);
1524 case LIB3DS_TARGET_NODE:
1526 lib3ds_lin3Track_dump(&node->data.target.pos_track);
1528 case LIB3DS_LIGHT_NODE:
1530 lib3ds_lin3Track_dump(&node->data.light.pos_track);
1532 lib3ds_lin3Track_dump(&node->data.light.col_track);
1533 printf("hotspot: ");
1534 lib3ds_lin1Track_dump(&node->data.light.hotspot_track);
1535 printf("falloff: ");
1536 lib3ds_lin1Track_dump(&node->data.light.falloff_track);
1538 lib3ds_lin1Track_dump(&node->data.light.roll_track);
1540 case LIB3DS_SPOT_NODE:
1542 lib3ds_lin3Track_dump(&node->data.spot.pos_track);