nuclear@27: #include <stdlib.h>
nuclear@27: #include <limits.h>
nuclear@27: #include <assert.h>
nuclear@27: #include "anim.h"
nuclear@27: #include "dynarr.h"
nuclear@27: 
nuclear@27: #define ROT_USE_SLERP
nuclear@27: 
nuclear@27: static void invalidate_cache(struct anm_node *node);
nuclear@27: 
nuclear@49: int anm_init_animation(struct anm_animation *anim)
nuclear@27: {
nuclear@27: 	int i, j;
nuclear@27: 	static const float defaults[] = {
nuclear@27: 		0.0f, 0.0f, 0.0f,		/* default position */
nuclear@27: 		0.0f, 0.0f, 0.0f, 1.0f,	/* default rotation quat */
nuclear@27: 		1.0f, 1.0f, 1.0f		/* default scale factor */
nuclear@27: 	};
nuclear@27: 
nuclear@49: 	anim->name = 0;
nuclear@49: 
nuclear@49: 	for(i=0; i<ANM_NUM_TRACKS; i++) {
nuclear@49: 		if(anm_init_track(anim->tracks + i) == -1) {
nuclear@49: 			for(j=0; j<i; j++) {
nuclear@49: 				anm_destroy_track(anim->tracks + i);
nuclear@49: 			}
nuclear@49: 		}
nuclear@49: 		anm_set_track_default(anim->tracks + i, defaults[i]);
nuclear@49: 	}
nuclear@49: 	return 0;
nuclear@49: }
nuclear@49: 
nuclear@49: void anm_destroy_animation(struct anm_animation *anim)
nuclear@49: {
nuclear@49: 	int i;
nuclear@49: 	for(i=0; i<ANM_NUM_TRACKS; i++) {
nuclear@49: 		anm_destroy_track(anim->tracks + i);
nuclear@49: 	}
nuclear@49: 	free(anim->name);
nuclear@49: }
nuclear@49: 
nuclear@49: void anm_set_animation_name(struct anm_animation *anim, const char *name)
nuclear@49: {
nuclear@49: 	char *newname = malloc(strlen(name) + 1);
nuclear@49: 	if(!newname) return;
nuclear@49: 
nuclear@49: 	strcpy(newname, name);
nuclear@49: 
nuclear@49: 	free(anim->name);
nuclear@49: 	anim->name = newname;
nuclear@49: }
nuclear@49: 
nuclear@49: /* ---- node implementation ----- */
nuclear@49: 
nuclear@49: int anm_init_node(struct anm_node *node)
nuclear@49: {
nuclear@27: 	memset(node, 0, sizeof *node);
nuclear@27: 
nuclear@49: 	node->cur_anim[1] = -1;
nuclear@49: 
nuclear@49: 	if(!(node->animations = dynarr_alloc(1, sizeof *node->animations))) {
nuclear@49: 		return -1;
nuclear@49: 	}
nuclear@49: 	if(anm_init_animation(node->animations) == -1) {
nuclear@49: 		dynarr_free(node->animations);
nuclear@49: 		return -1;
nuclear@27: 	}
nuclear@27: 
nuclear@49: 	/* initialize thread-local matrix cache */
nuclear@49: 	pthread_key_create(&node->cache_key, 0);
nuclear@49: 	pthread_mutex_init(&node->cache_list_lock, 0);
nuclear@49: 
nuclear@27: 	return 0;
nuclear@27: }
nuclear@27: 
nuclear@27: void anm_destroy_node(struct anm_node *node)
nuclear@27: {
nuclear@27: 	int i;
nuclear@27: 	free(node->name);
nuclear@27: 
nuclear@27: 	for(i=0; i<ANM_NUM_TRACKS; i++) {
nuclear@49: 		anm_destroy_animation(node->animations + i);
nuclear@49: 	}
nuclear@49: 	dynarr_free(node->animations);
nuclear@49: 
nuclear@49: 	/* destroy thread-specific cache */
nuclear@49: 	pthread_key_delete(node->cache_key);
nuclear@49: 
nuclear@49: 	while(node->cache_list) {
nuclear@49: 		struct mat_cache *tmp = node->cache_list;
nuclear@49: 		node->cache_list = tmp->next;
nuclear@49: 		free(tmp);
nuclear@27: 	}
nuclear@27: }
nuclear@27: 
nuclear@27: void anm_destroy_node_tree(struct anm_node *tree)
nuclear@27: {
nuclear@27: 	struct anm_node *c, *tmp;
nuclear@27: 
nuclear@27: 	if(!tree) return;
nuclear@27: 
nuclear@27: 	c = tree->child;
nuclear@27: 	while(c) {
nuclear@27: 		tmp = c;
nuclear@27: 		c = c->next;
nuclear@27: 
nuclear@27: 		anm_destroy_node_tree(tmp);
nuclear@27: 	}
nuclear@27: 	anm_destroy_node(tree);
nuclear@27: }
nuclear@27: 
nuclear@27: struct anm_node *anm_create_node(void)
nuclear@27: {
nuclear@27: 	struct anm_node *n;
nuclear@27: 
nuclear@27: 	if((n = malloc(sizeof *n))) {
nuclear@27: 		if(anm_init_node(n) == -1) {
nuclear@27: 			free(n);
nuclear@27: 			return 0;
nuclear@27: 		}
nuclear@27: 	}
nuclear@27: 	return n;
nuclear@27: }
nuclear@27: 
nuclear@27: void anm_free_node(struct anm_node *node)
nuclear@27: {
nuclear@27: 	anm_destroy_node(node);
nuclear@27: 	free(node);
nuclear@27: }
nuclear@27: 
nuclear@27: void anm_free_node_tree(struct anm_node *tree)
nuclear@27: {
nuclear@27: 	struct anm_node *c, *tmp;
nuclear@27: 
nuclear@27: 	if(!tree) return;
nuclear@27: 
nuclear@27: 	c = tree->child;
nuclear@27: 	while(c) {
nuclear@27: 		tmp = c;
nuclear@27: 		c = c->next;
nuclear@27: 
nuclear@27: 		anm_free_node_tree(tmp);
nuclear@27: 	}
nuclear@27: 
nuclear@27: 	anm_free_node(tree);
nuclear@27: }
nuclear@27: 
nuclear@27: int anm_set_node_name(struct anm_node *node, const char *name)
nuclear@27: {
nuclear@27: 	char *str;
nuclear@27: 
nuclear@27: 	if(!(str = malloc(strlen(name) + 1))) {
nuclear@27: 		return -1;
nuclear@27: 	}
nuclear@27: 	strcpy(str, name);
nuclear@27: 	free(node->name);
nuclear@27: 	node->name = str;
nuclear@27: 	return 0;
nuclear@27: }
nuclear@27: 
nuclear@27: const char *anm_get_node_name(struct anm_node *node)
nuclear@27: {
nuclear@27: 	return node->name ? node->name : "";
nuclear@27: }
nuclear@27: 
nuclear@27: void anm_link_node(struct anm_node *p, struct anm_node *c)
nuclear@27: {
nuclear@27: 	c->next = p->child;
nuclear@27: 	p->child = c;
nuclear@27: 
nuclear@27: 	c->parent = p;
nuclear@27: 	invalidate_cache(c);
nuclear@27: }
nuclear@27: 
nuclear@27: int anm_unlink_node(struct anm_node *p, struct anm_node *c)
nuclear@27: {
nuclear@27: 	struct anm_node *iter;
nuclear@27: 
nuclear@27: 	if(p->child == c) {
nuclear@27: 		p->child = c->next;
nuclear@27: 		c->next = 0;
nuclear@27: 		invalidate_cache(c);
nuclear@27: 		return 0;
nuclear@27: 	}
nuclear@27: 
nuclear@27: 	iter = p->child;
nuclear@27: 	while(iter->next) {
nuclear@27: 		if(iter->next == c) {
nuclear@27: 			iter->next = c->next;
nuclear@27: 			c->next = 0;
nuclear@27: 			invalidate_cache(c);
nuclear@27: 			return 0;
nuclear@27: 		}
nuclear@27: 	}
nuclear@27: 	return -1;
nuclear@27: }
nuclear@27: 
nuclear@49: void anm_set_pivot(struct anm_node *node, vec3_t piv)
nuclear@49: {
nuclear@49: 	node->pivot = piv;
nuclear@49: }
nuclear@49: 
nuclear@49: vec3_t anm_get_pivot(struct anm_node *node)
nuclear@49: {
nuclear@49: 	return node->pivot;
nuclear@49: }
nuclear@49: 
nuclear@49: 
nuclear@49: /* animation management */
nuclear@49: 
nuclear@49: int anm_use_node_animation(struct anm_node *node, int aidx)
nuclear@49: {
nuclear@49: 	if(aidx == node->cur_anim[0] && node->cur_anim[1] == -1) {
nuclear@49: 		return 0;	/* no change, no invalidation */
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	if(aidx < 0 || aidx >= anm_get_animation_count(node)) {
nuclear@49: 		return -1;
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	node->cur_anim[0] = aidx;
nuclear@49: 	node->cur_anim[1] = -1;
nuclear@49: 	node->cur_mix = 0;
nuclear@49: 	node->blend_dur = -1;
nuclear@49: 
nuclear@49: 	invalidate_cache(node);
nuclear@49: 	return 0;
nuclear@49: }
nuclear@49: 
nuclear@49: int anm_use_node_animations(struct anm_node *node, int aidx, int bidx, float t)
nuclear@49: {
nuclear@49: 	int num_anim;
nuclear@49: 
nuclear@49: 	if(node->cur_anim[0] == aidx && node->cur_anim[1] == bidx &&
nuclear@49: 			fabs(t - node->cur_mix) < 1e-6) {
nuclear@49: 		return 0;	/* no change, no invalidation */
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	num_anim = anm_get_animation_count(node);
nuclear@49: 	if(aidx < 0 || aidx >= num_anim) {
nuclear@49: 		return anm_use_animation(node, bidx);
nuclear@49: 	}
nuclear@49: 	if(bidx < 0 || bidx >= num_anim) {
nuclear@49: 		return anm_use_animation(node, aidx);
nuclear@49: 	}
nuclear@49: 	node->cur_anim[0] = aidx;
nuclear@49: 	node->cur_anim[1] = bidx;
nuclear@49: 	node->cur_mix = t;
nuclear@49: 
nuclear@49: 	invalidate_cache(node);
nuclear@49: 	return 0;
nuclear@49: }
nuclear@49: 
nuclear@49: int anm_use_animation(struct anm_node *node, int aidx)
nuclear@49: {
nuclear@49: 	struct anm_node *child;
nuclear@49: 
nuclear@49: 	if(anm_use_node_animation(node, aidx) == -1) {
nuclear@49: 		return -1;
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	child = node->child;
nuclear@49: 	while(child) {
nuclear@49: 		if(anm_use_animation(child, aidx) == -1) {
nuclear@49: 			return -1;
nuclear@49: 		}
nuclear@49: 		child = child->next;
nuclear@49: 	}
nuclear@49: 	return 0;
nuclear@49: }
nuclear@49: 
nuclear@49: int anm_use_animations(struct anm_node *node, int aidx, int bidx, float t)
nuclear@49: {
nuclear@49: 	struct anm_node *child;
nuclear@49: 
nuclear@49: 	if(anm_use_node_animations(node, aidx, bidx, t) == -1) {
nuclear@49: 		return -1;
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	child = node->child;
nuclear@49: 	while(child) {
nuclear@49: 		if(anm_use_animations(child, aidx, bidx, t) == -1) {
nuclear@49: 			return -1;
nuclear@49: 		}
nuclear@49: 		child = child->next;
nuclear@49: 	}
nuclear@49: 	return 0;
nuclear@49: 
nuclear@49: }
nuclear@49: 
nuclear@49: void anm_set_node_animation_offset(struct anm_node *node, anm_time_t offs, int which)
nuclear@49: {
nuclear@49: 	if(which < 0 || which >= 2) {
nuclear@49: 		return;
nuclear@49: 	}
nuclear@49: 	node->cur_anim_offset[which] = offs;
nuclear@49: }
nuclear@49: 
nuclear@49: anm_time_t anm_get_animation_offset(const struct anm_node *node, int which)
nuclear@49: {
nuclear@49: 	if(which < 0 || which >= 2) {
nuclear@49: 		return 0;
nuclear@49: 	}
nuclear@49: 	return node->cur_anim_offset[which];
nuclear@49: }
nuclear@49: 
nuclear@49: void anm_set_animation_offset(struct anm_node *node, anm_time_t offs, int which)
nuclear@49: {
nuclear@49: 	struct anm_node *c = node->child;
nuclear@49: 	while(c) {
nuclear@49: 		anm_set_animation_offset(c, offs, which);
nuclear@49: 		c = c->next;
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	anm_set_node_animation_offset(node, offs, which);
nuclear@49: }
nuclear@49: 
nuclear@49: int anm_get_active_animation_index(const struct anm_node *node, int which)
nuclear@49: {
nuclear@49: 	if(which < 0 || which >= 2) return -1;
nuclear@49: 	return node->cur_anim[which];
nuclear@49: }
nuclear@49: 
nuclear@49: struct anm_animation *anm_get_active_animation(const struct anm_node *node, int which)
nuclear@49: {
nuclear@49: 	int idx = anm_get_active_animation_index(node, which);
nuclear@49: 	if(idx < 0 || idx >= anm_get_animation_count(node)) {
nuclear@49: 		return 0;
nuclear@49: 	}
nuclear@49: 	return node->animations + idx;
nuclear@49: }
nuclear@49: 
nuclear@49: float anm_get_active_animation_mix(const struct anm_node *node)
nuclear@49: {
nuclear@49: 	return node->cur_mix;
nuclear@49: }
nuclear@49: 
nuclear@49: int anm_get_animation_count(const struct anm_node *node)
nuclear@49: {
nuclear@49: 	return dynarr_size(node->animations);
nuclear@49: }
nuclear@49: 
nuclear@49: int anm_add_node_animation(struct anm_node *node)
nuclear@49: {
nuclear@49: 	struct anm_animation newanim;
nuclear@49: 	anm_init_animation(&newanim);
nuclear@49: 
nuclear@49: 	node->animations = dynarr_push(node->animations, &newanim);
nuclear@49: 	return 0;
nuclear@49: }
nuclear@49: 
nuclear@49: int anm_remove_node_animation(struct anm_node *node, int idx)
nuclear@49: {
nuclear@49: 	fprintf(stderr, "anm_remove_animation: unimplemented!");
nuclear@49: 	abort();
nuclear@49: 	return 0;
nuclear@49: }
nuclear@49: 
nuclear@49: int anm_add_animation(struct anm_node *node)
nuclear@49: {
nuclear@49: 	struct anm_node *child;
nuclear@49: 
nuclear@49: 	if(anm_add_node_animation(node) == -1) {
nuclear@49: 		return -1;
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	child = node->child;
nuclear@49: 	while(child) {
nuclear@49: 		if(anm_add_animation(child)) {
nuclear@49: 			return -1;
nuclear@49: 		}
nuclear@49: 		child = child->next;
nuclear@49: 	}
nuclear@49: 	return 0;
nuclear@49: }
nuclear@49: 
nuclear@49: int anm_remove_animation(struct anm_node *node, int idx)
nuclear@49: {
nuclear@49: 	struct anm_node *child;
nuclear@49: 
nuclear@49: 	if(anm_remove_node_animation(node, idx) == -1) {
nuclear@49: 		return -1;
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	child = node->child;
nuclear@49: 	while(child) {
nuclear@49: 		if(anm_remove_animation(child, idx) == -1) {
nuclear@49: 			return -1;
nuclear@49: 		}
nuclear@49: 		child = child->next;
nuclear@49: 	}
nuclear@49: 	return 0;
nuclear@49: }
nuclear@49: 
nuclear@49: struct anm_animation *anm_get_animation(struct anm_node *node, int idx)
nuclear@49: {
nuclear@49: 	if(idx < 0 || idx > anm_get_animation_count(node)) {
nuclear@49: 		return 0;
nuclear@49: 	}
nuclear@49: 	return node->animations + idx;
nuclear@49: }
nuclear@49: 
nuclear@49: struct anm_animation *anm_get_animation_by_name(struct anm_node *node, const char *name)
nuclear@49: {
nuclear@49: 	return anm_get_animation(node, anm_find_animation(node, name));
nuclear@49: }
nuclear@49: 
nuclear@49: int anm_find_animation(struct anm_node *node, const char *name)
nuclear@49: {
nuclear@49: 	int i, count = anm_get_animation_count(node);
nuclear@49: 	for(i=0; i<count; i++) {
nuclear@49: 		if(strcmp(node->animations[i].name, name) == 0) {
nuclear@49: 			return i;
nuclear@49: 		}
nuclear@49: 	}
nuclear@49: 	return -1;
nuclear@49: }
nuclear@49: 
nuclear@49: /* all the rest act on the current animation(s) */
nuclear@49: 
nuclear@49: void anm_set_interpolator(struct anm_node *node, enum anm_interpolator in)
nuclear@49: {
nuclear@49: 	int i;
nuclear@49: 	struct anm_animation *anim = anm_get_active_animation(node, 0);
nuclear@49: 	if(!anim) return;
nuclear@49: 
nuclear@49: 	for(i=0; i<ANM_NUM_TRACKS; i++) {
nuclear@49: 		anm_set_track_interpolator(anim->tracks + i, in);
nuclear@49: 	}
nuclear@49: 	invalidate_cache(node);
nuclear@49: }
nuclear@49: 
nuclear@49: void anm_set_extrapolator(struct anm_node *node, enum anm_extrapolator ex)
nuclear@49: {
nuclear@49: 	int i;
nuclear@49: 	struct anm_animation *anim = anm_get_active_animation(node, 0);
nuclear@49: 	if(!anim) return;
nuclear@49: 
nuclear@49: 	for(i=0; i<ANM_NUM_TRACKS; i++) {
nuclear@49: 		anm_set_track_extrapolator(anim->tracks + i, ex);
nuclear@49: 	}
nuclear@49: 	invalidate_cache(node);
nuclear@49: }
nuclear@49: 
nuclear@49: void anm_set_node_active_animation_name(struct anm_node *node, const char *name)
nuclear@49: {
nuclear@49: 	struct anm_animation *anim = anm_get_active_animation(node, 0);
nuclear@49: 	if(!anim) return;
nuclear@49: 
nuclear@49: 	anm_set_animation_name(anim, name);
nuclear@49: }
nuclear@49: 
nuclear@49: void anm_set_active_animation_name(struct anm_node *node, const char *name)
nuclear@49: {
nuclear@49: 	struct anm_node *child;
nuclear@49: 
nuclear@49: 	anm_set_node_active_animation_name(node, name);
nuclear@49: 
nuclear@49: 	child = node->child;
nuclear@49: 	while(child) {
nuclear@49: 		anm_set_active_animation_name(child, name);
nuclear@49: 		child = child->next;
nuclear@49: 	}
nuclear@49: }
nuclear@49: 
nuclear@49: const char *anm_get_active_animation_name(struct anm_node *node)
nuclear@49: {
nuclear@49: 	struct anm_animation *anim = anm_get_active_animation(node, 0);
nuclear@49: 	if(anim) {
nuclear@49: 		return anim->name;
nuclear@49: 	}
nuclear@49: 	return 0;
nuclear@49: }
nuclear@49: 
nuclear@49: /* ---- high level animation blending ---- */
nuclear@49: void anm_transition(struct anm_node *node, int anmidx, anm_time_t start, anm_time_t dur)
nuclear@49: {
nuclear@49: 	struct anm_node *c = node->child;
nuclear@49: 
nuclear@49: 	if(anmidx == node->cur_anim[0]) {
nuclear@49: 		return;
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	while(c) {
nuclear@49: 		anm_transition(c, anmidx, start, dur);
nuclear@49: 		c = c->next;
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	anm_node_transition(node, anmidx, start, dur);
nuclear@49: }
nuclear@49: 
nuclear@49: void anm_node_transition(struct anm_node *node, int anmidx, anm_time_t start, anm_time_t dur)
nuclear@49: {
nuclear@49: 	if(anmidx == node->cur_anim[0]) {
nuclear@49: 		return;
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	node->cur_anim[1] = anmidx;
nuclear@49: 	node->cur_anim_offset[1] = start;
nuclear@49: 	node->blend_dur = dur;
nuclear@49: }
nuclear@49: 
nuclear@49: 
nuclear@49: #define BLEND_START_TM	node->cur_anim_offset[1]
nuclear@49: 
nuclear@49: static anm_time_t animation_time(struct anm_node *node, anm_time_t tm, int which)
nuclear@49: {
nuclear@49: 	float t;
nuclear@49: 
nuclear@49: 	if(node->blend_dur >= 0) {
nuclear@49: 		/* we're in transition... */
nuclear@49: 		t = (float)(tm - BLEND_START_TM) / (float)node->blend_dur;
nuclear@49: 		if(t < 0.0) t = 0.0;
nuclear@49: 
nuclear@49: 		node->cur_mix = t;
nuclear@49: 
nuclear@49: 		if(t > 1.0) {
nuclear@49: 			/* switch completely over to the target animation and stop blending */
nuclear@49: 			anm_use_node_animation(node, node->cur_anim[1]);
nuclear@49: 			node->cur_anim_offset[0] = node->cur_anim_offset[1];
nuclear@49: 		}
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	return tm - node->cur_anim_offset[which];
nuclear@49: }
nuclear@49: 
nuclear@49: 
nuclear@27: void anm_set_position(struct anm_node *node, vec3_t pos, anm_time_t tm)
nuclear@27: {
nuclear@49: 	struct anm_animation *anim = anm_get_active_animation(node, 0);
nuclear@49: 	if(!anim) return;
nuclear@49: 
nuclear@49: 	anm_set_value(anim->tracks + ANM_TRACK_POS_X, tm, pos.x);
nuclear@49: 	anm_set_value(anim->tracks + ANM_TRACK_POS_Y, tm, pos.y);
nuclear@49: 	anm_set_value(anim->tracks + ANM_TRACK_POS_Z, tm, pos.z);
nuclear@27: 	invalidate_cache(node);
nuclear@27: }
nuclear@27: 
nuclear@49: 
nuclear@27: vec3_t anm_get_node_position(struct anm_node *node, anm_time_t tm)
nuclear@27: {
nuclear@27: 	vec3_t v;
nuclear@49: 	anm_time_t tm0 = animation_time(node, tm, 0);
nuclear@49: 	struct anm_animation *anim0 = anm_get_active_animation(node, 0);
nuclear@49: 	struct anm_animation *anim1 = anm_get_active_animation(node, 1);
nuclear@49: 
nuclear@49: 	if(!anim0) {
nuclear@49: 		return v3_cons(0, 0, 0);
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	v.x = anm_get_value(anim0->tracks + ANM_TRACK_POS_X, tm0);
nuclear@49: 	v.y = anm_get_value(anim0->tracks + ANM_TRACK_POS_Y, tm0);
nuclear@49: 	v.z = anm_get_value(anim0->tracks + ANM_TRACK_POS_Z, tm0);
nuclear@49: 
nuclear@49: 	if(anim1) {
nuclear@49: 		vec3_t v1;
nuclear@49: 		anm_time_t tm1 = animation_time(node, tm, 1);
nuclear@49: 		v1.x = anm_get_value(anim1->tracks + ANM_TRACK_POS_X, tm1);
nuclear@49: 		v1.y = anm_get_value(anim1->tracks + ANM_TRACK_POS_Y, tm1);
nuclear@49: 		v1.z = anm_get_value(anim1->tracks + ANM_TRACK_POS_Z, tm1);
nuclear@49: 
nuclear@49: 		v.x = v.x + (v1.x - v.x) * node->cur_mix;
nuclear@49: 		v.y = v.y + (v1.y - v.y) * node->cur_mix;
nuclear@49: 		v.z = v.z + (v1.z - v.z) * node->cur_mix;
nuclear@49: 	}
nuclear@49: 
nuclear@27: 	return v;
nuclear@27: }
nuclear@27: 
nuclear@27: void anm_set_rotation(struct anm_node *node, quat_t rot, anm_time_t tm)
nuclear@27: {
nuclear@49: 	struct anm_animation *anim = anm_get_active_animation(node, 0);
nuclear@49: 	if(!anim) return;
nuclear@49: 
nuclear@49: 	anm_set_value(anim->tracks + ANM_TRACK_ROT_X, tm, rot.x);
nuclear@49: 	anm_set_value(anim->tracks + ANM_TRACK_ROT_Y, tm, rot.y);
nuclear@49: 	anm_set_value(anim->tracks + ANM_TRACK_ROT_Z, tm, rot.z);
nuclear@49: 	anm_set_value(anim->tracks + ANM_TRACK_ROT_W, tm, rot.w);
nuclear@27: 	invalidate_cache(node);
nuclear@27: }
nuclear@27: 
nuclear@49: static quat_t get_node_rotation(struct anm_node *node, anm_time_t tm, struct anm_animation *anim)
nuclear@27: {
nuclear@27: #ifndef ROT_USE_SLERP
nuclear@27: 	quat_t q;
nuclear@49: 	q.x = anm_get_value(anim->tracks + ANM_TRACK_ROT_X, tm);
nuclear@49: 	q.y = anm_get_value(anim->tracks + ANM_TRACK_ROT_Y, tm);
nuclear@49: 	q.z = anm_get_value(anim->tracks + ANM_TRACK_ROT_Z, tm);
nuclear@49: 	q.w = anm_get_value(anim->tracks + ANM_TRACK_ROT_W, tm);
nuclear@27: 	return q;
nuclear@27: #else
nuclear@27: 	int idx0, idx1, last_idx;
nuclear@27: 	anm_time_t tstart, tend;
nuclear@27: 	float t, dt;
nuclear@27: 	struct anm_track *track_x, *track_y, *track_z, *track_w;
nuclear@27: 	quat_t q, q1, q2;
nuclear@27: 
nuclear@49: 	track_x = anim->tracks + ANM_TRACK_ROT_X;
nuclear@49: 	track_y = anim->tracks + ANM_TRACK_ROT_Y;
nuclear@49: 	track_z = anim->tracks + ANM_TRACK_ROT_Z;
nuclear@49: 	track_w = anim->tracks + ANM_TRACK_ROT_W;
nuclear@27: 
nuclear@27: 	if(!track_x->count) {
nuclear@27: 		q.x = track_x->def_val;
nuclear@27: 		q.y = track_y->def_val;
nuclear@27: 		q.z = track_z->def_val;
nuclear@27: 		q.w = track_w->def_val;
nuclear@27: 		return q;
nuclear@27: 	}
nuclear@27: 
nuclear@27: 	last_idx = track_x->count - 1;
nuclear@27: 
nuclear@27: 	tstart = track_x->keys[0].time;
nuclear@27: 	tend = track_x->keys[last_idx].time;
nuclear@27: 
nuclear@27: 	if(tstart == tend) {
nuclear@27: 		q.x = track_x->keys[0].val;
nuclear@27: 		q.y = track_y->keys[0].val;
nuclear@27: 		q.z = track_z->keys[0].val;
nuclear@27: 		q.w = track_w->keys[0].val;
nuclear@27: 		return q;
nuclear@27: 	}
nuclear@27: 
nuclear@27: 	tm = anm_remap_time(track_x, tm, tstart, tend);
nuclear@27: 
nuclear@27: 	idx0 = anm_get_key_interval(track_x, tm);
nuclear@27: 	assert(idx0 >= 0 && idx0 < track_x->count);
nuclear@27: 	idx1 = idx0 + 1;
nuclear@27: 
nuclear@27: 	if(idx0 == last_idx) {
nuclear@27: 		q.x = track_x->keys[idx0].val;
nuclear@27: 		q.y = track_y->keys[idx0].val;
nuclear@27: 		q.z = track_z->keys[idx0].val;
nuclear@27: 		q.w = track_w->keys[idx0].val;
nuclear@27: 		return q;
nuclear@27: 	}
nuclear@27: 
nuclear@27: 	dt = (float)(track_x->keys[idx1].time - track_x->keys[idx0].time);
nuclear@27: 	t = (float)(tm - track_x->keys[idx0].time) / dt;
nuclear@27: 
nuclear@27: 	q1.x = track_x->keys[idx0].val;
nuclear@27: 	q1.y = track_y->keys[idx0].val;
nuclear@27: 	q1.z = track_z->keys[idx0].val;
nuclear@27: 	q1.w = track_w->keys[idx0].val;
nuclear@27: 
nuclear@27: 	q2.x = track_x->keys[idx1].val;
nuclear@27: 	q2.y = track_y->keys[idx1].val;
nuclear@27: 	q2.z = track_z->keys[idx1].val;
nuclear@27: 	q2.w = track_w->keys[idx1].val;
nuclear@27: 
nuclear@27: 	/*q1 = quat_normalize(q1);
nuclear@27: 	q2 = quat_normalize(q2);*/
nuclear@27: 
nuclear@27: 	return quat_slerp(q1, q2, t);
nuclear@27: #endif
nuclear@27: }
nuclear@27: 
nuclear@49: quat_t anm_get_node_rotation(struct anm_node *node, anm_time_t tm)
nuclear@49: {
nuclear@49: 	quat_t q;
nuclear@49: 	anm_time_t tm0 = animation_time(node, tm, 0);
nuclear@49: 	struct anm_animation *anim0 = anm_get_active_animation(node, 0);
nuclear@49: 	struct anm_animation *anim1 = anm_get_active_animation(node, 1);
nuclear@49: 
nuclear@49: 	if(!anim0) {
nuclear@49: 		return quat_identity();
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	q = get_node_rotation(node, tm0, anim0);
nuclear@49: 
nuclear@49: 	if(anim1) {
nuclear@49: 		anm_time_t tm1 = animation_time(node, tm, 1);
nuclear@49: 		quat_t q1 = get_node_rotation(node, tm1, anim1);
nuclear@49: 
nuclear@49: 		q = quat_slerp(q, q1, node->cur_mix);
nuclear@49: 	}
nuclear@49: 	return q;
nuclear@49: }
nuclear@49: 
nuclear@27: void anm_set_scaling(struct anm_node *node, vec3_t scl, anm_time_t tm)
nuclear@27: {
nuclear@49: 	struct anm_animation *anim = anm_get_active_animation(node, 0);
nuclear@49: 	if(!anim) return;
nuclear@49: 
nuclear@49: 	anm_set_value(anim->tracks + ANM_TRACK_SCL_X, tm, scl.x);
nuclear@49: 	anm_set_value(anim->tracks + ANM_TRACK_SCL_Y, tm, scl.y);
nuclear@49: 	anm_set_value(anim->tracks + ANM_TRACK_SCL_Z, tm, scl.z);
nuclear@27: 	invalidate_cache(node);
nuclear@27: }
nuclear@27: 
nuclear@27: vec3_t anm_get_node_scaling(struct anm_node *node, anm_time_t tm)
nuclear@27: {
nuclear@27: 	vec3_t v;
nuclear@49: 	anm_time_t tm0 = animation_time(node, tm, 0);
nuclear@49: 	struct anm_animation *anim0 = anm_get_active_animation(node, 0);
nuclear@49: 	struct anm_animation *anim1 = anm_get_active_animation(node, 1);
nuclear@49: 
nuclear@49: 	if(!anim0) {
nuclear@49: 		return v3_cons(1, 1, 1);
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	v.x = anm_get_value(anim0->tracks + ANM_TRACK_SCL_X, tm0);
nuclear@49: 	v.y = anm_get_value(anim0->tracks + ANM_TRACK_SCL_Y, tm0);
nuclear@49: 	v.z = anm_get_value(anim0->tracks + ANM_TRACK_SCL_Z, tm0);
nuclear@49: 
nuclear@49: 	if(anim1) {
nuclear@49: 		vec3_t v1;
nuclear@49: 		anm_time_t tm1 = animation_time(node, tm, 1);
nuclear@49: 		v1.x = anm_get_value(anim1->tracks + ANM_TRACK_SCL_X, tm1);
nuclear@49: 		v1.y = anm_get_value(anim1->tracks + ANM_TRACK_SCL_Y, tm1);
nuclear@49: 		v1.z = anm_get_value(anim1->tracks + ANM_TRACK_SCL_Z, tm1);
nuclear@49: 
nuclear@49: 		v.x = v.x + (v1.x - v.x) * node->cur_mix;
nuclear@49: 		v.y = v.y + (v1.y - v.y) * node->cur_mix;
nuclear@49: 		v.z = v.z + (v1.z - v.z) * node->cur_mix;
nuclear@49: 	}
nuclear@49: 
nuclear@27: 	return v;
nuclear@27: }
nuclear@27: 
nuclear@27: 
nuclear@27: vec3_t anm_get_position(struct anm_node *node, anm_time_t tm)
nuclear@27: {
nuclear@27: 	mat4_t xform;
nuclear@27: 	vec3_t pos = {0.0, 0.0, 0.0};
nuclear@27: 
nuclear@27: 	if(!node->parent) {
nuclear@27: 		return anm_get_node_position(node, tm);
nuclear@27: 	}
nuclear@27: 
nuclear@27: 	anm_get_matrix(node, xform, tm);
nuclear@27: 	return v3_transform(pos, xform);
nuclear@27: }
nuclear@27: 
nuclear@27: quat_t anm_get_rotation(struct anm_node *node, anm_time_t tm)
nuclear@27: {
nuclear@27: 	quat_t rot, prot;
nuclear@27: 	rot = anm_get_node_rotation(node, tm);
nuclear@27: 
nuclear@27: 	if(!node->parent) {
nuclear@27: 		return rot;
nuclear@27: 	}
nuclear@27: 
nuclear@27: 	prot = anm_get_rotation(node->parent, tm);
nuclear@27: 	return quat_mul(prot, rot);
nuclear@27: }
nuclear@27: 
nuclear@27: vec3_t anm_get_scaling(struct anm_node *node, anm_time_t tm)
nuclear@27: {
nuclear@27: 	vec3_t s, ps;
nuclear@27: 	s = anm_get_node_scaling(node, tm);
nuclear@27: 
nuclear@27: 	if(!node->parent) {
nuclear@27: 		return s;
nuclear@27: 	}
nuclear@27: 
nuclear@27: 	ps = anm_get_scaling(node->parent, tm);
nuclear@27: 	return v3_mul(s, ps);
nuclear@27: }
nuclear@27: 
nuclear@27: void anm_get_node_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
nuclear@27: {
nuclear@27: 	int i;
nuclear@27: 	mat4_t rmat;
nuclear@27: 	vec3_t pos, scale;
nuclear@27: 	quat_t rot;
nuclear@27: 
nuclear@27: 	pos = anm_get_node_position(node, tm);
nuclear@27: 	rot = anm_get_node_rotation(node, tm);
nuclear@27: 	scale = anm_get_node_scaling(node, tm);
nuclear@27: 
nuclear@27: 	m4_set_translation(mat, node->pivot.x, node->pivot.y, node->pivot.z);
nuclear@27: 
nuclear@27: 	quat_to_mat4(rmat, rot);
nuclear@27: 	for(i=0; i<3; i++) {
nuclear@27: 		mat[i][0] = rmat[i][0];
nuclear@27: 		mat[i][1] = rmat[i][1];
nuclear@27: 		mat[i][2] = rmat[i][2];
nuclear@27: 	}
nuclear@27: 	/* this loop is equivalent to: m4_mult(mat, mat, rmat); */
nuclear@27: 
nuclear@27: 	mat[0][0] *= scale.x; mat[0][1] *= scale.y; mat[0][2] *= scale.z; mat[0][3] += pos.x;
nuclear@27: 	mat[1][0] *= scale.x; mat[1][1] *= scale.y; mat[1][2] *= scale.z; mat[1][3] += pos.y;
nuclear@27: 	mat[2][0] *= scale.x; mat[2][1] *= scale.y; mat[2][2] *= scale.z; mat[2][3] += pos.z;
nuclear@27: 
nuclear@27: 	m4_translate(mat, -node->pivot.x, -node->pivot.y, -node->pivot.z);
nuclear@27: 
nuclear@27: 	/* that's basically: pivot * rotation * translation * scaling * -pivot */
nuclear@27: }
nuclear@27: 
nuclear@27: void anm_get_node_inv_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
nuclear@27: {
nuclear@27: 	mat4_t tmp;
nuclear@27: 	anm_get_node_matrix(node, tmp, tm);
nuclear@27: 	m4_inverse(mat, tmp);
nuclear@27: }
nuclear@27: 
nuclear@49: void anm_eval_node(struct anm_node *node, anm_time_t tm)
nuclear@49: {
nuclear@49: 	anm_get_node_matrix(node, node->matrix, tm);
nuclear@49: }
nuclear@49: 
nuclear@49: void anm_eval(struct anm_node *node, anm_time_t tm)
nuclear@49: {
nuclear@49: 	struct anm_node *c;
nuclear@49: 
nuclear@49: 	anm_eval_node(node, tm);
nuclear@49: 
nuclear@49: 	if(node->parent) {
nuclear@49: 		/* due to post-order traversal, the parent matrix is already evaluated */
nuclear@49: 		m4_mult(node->matrix, node->parent->matrix, node->matrix);
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	/* recersively evaluate all children */
nuclear@49: 	c = node->child;
nuclear@49: 	while(c) {
nuclear@49: 		anm_eval(c, tm);
nuclear@49: 		c = c->next;
nuclear@49: 	}
nuclear@49: }
nuclear@49: 
nuclear@27: void anm_get_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
nuclear@27: {
nuclear@49: 	struct mat_cache *cache = pthread_getspecific(node->cache_key);
nuclear@49: 	if(!cache) {
nuclear@49: 		cache = malloc(sizeof *cache);
nuclear@49: 		assert(cache);
nuclear@49: 
nuclear@49: 		pthread_mutex_lock(&node->cache_list_lock);
nuclear@49: 		cache->next = node->cache_list;
nuclear@49: 		node->cache_list = cache;
nuclear@49: 		pthread_mutex_unlock(&node->cache_list_lock);
nuclear@49: 
nuclear@49: 		cache->time = ANM_TIME_INVAL;
nuclear@49: 		cache->inv_time = ANM_TIME_INVAL;
nuclear@49: 		pthread_setspecific(node->cache_key, cache);
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	if(cache->time != tm) {
nuclear@49: 		anm_get_node_matrix(node, cache->matrix, tm);
nuclear@27: 
nuclear@27: 		if(node->parent) {
nuclear@27: 			mat4_t parent_mat;
nuclear@27: 
nuclear@27: 			anm_get_matrix(node->parent, parent_mat, tm);
nuclear@49: 			m4_mult(cache->matrix, parent_mat, cache->matrix);
nuclear@27: 		}
nuclear@49: 		cache->time = tm;
nuclear@27: 	}
nuclear@49: 	m4_copy(mat, cache->matrix);
nuclear@27: }
nuclear@27: 
nuclear@27: void anm_get_inv_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
nuclear@27: {
nuclear@49: 	struct mat_cache *cache = pthread_getspecific(node->cache_key);
nuclear@49: 	if(!cache) {
nuclear@49: 		cache = malloc(sizeof *cache);
nuclear@49: 		assert(cache);
nuclear@49: 
nuclear@49: 		pthread_mutex_lock(&node->cache_list_lock);
nuclear@49: 		cache->next = node->cache_list;
nuclear@49: 		node->cache_list = cache;
nuclear@49: 		pthread_mutex_unlock(&node->cache_list_lock);
nuclear@49: 
nuclear@49: 		cache->inv_time = ANM_TIME_INVAL;
nuclear@49: 		cache->inv_time = ANM_TIME_INVAL;
nuclear@49: 		pthread_setspecific(node->cache_key, cache);
nuclear@49: 	}
nuclear@49: 
nuclear@49: 	if(cache->inv_time != tm) {
nuclear@27: 		anm_get_matrix(node, mat, tm);
nuclear@49: 		m4_inverse(cache->inv_matrix, mat);
nuclear@49: 		cache->inv_time = tm;
nuclear@27: 	}
nuclear@49: 	m4_copy(mat, cache->inv_matrix);
nuclear@27: }
nuclear@27: 
nuclear@27: anm_time_t anm_get_start_time(struct anm_node *node)
nuclear@27: {
nuclear@49: 	int i, j;
nuclear@27: 	struct anm_node *c;
nuclear@27: 	anm_time_t res = LONG_MAX;
nuclear@27: 
nuclear@49: 	for(j=0; j<2; j++) {
nuclear@49: 		struct anm_animation *anim = anm_get_active_animation(node, j);
nuclear@49: 		if(!anim) break;
nuclear@49: 
nuclear@49: 		for(i=0; i<ANM_NUM_TRACKS; i++) {
nuclear@49: 			if(anim->tracks[i].count) {
nuclear@49: 				anm_time_t tm = anim->tracks[i].keys[0].time;
nuclear@49: 				if(tm < res) {
nuclear@49: 					res = tm;
nuclear@49: 				}
nuclear@27: 			}
nuclear@27: 		}
nuclear@27: 	}
nuclear@27: 
nuclear@27: 	c = node->child;
nuclear@27: 	while(c) {
nuclear@27: 		anm_time_t tm = anm_get_start_time(c);
nuclear@27: 		if(tm < res) {
nuclear@27: 			res = tm;
nuclear@27: 		}
nuclear@27: 		c = c->next;
nuclear@27: 	}
nuclear@27: 	return res;
nuclear@27: }
nuclear@27: 
nuclear@27: anm_time_t anm_get_end_time(struct anm_node *node)
nuclear@27: {
nuclear@49: 	int i, j;
nuclear@27: 	struct anm_node *c;
nuclear@27: 	anm_time_t res = LONG_MIN;
nuclear@27: 
nuclear@49: 	for(j=0; j<2; j++) {
nuclear@49: 		struct anm_animation *anim = anm_get_active_animation(node, j);
nuclear@49: 		if(!anim) break;
nuclear@49: 
nuclear@49: 		for(i=0; i<ANM_NUM_TRACKS; i++) {
nuclear@49: 			if(anim->tracks[i].count) {
nuclear@49: 				anm_time_t tm = anim->tracks[i].keys[anim->tracks[i].count - 1].time;
nuclear@49: 				if(tm > res) {
nuclear@49: 					res = tm;
nuclear@49: 				}
nuclear@27: 			}
nuclear@27: 		}
nuclear@27: 	}
nuclear@27: 
nuclear@27: 	c = node->child;
nuclear@27: 	while(c) {
nuclear@27: 		anm_time_t tm = anm_get_end_time(c);
nuclear@27: 		if(tm > res) {
nuclear@27: 			res = tm;
nuclear@27: 		}
nuclear@27: 		c = c->next;
nuclear@27: 	}
nuclear@27: 	return res;
nuclear@27: }
nuclear@27: 
nuclear@27: static void invalidate_cache(struct anm_node *node)
nuclear@27: {
nuclear@49: 	struct mat_cache *cache = pthread_getspecific(node->cache_key);
nuclear@49: 	if(cache) {
nuclear@49: 	   cache->time = cache->inv_time = ANM_TIME_INVAL;
nuclear@49: 	}
nuclear@27: }