1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/.hgignore	Sat Feb 01 19:58:19 2014 +0200
     1.3 @@ -0,0 +1,3 @@
     1.4 +\.o$
     1.5 +\.d$
     1.6 +\.swp$

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/Makefile	Sat Feb 01 19:58:19 2014 +0200
     2.3 @@ -0,0 +1,60 @@
     2.4 +csrc = $(wildcard src/*.c) \
     2.5 +	   $(wildcard libs/vmath/*.c) \
     2.6 +	   $(wildcard libs/anim/*.c) \
     2.7 +	   $(wildcard libs/imago/*.c) \
     2.8 +	   $(wildcard libs/drawtext/*.c) \
     2.9 +	   $(wildcard libs/ogg/*.c) \
    2.10 +	   $(wildcard libs/vorbis/*.c) \
    2.11 +	   $(wildcard libs/psys/*.c) \
    2.12 +	   $(wildcard libs/kissfft/*.c)
    2.13 +
    2.14 +ccsrc = $(wildcard src/*.cc) \
    2.15 +		$(wildcard src/audio/*.cc) \
    2.16 +		$(wildcard libs/vmath/*.cc)
    2.17 +
    2.18 +obj = $(ccsrc:.cc=.o) $(csrc:.c=.o)
    2.19 +dep = $(obj:.o=.d)
    2.20 +bin = candyshoot
    2.21 +
    2.22 +USE_ASSIMP = true
    2.23 +
    2.24 +ifeq ($(USE_ASSIMP), true)
    2.25 +	libs_cflags_ai = `pkg-config --cflags assimp` -DUSE_ASSIMP
    2.26 +	libs_ldflags_ai = `pkg-config --libs assimp`
    2.27 +endif
    2.28 +
    2.29 +libs_cflags = -Isrc -Ilibs -Ilibs/imago -Ilibs/drawtext -Ilibs/vorbis -Ilibs/kissfft \
    2.30 +			  `pkg-config --cflags freetype2` $(libs_cflags_ai)
    2.31 +libs_ldflags = -lz -lpng -ljpeg `pkg-config --libs freetype2` \
    2.32 +			   $(libs_ldflags_ai)
    2.33 +
    2.34 +
    2.35 +CC = clang
    2.36 +CXX = clang++
    2.37 +CFLAGS = -pedantic -Wall -g $(libs_cflags)
    2.38 +CXXFLAGS = $(CFLAGS)
    2.39 +LDFLAGS = $(libgl) $(libal) -lpthread -lm -ldl $(libs_ldflags)
    2.40 +
    2.41 +ifeq ($(shell uname -s), Darwin)
    2.42 +	libgl = -framework OpenGL -framework GLUT -lGLEW
    2.43 +	libal = -framework OpenAL
    2.44 +else
    2.45 +	libgl = -lGL -lGLU -lglut -lGLEW
    2.46 +	libal = -lopenal
    2.47 +endif
    2.48 +
    2.49 +
    2.50 +$(bin): $(obj)
    2.51 +	$(CXX) -o $@ $(obj) $(LDFLAGS)
    2.52 +
    2.53 +-include $(dep)
    2.54 +
    2.55 +%.d: %.c
    2.56 +	@$(CPP) $(CFLAGS) $< -MM -MT $(@:.d=.o) >$@
    2.57 +
    2.58 +%.d: %.cc
    2.59 +	@$(CPP) $(CXXFLAGS) $< -MM -MT $(@:.d=.o) >$@
    2.60 +
    2.61 +.PHONY: clean
    2.62 +clean:
    2.63 +	rm -f $(obj) $(bin)

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/libs/anim/anim.c	Sat Feb 01 19:58:19 2014 +0200
     3.3 @@ -0,0 +1,532 @@
     3.4 +#include <stdlib.h>
     3.5 +#include <limits.h>
     3.6 +#include <assert.h>
     3.7 +#include "anim.h"
     3.8 +#include "dynarr.h"
     3.9 +
    3.10 +#define ROT_USE_SLERP
    3.11 +
    3.12 +static void invalidate_cache(struct anm_node *node);
    3.13 +
    3.14 +int anm_init_node(struct anm_node *node)
    3.15 +{
    3.16 +	int i, j;
    3.17 +	static const float defaults[] = {
    3.18 +		0.0f, 0.0f, 0.0f,		/* default position */
    3.19 +		0.0f, 0.0f, 0.0f, 1.0f,	/* default rotation quat */
    3.20 +		1.0f, 1.0f, 1.0f		/* default scale factor */
    3.21 +	};
    3.22 +
    3.23 +	memset(node, 0, sizeof *node);
    3.24 +
    3.25 +	/* initialize thread-local matrix cache */
    3.26 +	pthread_key_create(&node->cache_key, 0);
    3.27 +	pthread_mutex_init(&node->cache_list_lock, 0);
    3.28 +
    3.29 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
    3.30 +		if(anm_init_track(node->tracks + i) == -1) {
    3.31 +			for(j=0; j<i; j++) {
    3.32 +				anm_destroy_track(node->tracks + i);
    3.33 +			}
    3.34 +		}
    3.35 +		anm_set_track_default(node->tracks + i, defaults[i]);
    3.36 +	}
    3.37 +	return 0;
    3.38 +}
    3.39 +
    3.40 +void anm_destroy_node(struct anm_node *node)
    3.41 +{
    3.42 +	int i;
    3.43 +	free(node->name);
    3.44 +
    3.45 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
    3.46 +		anm_destroy_track(node->tracks + i);
    3.47 +	}
    3.48 +
    3.49 +	/* destroy thread-specific cache */
    3.50 +	pthread_key_delete(node->cache_key);
    3.51 +
    3.52 +	while(node->cache_list) {
    3.53 +		struct mat_cache *tmp = node->cache_list;
    3.54 +		node->cache_list = tmp->next;
    3.55 +		free(tmp);
    3.56 +	}
    3.57 +}
    3.58 +
    3.59 +void anm_destroy_node_tree(struct anm_node *tree)
    3.60 +{
    3.61 +	struct anm_node *c, *tmp;
    3.62 +
    3.63 +	if(!tree) return;
    3.64 +
    3.65 +	c = tree->child;
    3.66 +	while(c) {
    3.67 +		tmp = c;
    3.68 +		c = c->next;
    3.69 +
    3.70 +		anm_destroy_node_tree(tmp);
    3.71 +	}
    3.72 +	anm_destroy_node(tree);
    3.73 +}
    3.74 +
    3.75 +struct anm_node *anm_create_node(void)
    3.76 +{
    3.77 +	struct anm_node *n;
    3.78 +
    3.79 +	if((n = malloc(sizeof *n))) {
    3.80 +		if(anm_init_node(n) == -1) {
    3.81 +			free(n);
    3.82 +			return 0;
    3.83 +		}
    3.84 +	}
    3.85 +	return n;
    3.86 +}
    3.87 +
    3.88 +void anm_free_node(struct anm_node *node)
    3.89 +{
    3.90 +	anm_destroy_node(node);
    3.91 +	free(node);
    3.92 +}
    3.93 +
    3.94 +void anm_free_node_tree(struct anm_node *tree)
    3.95 +{
    3.96 +	struct anm_node *c, *tmp;
    3.97 +
    3.98 +	if(!tree) return;
    3.99 +
   3.100 +	c = tree->child;
   3.101 +	while(c) {
   3.102 +		tmp = c;
   3.103 +		c = c->next;
   3.104 +
   3.105 +		anm_free_node_tree(tmp);
   3.106 +	}
   3.107 +
   3.108 +	anm_free_node(tree);
   3.109 +}
   3.110 +
   3.111 +int anm_set_node_name(struct anm_node *node, const char *name)
   3.112 +{
   3.113 +	char *str;
   3.114 +
   3.115 +	if(!(str = malloc(strlen(name) + 1))) {
   3.116 +		return -1;
   3.117 +	}
   3.118 +	strcpy(str, name);
   3.119 +	free(node->name);
   3.120 +	node->name = str;
   3.121 +	return 0;
   3.122 +}
   3.123 +
   3.124 +const char *anm_get_node_name(struct anm_node *node)
   3.125 +{
   3.126 +	return node->name ? node->name : "";
   3.127 +}
   3.128 +
   3.129 +void anm_set_interpolator(struct anm_node *node, enum anm_interpolator in)
   3.130 +{
   3.131 +	int i;
   3.132 +
   3.133 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
   3.134 +		anm_set_track_interpolator(node->tracks + i, in);
   3.135 +	}
   3.136 +	invalidate_cache(node);
   3.137 +}
   3.138 +
   3.139 +void anm_set_extrapolator(struct anm_node *node, enum anm_extrapolator ex)
   3.140 +{
   3.141 +	int i;
   3.142 +
   3.143 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
   3.144 +		anm_set_track_extrapolator(node->tracks + i, ex);
   3.145 +	}
   3.146 +	invalidate_cache(node);
   3.147 +}
   3.148 +
   3.149 +void anm_link_node(struct anm_node *p, struct anm_node *c)
   3.150 +{
   3.151 +	c->next = p->child;
   3.152 +	p->child = c;
   3.153 +
   3.154 +	c->parent = p;
   3.155 +	invalidate_cache(c);
   3.156 +}
   3.157 +
   3.158 +int anm_unlink_node(struct anm_node *p, struct anm_node *c)
   3.159 +{
   3.160 +	struct anm_node *iter;
   3.161 +
   3.162 +	if(p->child == c) {
   3.163 +		p->child = c->next;
   3.164 +		c->next = 0;
   3.165 +		invalidate_cache(c);
   3.166 +		return 0;
   3.167 +	}
   3.168 +
   3.169 +	iter = p->child;
   3.170 +	while(iter->next) {
   3.171 +		if(iter->next == c) {
   3.172 +			iter->next = c->next;
   3.173 +			c->next = 0;
   3.174 +			invalidate_cache(c);
   3.175 +			return 0;
   3.176 +		}
   3.177 +	}
   3.178 +	return -1;
   3.179 +}
   3.180 +
   3.181 +void anm_clear(struct anm_node *node)
   3.182 +{
   3.183 +	int i;
   3.184 +
   3.185 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
   3.186 +		anm_clear_track(&node->tracks[i]);
   3.187 +	}
   3.188 +	invalidate_cache(node);
   3.189 +}
   3.190 +
   3.191 +void anm_set_position(struct anm_node *node, vec3_t pos, anm_time_t tm)
   3.192 +{
   3.193 +	anm_set_value(node->tracks + ANM_TRACK_POS_X, tm, pos.x);
   3.194 +	anm_set_value(node->tracks + ANM_TRACK_POS_Y, tm, pos.y);
   3.195 +	anm_set_value(node->tracks + ANM_TRACK_POS_Z, tm, pos.z);
   3.196 +	invalidate_cache(node);
   3.197 +}
   3.198 +
   3.199 +vec3_t anm_get_node_position(struct anm_node *node, anm_time_t tm)
   3.200 +{
   3.201 +	vec3_t v;
   3.202 +	v.x = anm_get_value(node->tracks + ANM_TRACK_POS_X, tm);
   3.203 +	v.y = anm_get_value(node->tracks + ANM_TRACK_POS_Y, tm);
   3.204 +	v.z = anm_get_value(node->tracks + ANM_TRACK_POS_Z, tm);
   3.205 +	return v;
   3.206 +}
   3.207 +
   3.208 +void anm_set_rotation(struct anm_node *node, quat_t rot, anm_time_t tm)
   3.209 +{
   3.210 +	anm_set_value(node->tracks + ANM_TRACK_ROT_X, tm, rot.x);
   3.211 +	anm_set_value(node->tracks + ANM_TRACK_ROT_Y, tm, rot.y);
   3.212 +	anm_set_value(node->tracks + ANM_TRACK_ROT_Z, tm, rot.z);
   3.213 +	anm_set_value(node->tracks + ANM_TRACK_ROT_W, tm, rot.w);
   3.214 +	invalidate_cache(node);
   3.215 +}
   3.216 +
   3.217 +quat_t anm_get_node_rotation(struct anm_node *node, anm_time_t tm)
   3.218 +{
   3.219 +#ifndef ROT_USE_SLERP
   3.220 +	quat_t q;
   3.221 +	q.x = anm_get_value(node->tracks + ANM_TRACK_ROT_X, tm);
   3.222 +	q.y = anm_get_value(node->tracks + ANM_TRACK_ROT_Y, tm);
   3.223 +	q.z = anm_get_value(node->tracks + ANM_TRACK_ROT_Z, tm);
   3.224 +	q.w = anm_get_value(node->tracks + ANM_TRACK_ROT_W, tm);
   3.225 +	return q;
   3.226 +#else
   3.227 +	int idx0, idx1, last_idx;
   3.228 +	anm_time_t tstart, tend;
   3.229 +	float t, dt;
   3.230 +	struct anm_track *track_x, *track_y, *track_z, *track_w;
   3.231 +	quat_t q, q1, q2;
   3.232 +
   3.233 +	track_x = node->tracks + ANM_TRACK_ROT_X;
   3.234 +	track_y = node->tracks + ANM_TRACK_ROT_Y;
   3.235 +	track_z = node->tracks + ANM_TRACK_ROT_Z;
   3.236 +	track_w = node->tracks + ANM_TRACK_ROT_W;
   3.237 +
   3.238 +	if(!track_x->count) {
   3.239 +		q.x = track_x->def_val;
   3.240 +		q.y = track_y->def_val;
   3.241 +		q.z = track_z->def_val;
   3.242 +		q.w = track_w->def_val;
   3.243 +		return q;
   3.244 +	}
   3.245 +
   3.246 +	last_idx = track_x->count - 1;
   3.247 +
   3.248 +	tstart = track_x->keys[0].time;
   3.249 +	tend = track_x->keys[last_idx].time;
   3.250 +
   3.251 +	if(tstart == tend) {
   3.252 +		q.x = track_x->keys[0].val;
   3.253 +		q.y = track_y->keys[0].val;
   3.254 +		q.z = track_z->keys[0].val;
   3.255 +		q.w = track_w->keys[0].val;
   3.256 +		return q;
   3.257 +	}
   3.258 +
   3.259 +	tm = anm_remap_time(track_x, tm, tstart, tend);
   3.260 +
   3.261 +	idx0 = anm_get_key_interval(track_x, tm);
   3.262 +	assert(idx0 >= 0 && idx0 < track_x->count);
   3.263 +	idx1 = idx0 + 1;
   3.264 +
   3.265 +	if(idx0 == last_idx) {
   3.266 +		q.x = track_x->keys[idx0].val;
   3.267 +		q.y = track_y->keys[idx0].val;
   3.268 +		q.z = track_z->keys[idx0].val;
   3.269 +		q.w = track_w->keys[idx0].val;
   3.270 +		return q;
   3.271 +	}
   3.272 +
   3.273 +	dt = (float)(track_x->keys[idx1].time - track_x->keys[idx0].time);
   3.274 +	t = (float)(tm - track_x->keys[idx0].time) / dt;
   3.275 +
   3.276 +	q1.x = track_x->keys[idx0].val;
   3.277 +	q1.y = track_y->keys[idx0].val;
   3.278 +	q1.z = track_z->keys[idx0].val;
   3.279 +	q1.w = track_w->keys[idx0].val;
   3.280 +
   3.281 +	q2.x = track_x->keys[idx1].val;
   3.282 +	q2.y = track_y->keys[idx1].val;
   3.283 +	q2.z = track_z->keys[idx1].val;
   3.284 +	q2.w = track_w->keys[idx1].val;
   3.285 +
   3.286 +	/*q1 = quat_normalize(q1);
   3.287 +	q2 = quat_normalize(q2);*/
   3.288 +
   3.289 +	return quat_slerp(q1, q2, t);
   3.290 +#endif
   3.291 +}
   3.292 +
   3.293 +void anm_set_scaling(struct anm_node *node, vec3_t scl, anm_time_t tm)
   3.294 +{
   3.295 +	anm_set_value(node->tracks + ANM_TRACK_SCL_X, tm, scl.x);
   3.296 +	anm_set_value(node->tracks + ANM_TRACK_SCL_Y, tm, scl.y);
   3.297 +	anm_set_value(node->tracks + ANM_TRACK_SCL_Z, tm, scl.z);
   3.298 +	invalidate_cache(node);
   3.299 +}
   3.300 +
   3.301 +vec3_t anm_get_node_scaling(struct anm_node *node, anm_time_t tm)
   3.302 +{
   3.303 +	vec3_t v;
   3.304 +	v.x = anm_get_value(node->tracks + ANM_TRACK_SCL_X, tm);
   3.305 +	v.y = anm_get_value(node->tracks + ANM_TRACK_SCL_Y, tm);
   3.306 +	v.z = anm_get_value(node->tracks + ANM_TRACK_SCL_Z, tm);
   3.307 +	return v;
   3.308 +}
   3.309 +
   3.310 +
   3.311 +vec3_t anm_get_position(struct anm_node *node, anm_time_t tm)
   3.312 +{
   3.313 +	mat4_t xform;
   3.314 +	vec3_t pos = {0.0, 0.0, 0.0};
   3.315 +
   3.316 +	if(!node->parent) {
   3.317 +		return anm_get_node_position(node, tm);
   3.318 +	}
   3.319 +
   3.320 +	anm_get_matrix(node, xform, tm);
   3.321 +	return v3_transform(pos, xform);
   3.322 +}
   3.323 +
   3.324 +quat_t anm_get_rotation(struct anm_node *node, anm_time_t tm)
   3.325 +{
   3.326 +	quat_t rot, prot;
   3.327 +	rot = anm_get_node_rotation(node, tm);
   3.328 +
   3.329 +	if(!node->parent) {
   3.330 +		return rot;
   3.331 +	}
   3.332 +
   3.333 +	prot = anm_get_rotation(node->parent, tm);
   3.334 +	return quat_mul(prot, rot);
   3.335 +}
   3.336 +
   3.337 +vec3_t anm_get_scaling(struct anm_node *node, anm_time_t tm)
   3.338 +{
   3.339 +	vec3_t s, ps;
   3.340 +	s = anm_get_node_scaling(node, tm);
   3.341 +
   3.342 +	if(!node->parent) {
   3.343 +		return s;
   3.344 +	}
   3.345 +
   3.346 +	ps = anm_get_scaling(node->parent, tm);
   3.347 +	return v3_mul(s, ps);
   3.348 +}
   3.349 +
   3.350 +void anm_set_pivot(struct anm_node *node, vec3_t piv)
   3.351 +{
   3.352 +	node->pivot = piv;
   3.353 +}
   3.354 +
   3.355 +vec3_t anm_get_pivot(struct anm_node *node)
   3.356 +{
   3.357 +	return node->pivot;
   3.358 +}
   3.359 +
   3.360 +void anm_get_node_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
   3.361 +{
   3.362 +	int i;
   3.363 +	mat4_t rmat;
   3.364 +	vec3_t pos, scale;
   3.365 +	quat_t rot;
   3.366 +
   3.367 +	pos = anm_get_node_position(node, tm);
   3.368 +	rot = anm_get_node_rotation(node, tm);
   3.369 +	scale = anm_get_node_scaling(node, tm);
   3.370 +
   3.371 +	m4_set_translation(mat, node->pivot.x, node->pivot.y, node->pivot.z);
   3.372 +
   3.373 +	quat_to_mat4(rmat, rot);
   3.374 +	for(i=0; i<3; i++) {
   3.375 +		mat[i][0] = rmat[i][0];
   3.376 +		mat[i][1] = rmat[i][1];
   3.377 +		mat[i][2] = rmat[i][2];
   3.378 +	}
   3.379 +	/* this loop is equivalent to: m4_mult(mat, mat, rmat); */
   3.380 +
   3.381 +	mat[0][0] *= scale.x; mat[0][1] *= scale.y; mat[0][2] *= scale.z; mat[0][3] += pos.x;
   3.382 +	mat[1][0] *= scale.x; mat[1][1] *= scale.y; mat[1][2] *= scale.z; mat[1][3] += pos.y;
   3.383 +	mat[2][0] *= scale.x; mat[2][1] *= scale.y; mat[2][2] *= scale.z; mat[2][3] += pos.z;
   3.384 +
   3.385 +	m4_translate(mat, -node->pivot.x, -node->pivot.y, -node->pivot.z);
   3.386 +
   3.387 +	/* that's basically: pivot * rotation * translation * scaling * -pivot */
   3.388 +}
   3.389 +
   3.390 +void anm_get_node_inv_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
   3.391 +{
   3.392 +	mat4_t tmp;
   3.393 +	anm_get_node_matrix(node, tmp, tm);
   3.394 +	m4_inverse(mat, tmp);
   3.395 +}
   3.396 +
   3.397 +void anm_eval_node(struct anm_node *node, anm_time_t tm)
   3.398 +{
   3.399 +	anm_get_node_matrix(node, node->matrix, tm);
   3.400 +}
   3.401 +
   3.402 +void anm_eval(struct anm_node *node, anm_time_t tm)
   3.403 +{
   3.404 +	struct anm_node *c;
   3.405 +
   3.406 +	anm_eval_node(node, tm);
   3.407 +
   3.408 +	if(node->parent) {
   3.409 +		/* due to post-order traversal, the parent matrix is already evaluated */
   3.410 +		m4_mult(node->matrix, node->parent->matrix, node->matrix);
   3.411 +	}
   3.412 +
   3.413 +	/* recersively evaluate all children */
   3.414 +	c = node->child;
   3.415 +	while(c) {
   3.416 +		anm_eval(c, tm);
   3.417 +		c = c->next;
   3.418 +	}
   3.419 +}
   3.420 +
   3.421 +void anm_get_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
   3.422 +{
   3.423 +	struct mat_cache *cache = pthread_getspecific(node->cache_key);
   3.424 +	if(!cache) {
   3.425 +		cache = malloc(sizeof *cache);
   3.426 +		assert(cache);
   3.427 +
   3.428 +		pthread_mutex_lock(&node->cache_list_lock);
   3.429 +		cache->next = node->cache_list;
   3.430 +		node->cache_list = cache;
   3.431 +		pthread_mutex_unlock(&node->cache_list_lock);
   3.432 +
   3.433 +		cache->time = ANM_TIME_INVAL;
   3.434 +		cache->inv_time = ANM_TIME_INVAL;
   3.435 +		pthread_setspecific(node->cache_key, cache);
   3.436 +	}
   3.437 +
   3.438 +	if(cache->time != tm) {
   3.439 +		anm_get_node_matrix(node, cache->matrix, tm);
   3.440 +
   3.441 +		if(node->parent) {
   3.442 +			mat4_t parent_mat;
   3.443 +
   3.444 +			anm_get_matrix(node->parent, parent_mat, tm);
   3.445 +			m4_mult(cache->matrix, parent_mat, cache->matrix);
   3.446 +		}
   3.447 +		cache->time = tm;
   3.448 +	}
   3.449 +	m4_copy(mat, cache->matrix);
   3.450 +}
   3.451 +
   3.452 +void anm_get_inv_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm)
   3.453 +{
   3.454 +	struct mat_cache *cache = pthread_getspecific(node->cache_key);
   3.455 +	if(!cache) {
   3.456 +		cache = malloc(sizeof *cache);
   3.457 +		assert(cache);
   3.458 +
   3.459 +		pthread_mutex_lock(&node->cache_list_lock);
   3.460 +		cache->next = node->cache_list;
   3.461 +		node->cache_list = cache;
   3.462 +		pthread_mutex_unlock(&node->cache_list_lock);
   3.463 +
   3.464 +		cache->inv_time = ANM_TIME_INVAL;
   3.465 +		cache->inv_time = ANM_TIME_INVAL;
   3.466 +		pthread_setspecific(node->cache_key, cache);
   3.467 +	}
   3.468 +
   3.469 +	if(cache->inv_time != tm) {
   3.470 +		anm_get_matrix(node, mat, tm);
   3.471 +		m4_inverse(cache->inv_matrix, mat);
   3.472 +		cache->inv_time = tm;
   3.473 +	}
   3.474 +	m4_copy(mat, cache->inv_matrix);
   3.475 +}
   3.476 +
   3.477 +anm_time_t anm_get_start_time(struct anm_node *node)
   3.478 +{
   3.479 +	int i;
   3.480 +	struct anm_node *c;
   3.481 +	anm_time_t res = LONG_MAX;
   3.482 +
   3.483 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
   3.484 +		if(node->tracks[i].count) {
   3.485 +			anm_time_t tm = node->tracks[i].keys[0].time;
   3.486 +			if(tm < res) {
   3.487 +				res = tm;
   3.488 +			}
   3.489 +		}
   3.490 +	}
   3.491 +
   3.492 +	c = node->child;
   3.493 +	while(c) {
   3.494 +		anm_time_t tm = anm_get_start_time(c);
   3.495 +		if(tm < res) {
   3.496 +			res = tm;
   3.497 +		}
   3.498 +		c = c->next;
   3.499 +	}
   3.500 +	return res;
   3.501 +}
   3.502 +
   3.503 +anm_time_t anm_get_end_time(struct anm_node *node)
   3.504 +{
   3.505 +	int i;
   3.506 +	struct anm_node *c;
   3.507 +	anm_time_t res = LONG_MIN;
   3.508 +
   3.509 +	for(i=0; i<ANM_NUM_TRACKS; i++) {
   3.510 +		if(node->tracks[i].count) {
   3.511 +			anm_time_t tm = node->tracks[i].keys[node->tracks[i].count - 1].time;
   3.512 +			if(tm > res) {
   3.513 +				res = tm;
   3.514 +			}
   3.515 +		}
   3.516 +	}
   3.517 +
   3.518 +	c = node->child;
   3.519 +	while(c) {
   3.520 +		anm_time_t tm = anm_get_end_time(c);
   3.521 +		if(tm > res) {
   3.522 +			res = tm;
   3.523 +		}
   3.524 +		c = c->next;
   3.525 +	}
   3.526 +	return res;
   3.527 +}
   3.528 +
   3.529 +static void invalidate_cache(struct anm_node *node)
   3.530 +{
   3.531 +	struct mat_cache *cache = pthread_getspecific(node->cache_key);
   3.532 +	if(cache) {
   3.533 +	   cache->time = cache->inv_time = ANM_TIME_INVAL;
   3.534 +	}
   3.535 +}

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/libs/anim/anim.h	Sat Feb 01 19:58:19 2014 +0200
     4.3 @@ -0,0 +1,132 @@
     4.4 +#ifndef LIBANIM_H_
     4.5 +#define LIBANIM_H_
     4.6 +
     4.7 +#include "config.h"
     4.8 +
     4.9 +#include <pthread.h>
    4.10 +
    4.11 +#include <vmath/vector.h>
    4.12 +#include <vmath/quat.h>
    4.13 +#include <vmath/matrix.h>
    4.14 +#include "track.h"
    4.15 +
    4.16 +enum {
    4.17 +	ANM_TRACK_POS_X,
    4.18 +	ANM_TRACK_POS_Y,
    4.19 +	ANM_TRACK_POS_Z,
    4.20 +
    4.21 +	ANM_TRACK_ROT_X,
    4.22 +	ANM_TRACK_ROT_Y,
    4.23 +	ANM_TRACK_ROT_Z,
    4.24 +	ANM_TRACK_ROT_W,
    4.25 +
    4.26 +	ANM_TRACK_SCL_X,
    4.27 +	ANM_TRACK_SCL_Y,
    4.28 +	ANM_TRACK_SCL_Z,
    4.29 +
    4.30 +	ANM_NUM_TRACKS
    4.31 +};
    4.32 +
    4.33 +struct anm_node {
    4.34 +	char *name;
    4.35 +
    4.36 +	struct anm_track tracks[ANM_NUM_TRACKS];
    4.37 +	vec3_t pivot;
    4.38 +
    4.39 +	/* matrix cache */
    4.40 +	struct mat_cache {
    4.41 +		mat4_t matrix, inv_matrix;
    4.42 +		anm_time_t time, inv_time;
    4.43 +		struct mat_cache *next;
    4.44 +	} *cache_list;
    4.45 +	pthread_key_t cache_key;
    4.46 +	pthread_mutex_t cache_list_lock;
    4.47 +
    4.48 +	/* matrix calculated by anm_eval functions (no locking, meant as a pre-pass) */
    4.49 +	mat4_t matrix;
    4.50 +
    4.51 +	struct anm_node *parent;
    4.52 +	struct anm_node *child;
    4.53 +	struct anm_node *next;
    4.54 +};
    4.55 +
    4.56 +#ifdef __cplusplus
    4.57 +extern "C" {
    4.58 +#endif
    4.59 +
    4.60 +/* node constructor and destructor */
    4.61 +int anm_init_node(struct anm_node *node);
    4.62 +void anm_destroy_node(struct anm_node *node);
    4.63 +
    4.64 +/* recursively destroy an animation node tree */
    4.65 +void anm_destroy_node_tree(struct anm_node *tree);
    4.66 +
    4.67 +/* helper functions to allocate/construct and destroy/free with
    4.68 + * a single call. They call anm_init_node and anm_destroy_node
    4.69 + * internally.
    4.70 + */
    4.71 +struct anm_node *anm_create_node(void);
    4.72 +void anm_free_node(struct anm_node *node);
    4.73 +
    4.74 +/* recursively destroy and free the nodes of a node tree */
    4.75 +void anm_free_node_tree(struct anm_node *tree);
    4.76 +
    4.77 +int anm_set_node_name(struct anm_node *node, const char *name);
    4.78 +const char *anm_get_node_name(struct anm_node *node);
    4.79 +
    4.80 +void anm_set_interpolator(struct anm_node *node, enum anm_interpolator in);
    4.81 +void anm_set_extrapolator(struct anm_node *node, enum anm_extrapolator ex);
    4.82 +
    4.83 +/* link and unlink nodes with parent/child relations */
    4.84 +void anm_link_node(struct anm_node *parent, struct anm_node *child);
    4.85 +int anm_unlink_node(struct anm_node *parent, struct anm_node *child);
    4.86 +
    4.87 +void anm_clear(struct anm_node *node);
    4.88 +
    4.89 +void anm_set_position(struct anm_node *node, vec3_t pos, anm_time_t tm);
    4.90 +vec3_t anm_get_node_position(struct anm_node *node, anm_time_t tm);
    4.91 +
    4.92 +void anm_set_rotation(struct anm_node *node, quat_t rot, anm_time_t tm);
    4.93 +quat_t anm_get_node_rotation(struct anm_node *node, anm_time_t tm);
    4.94 +
    4.95 +void anm_set_scaling(struct anm_node *node, vec3_t scl, anm_time_t tm);
    4.96 +vec3_t anm_get_node_scaling(struct anm_node *node, anm_time_t tm);
    4.97 +
    4.98 +/* these three return the full p/r/s taking hierarchy into account */
    4.99 +vec3_t anm_get_position(struct anm_node *node, anm_time_t tm);
   4.100 +quat_t anm_get_rotation(struct anm_node *node, anm_time_t tm);
   4.101 +vec3_t anm_get_scaling(struct anm_node *node, anm_time_t tm);
   4.102 +
   4.103 +void anm_set_pivot(struct anm_node *node, vec3_t pivot);
   4.104 +vec3_t anm_get_pivot(struct anm_node *node);
   4.105 +
   4.106 +/* those return the start and end times of the whole tree */
   4.107 +anm_time_t anm_get_start_time(struct anm_node *node);
   4.108 +anm_time_t anm_get_end_time(struct anm_node *node);
   4.109 +
   4.110 +/* these calculate the matrix and inverse matrix of this node alone */
   4.111 +void anm_get_node_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm);
   4.112 +void anm_get_node_inv_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm);
   4.113 +
   4.114 +/* ---- top-down matrix calculation interface ---- */
   4.115 +
   4.116 +/* calculate and set the matrix of this node */
   4.117 +void anm_eval_node(struct anm_node *node, anm_time_t tm);
   4.118 +/* calculate and set the matrix of this node and all its children recursively */
   4.119 +void anm_eval(struct anm_node *node, anm_time_t tm);
   4.120 +
   4.121 +
   4.122 +/* ---- bottom-up lazy matrix calculation interface ---- */
   4.123 +
   4.124 +/* These calculate the matrix and inverse matrix of this node taking hierarchy
   4.125 + * into account. The results are cached in thread-specific storage and returned
   4.126 + * if there's no change in time or tracks from the last query...
   4.127 + */
   4.128 +void anm_get_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm);
   4.129 +void anm_get_inv_matrix(struct anm_node *node, mat4_t mat, anm_time_t tm);
   4.130 +
   4.131 +#ifdef __cplusplus
   4.132 +}
   4.133 +#endif
   4.134 +
   4.135 +#endif	/* LIBANIM_H_ */

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/libs/anim/config.h	Sat Feb 01 19:58:19 2014 +0200
     5.3 @@ -0,0 +1,6 @@
     5.4 +#ifndef ANIM_CONFIG_H_
     5.5 +#define ANIM_CONFIG_H_
     5.6 +
     5.7 +#undef ANIM_THREAD_SAFE
     5.8 +
     5.9 +#endif	/* ANIM_CONFIG_H_ */

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/libs/anim/dynarr.c	Sat Feb 01 19:58:19 2014 +0200
     6.3 @@ -0,0 +1,122 @@
     6.4 +#include <stdio.h>
     6.5 +#include <stdlib.h>
     6.6 +#include <string.h>
     6.7 +#include "dynarr.h"
     6.8 +
     6.9 +/* The array descriptor keeps auxilliary information needed to manipulate
    6.10 + * the dynamic array. It's allocated adjacent to the array buffer.
    6.11 + */
    6.12 +struct arrdesc {
    6.13 +	int nelem, szelem;
    6.14 +	int max_elem;
    6.15 +	int bufsz;	/* not including the descriptor */
    6.16 +};
    6.17 +
    6.18 +#define DESC(x)		((struct arrdesc*)((char*)(x) - sizeof(struct arrdesc)))
    6.19 +
    6.20 +void *dynarr_alloc(int elem, int szelem)
    6.21 +{
    6.22 +	struct arrdesc *desc;
    6.23 +
    6.24 +	if(!(desc = malloc(elem * szelem + sizeof *desc))) {
    6.25 +		return 0;
    6.26 +	}
    6.27 +	desc->nelem = desc->max_elem = elem;
    6.28 +	desc->szelem = szelem;
    6.29 +	desc->bufsz = elem * szelem;
    6.30 +	return (char*)desc + sizeof *desc;
    6.31 +}
    6.32 +
    6.33 +void dynarr_free(void *da)
    6.34 +{
    6.35 +	if(da) {
    6.36 +		free(DESC(da));
    6.37 +	}
    6.38 +}
    6.39 +
    6.40 +void *dynarr_resize(void *da, int elem)
    6.41 +{
    6.42 +	int newsz;
    6.43 +	void *tmp;
    6.44 +	struct arrdesc *desc;
    6.45 +
    6.46 +	if(!da) return 0;
    6.47 +	desc = DESC(da);
    6.48 +
    6.49 +	newsz = desc->szelem * elem;
    6.50 +
    6.51 +	if(!(tmp = realloc(desc, newsz + sizeof *desc))) {
    6.52 +		return 0;
    6.53 +	}
    6.54 +	desc = tmp;
    6.55 +
    6.56 +	desc->nelem = desc->max_elem = elem;
    6.57 +	desc->bufsz = newsz;
    6.58 +	return (char*)desc + sizeof *desc;
    6.59 +}
    6.60 +
    6.61 +int dynarr_empty(void *da)
    6.62 +{
    6.63 +	return DESC(da)->nelem ? 0 : 1;
    6.64 +}
    6.65 +
    6.66 +int dynarr_size(void *da)
    6.67 +{
    6.68 +	return DESC(da)->nelem;
    6.69 +}
    6.70 +
    6.71 +
    6.72 +/* stack semantics */
    6.73 +void *dynarr_push(void *da, void *item)
    6.74 +{
    6.75 +	struct arrdesc *desc;
    6.76 +	int nelem;
    6.77 +
    6.78 +	desc = DESC(da);
    6.79 +	nelem = desc->nelem;
    6.80 +
    6.81 +	if(nelem >= desc->max_elem) {
    6.82 +		/* need to resize */
    6.83 +		struct arrdesc *tmp;
    6.84 +		int newsz = desc->max_elem ? desc->max_elem * 2 : 1;
    6.85 +
    6.86 +		if(!(tmp = dynarr_resize(da, newsz))) {
    6.87 +			fprintf(stderr, "failed to resize\n");
    6.88 +			return da;
    6.89 +		}
    6.90 +		da = tmp;
    6.91 +		desc = DESC(da);
    6.92 +		desc->nelem = nelem;
    6.93 +	}
    6.94 +
    6.95 +	memcpy((char*)da + desc->nelem++ * desc->szelem, item, desc->szelem);
    6.96 +	return da;
    6.97 +}
    6.98 +
    6.99 +void *dynarr_pop(void *da)
   6.100 +{
   6.101 +	struct arrdesc *desc;
   6.102 +	int nelem;
   6.103 +
   6.104 +	desc = DESC(da);
   6.105 +	nelem = desc->nelem;
   6.106 +
   6.107 +	if(!nelem) return da;
   6.108 +
   6.109 +	if(nelem <= desc->max_elem / 3) {
   6.110 +		/* reclaim space */
   6.111 +		struct arrdesc *tmp;
   6.112 +		int newsz = desc->max_elem / 2;
   6.113 +
   6.114 +		if(!(tmp = dynarr_resize(da, newsz))) {
   6.115 +			fprintf(stderr, "failed to resize\n");
   6.116 +			return da;
   6.117 +		}
   6.118 +		da = tmp;
   6.119 +		desc = DESC(da);
   6.120 +		desc->nelem = nelem;
   6.121 +	}
   6.122 +	desc->nelem--;
   6.123 +
   6.124 +	return da;
   6.125 +}

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/libs/anim/dynarr.h	Sat Feb 01 19:58:19 2014 +0200
     7.3 @@ -0,0 +1,16 @@
     7.4 +#ifndef DYNARR_H_
     7.5 +#define DYNARR_H_
     7.6 +
     7.7 +void *dynarr_alloc(int elem, int szelem);
     7.8 +void dynarr_free(void *da);
     7.9 +void *dynarr_resize(void *da, int elem);
    7.10 +
    7.11 +int dynarr_empty(void *da);
    7.12 +int dynarr_size(void *da);
    7.13 +
    7.14 +/* stack semantics */
    7.15 +void *dynarr_push(void *da, void *item);
    7.16 +void *dynarr_pop(void *da);
    7.17 +
    7.18 +
    7.19 +#endif	/* DYNARR_H_ */