libpsys
view src/psys.c @ 2:6e5342a2529a
more stuff done
| author | John Tsiombikas <nuclear@mutantstargoat.com> |
|---|---|
| date | Sun, 25 Sep 2011 04:26:51 +0300 |
| parents | 874a942853ad |
| children | 133094e2f5a5 |
line source
1 #include <stdlib.h>
2 #include <math.h>
3 #include <assert.h>
4 #include <pthread.h>
5 #include <vmath.h>
6 #include "psys_impl.h"
8 static int spawn(struct psys_emitter *em, struct psys_particle *p, void *cls);
9 static void update_particle(struct psys_emitter *em, struct psys_particle *p, float tm, float dt, void *cls);
11 static int init_v3track(struct v3track *v3t);
12 static void destroy_v3track(struct v3track *v3t);
13 static void set_v3value(struct v3track *v3t, anm_time_t tm, vec3_t v);
14 static vec3_t get_v3value(struct v3track *v3t, anm_time_t tm);
16 /* particle pool */
17 static struct psys_particle *ppool;
18 static int ppool_size;
19 static pthread_mutex_t pool_lock = PTHREAD_MUTEX_INITIALIZER;
21 static struct psys_particle *palloc(void);
22 static void pfree(struct psys_particle *p);
24 /* --- constructors and shit --- */
26 struct psys_emitter *psys_create(void)
27 {
28 struct psys_emitter *em;
30 if(!(em = malloc(sizeof *em))) {
31 return 0;
32 }
33 if(psys_init(em) == -1) {
34 free(em);
35 return 0;
36 }
37 return em;
38 }
40 void psys_free(struct psys_emitter *em)
41 {
42 psys_destroy(em);
43 free(em);
44 }
46 int psys_init(struct psys_emitter *em)
47 {
48 memset(em, 0, sizeof *em);
50 if(anm_init_node(&em->prs) == -1) {
51 psys_destroy(em);
52 return -1;
53 }
54 if(anm_init_track(&em->rate) == -1) {
55 psys_destroy(em);
56 return -1;
57 }
58 if(anm_init_track(&em->life) == -1) {
59 psys_destroy(em);
60 return -1;
61 }
62 if(init_v3track(&em->dir) == -1) {
63 psys_destroy(em);
64 return -1;
65 }
66 if(init_v3track(&em->grav) == -1) {
67 psys_destroy(em);
68 return -1;
69 }
71 em->spawn = spawn;
72 em->update = update_particle;
74 em->draw = psys_gl_draw;
75 em->draw_start = psys_gl_draw_start;
76 em->draw_end = psys_gl_draw_end;
78 return 0;
79 }
81 void psys_destroy(struct psys_emitter *em)
82 {
83 struct psys_particle *part;
85 part = em->plist;
86 while(part) {
87 struct psys_particle *tmp = part;
88 part = part->next;
89 pfree(tmp);
90 }
92 anm_destroy_node(&em->prs);
93 anm_destroy_track(&em->rate);
94 destroy_v3track(&em->dir);
95 }
97 void psys_set_texture(struct psys_emitter *em, unsigned int tex)
98 {
99 em->tex = tex;
100 }
102 void psys_set_pos(struct psys_emitter *em, vec3_t pos, float tm)
103 {
104 anm_set_position(&em->prs, pos, ANM_SEC2TM(tm));
105 }
107 void psys_set_rot(struct psys_emitter *em, quat_t rot, float tm)
108 {
109 anm_set_rotation(&em->prs, rot, ANM_SEC2TM(tm));
110 }
112 void psys_set_pivot(struct psys_emitter *em, vec3_t pivot)
113 {
114 anm_set_pivot(&em->prs, pivot);
115 }
117 void psys_set_rate(struct psys_emitter *em, float rate, float tm)
118 {
119 anm_set_value(&em->rate, ANM_SEC2TM(tm), rate);
120 }
122 void psys_set_life(struct psys_emitter *em, float life, float tm)
123 {
124 anm_set_value(&em->life, ANM_SEC2TM(tm), life);
125 }
127 void psys_set_dir(struct psys_emitter *em, vec3_t dir, float tm)
128 {
129 set_v3value(&em->dir, ANM_SEC2TM(tm), dir);
130 }
132 void psys_set_grav(struct psys_emitter *em, vec3_t grav, float tm)
133 {
134 set_v3value(&em->grav, ANM_SEC2TM(tm), grav);
135 }
138 void psys_clear_collision_planes(struct psys_emitter *em)
139 {
140 struct col_plane *plane;
142 plane = em->planes;
143 while(plane) {
144 struct col_plane *tmp = plane;
145 plane = plane->next;
146 free(tmp);
147 }
148 }
150 int psys_add_collision_plane(struct psys_emitter *em, plane_t plane, float elast)
151 {
152 struct col_plane *node;
154 if(!(node = malloc(sizeof *node))) {
155 return -1;
156 }
157 node->p = plane;
158 node->elasticity = elast;
159 node->next = em->planes;
160 em->planes = node;
161 return 0;
162 }
164 void psys_add_particle(struct psys_emitter *em, struct psys_particle *p)
165 {
166 p->next = em->plist;
167 em->plist = p;
168 }
170 void psys_spawn_func(struct psys_emitter *em, psys_spawn_func_t func, void *cls)
171 {
172 em->spawn = func;
173 em->spawn_cls = cls;
174 }
176 void psys_update_func(struct psys_emitter *em, psys_update_func_t func, void *cls)
177 {
178 em->update = func;
179 em->upd_cls = cls;
180 }
182 void psys_draw_func(struct psys_emitter *em, psys_draw_func_t draw,
183 psys_draw_start_func_t start, psys_draw_end_func_t end, void *cls)
184 {
185 em->draw = draw;
186 em->draw_start = start;
187 em->draw_end = end;
188 em->draw_cls = cls;
189 }
191 /* --- query current state --- */
192 unsigned int psys_get_texture(struct psys_emitter *em)
193 {
194 return em->tex;
195 }
197 vec3_t psys_get_pos(struct psys_emitter *em)
198 {
199 return em->cur_pos;
200 }
202 quat_t psys_get_rot(struct psys_emitter *em)
203 {
204 return em->cur_rot;
205 }
207 float psys_get_rate(struct psys_emitter *em)
208 {
209 return em->cur_rate;
210 }
212 float psys_get_life(struct psys_emitter *em)
213 {
214 return em->cur_life;
215 }
217 vec3_t psys_get_dir(struct psys_emitter *em)
218 {
219 return em->cur_dir;
220 }
222 vec3_t psys_get_grav(struct psys_emitter *em)
223 {
224 return em->cur_grav;
225 }
227 /* --- update and render --- */
229 void psys_update(struct psys_emitter *em, float tm)
230 {
231 float dt, spawn_dt, spawn_tm;
232 int i, spawn_count;
233 struct psys_particle *p, pdummy;
234 anm_time_t atm;
236 assert(em->spawn && em->update);
238 atm = ANM_SEC2TM(tm);
240 em->cur_rate = anm_get_value(&em->rate, atm);
241 dt = tm - em->last_update;
243 /* how many particles to spawn for this interval ? */
244 em->spawn_acc += em->cur_rate * dt;
245 if(em->spawn_acc >= 1.0) {
246 spawn_count = em->spawn_acc;
247 em->spawn_acc = fmod(em->spawn_acc, 1.0);
248 } else {
249 spawn_count = 0;
250 }
252 em->cur_dir = get_v3value(&em->dir, atm);
253 em->cur_life = anm_get_value(&em->life, atm);
254 em->cur_grav = get_v3value(&em->grav, atm);
256 spawn_dt = dt / (float)spawn_count;
257 spawn_tm = em->last_update;
258 for(i=0; i<spawn_count; i++) {
259 /* update emitter position for this spawning */
260 em->cur_pos = anm_get_position(&em->prs, ANM_SEC2TM(spawn_tm));
262 if(!(p = palloc())) {
263 return;
264 }
265 if(em->spawn(em, p, em->spawn_cls) == -1) {
266 pfree(p);
267 }
268 spawn_tm += spawn_dt;
269 }
271 /* update all particles */
272 p = em->plist;
273 while(p) {
274 em->update(em, p, tm, dt, em->upd_cls);
275 p = p->next;
276 }
278 /* cleanup dead particles */
279 pdummy.next = em->plist;
280 p = &pdummy;
281 while(p->next) {
282 if(p->next->life <= 0) {
283 struct psys_particle *tmp = p->next;
284 p->next = p->next->next;
285 pfree(tmp);
286 } else {
287 p = p->next;
288 }
289 }
290 em->plist = pdummy.next;
292 em->last_update = tm;
293 }
295 void psys_draw(struct psys_emitter *em)
296 {
297 struct psys_particle *p;
299 if(em->draw_start) {
300 em->draw_start(em, em->draw_cls);
301 }
303 p = em->plist;
304 while(p) {
305 em->draw(em, p, em->draw_cls);
306 p = p->next;
307 }
309 if(em->draw_end) {
310 em->draw_end(em, em->draw_cls);
311 }
312 }
314 static int spawn(struct psys_emitter *em, struct psys_particle *p, void *cls)
315 {
316 p->pos = em->cur_pos;
317 p->vel = em->cur_dir;
318 p->size = 1.0;
319 p->life = em->cur_life;
321 psys_add_particle(em, p);
322 return 0;
323 }
325 static void update_particle(struct psys_emitter *em, struct psys_particle *p, float tm, float dt, void *cls)
326 {
327 vec3_t accel;
329 accel.x = em->cur_grav.x - p->vel.x * em->drag;
330 accel.y = em->cur_grav.y - p->vel.y * em->drag;
331 accel.z = em->cur_grav.z - p->vel.z * em->drag;
333 p->vel.x += accel.x * dt;
334 p->vel.y += accel.y * dt;
335 p->vel.z += accel.z * dt;
337 p->pos.x += p->vel.x * dt;
338 p->pos.y += p->vel.y * dt;
339 p->pos.z += p->vel.z * dt;
341 p->life -= dt;
342 }
344 /* --- v3track helper --- */
346 int init_v3track(struct v3track *v3t)
347 {
348 if(anm_init_track(&v3t->x) == -1) {
349 return -1;
350 }
351 if(anm_init_track(&v3t->y) == -1) {
352 anm_destroy_track(&v3t->x);
353 return -1;
354 }
355 if(anm_init_track(&v3t->z) == -1) {
356 anm_destroy_track(&v3t->x);
357 anm_destroy_track(&v3t->y);
358 return -1;
359 }
360 return 0;
361 }
363 static void destroy_v3track(struct v3track *v3t)
364 {
365 anm_destroy_track(&v3t->x);
366 anm_destroy_track(&v3t->y);
367 anm_destroy_track(&v3t->z);
368 }
370 static void set_v3value(struct v3track *v3t, anm_time_t tm, vec3_t v)
371 {
372 anm_set_value(&v3t->x, tm, v.x);
373 anm_set_value(&v3t->y, tm, v.y);
374 anm_set_value(&v3t->z, tm, v.z);
375 }
377 static vec3_t get_v3value(struct v3track *v3t, anm_time_t tm)
378 {
379 vec3_t v;
380 v.x = anm_get_value(&v3t->x, tm);
381 v.y = anm_get_value(&v3t->y, tm);
382 v.z = anm_get_value(&v3t->z, tm);
383 return v;
384 }
386 /* --- particle allocation pool --- */
388 static struct psys_particle *palloc(void)
389 {
390 struct psys_particle *p;
392 pthread_mutex_lock(&pool_lock);
393 if(ppool) {
394 p = ppool;
395 ppool = ppool->next;
396 ppool_size--;
397 } else {
398 p = malloc(sizeof *p);
399 }
400 pthread_mutex_unlock(&pool_lock);
402 if(p) {
403 memset(p, 0, sizeof *p);
404 /*reset_pattr(&p->attr);*/
405 }
406 return p;
407 }
409 static void pfree(struct psys_particle *p)
410 {
411 pthread_mutex_lock(&pool_lock);
412 p->next = ppool;
413 ppool = p;
414 ppool_size++;
415 pthread_mutex_unlock(&pool_lock);
416 }