n_particles.c

Go to the documentation of this file.

 
#include "nilorea/n_particles.h"
#include "math.h"
 
int init_particle_system(PARTICLE_SYSTEM** psys, int max, double x, double y, double z, int max_sprites) {
    __n_assert(!(*psys), n_log(LOG_ERR, "particle system %p already initialized", (*psys)); return FALSE);
 
    Malloc((*psys), PARTICLE_SYSTEM, 1);
 
    start_HiTimer(&(*psys)->timer);
 
    (*psys)->list = new_generic_list(max);
 
    (*psys)->source[0] = x;
    (*psys)->source[1] = y;
    (*psys)->source[2] = z;
 
    if (max_sprites > 0)
        (*psys)->sprites = (ALLEGRO_BITMAP**)calloc(max_sprites, sizeof(ALLEGRO_BITMAP*));
    else
        (*psys)->sprites = NULL;
 
    return TRUE;
} /* init_particle_system() */
 
int add_particle(PARTICLE_SYSTEM* psys, int spr, int mode, int lifetime, int size, ALLEGRO_COLOR color, PHYSICS object) {
    int it = 0;
 
    PARTICLE* new_p = NULL;
 
    if (psys->list->nb_items == psys->list->nb_max_items)
        return FALSE;
 
    for (it = 0; it < 3; it++) {
        object.position[it] += psys->source[it];
    }
 
    Malloc(new_p, PARTICLE, 1);
    __n_assert(new_p, return FALSE);
 
    new_p->spr_id = spr;
    new_p->mode = mode;
    new_p->lifetime = lifetime;
    new_p->color = color;
    new_p->size = size;
 
    memcpy(&new_p->object, &object, sizeof(PHYSICS));
 
    return list_push(psys->list, new_p, &free);
} /* add_particle() */
 
int add_particle_ex(PARTICLE_SYSTEM* psys, int spr, int mode, int off_x, int off_y, int lifetime, int size, ALLEGRO_COLOR color, double vx, double vy, double vz, double ax, double ay, double az) {
    PHYSICS object;
    VECTOR3D_SET(object.position, off_x, off_y, 0.0);
    VECTOR3D_SET(object.speed, vx, vy, vz);
    VECTOR3D_SET(object.acceleration, ax, ay, az);
    VECTOR3D_SET(object.orientation, 0.0, 0.0, 0.0);
    VECTOR3D_SET(object.angular_speed, 0.0, 0.0, 0.0);
    VECTOR3D_SET(object.angular_acceleration, 0.0, 0.0, 0.0);
 
    return add_particle(psys, spr, mode, lifetime, size, color, object);
} /* add_particle_ex () */
 
int manage_particle_ex(PARTICLE_SYSTEM* psys, double delta_t) {
    __n_assert(psys, return FALSE);
 
    LIST_NODE* node = NULL;
    PARTICLE* ptr = NULL;
 
    node = psys->list->start;
 
    while (node) {
        ptr = (PARTICLE*)node->ptr;
        if (ptr->lifetime != -1) {
            ptr->lifetime -= delta_t / 1000.0;
        }
 
        if (ptr->lifetime > 0 || ptr->lifetime == -1) {
            update_physics_position(&ptr->object, delta_t);
            node = node->next;
        } else {
            LIST_NODE* node_to_kill = node;
            node = node->next;
            ptr = remove_list_node(psys->list, node_to_kill, PARTICLE);
            Free(ptr);
        }
    }
 
    return TRUE;
} /* manage_particle_ex() */
 
int manage_particle(PARTICLE_SYSTEM* psys) {
    __n_assert(psys, return FALSE);
 
    double delta_t = get_usec(&psys->timer);
    return manage_particle_ex(psys, delta_t);
} /* manage_particle() */
 
int draw_particle(PARTICLE_SYSTEM* psys, double xpos, double ypos, int w, int h, double range) {
    __n_assert(psys, return FALSE);
 
    LIST_NODE* node = NULL;
    PARTICLE* ptr = NULL;
 
    node = psys->list->start;
 
    while (node) {
        double x = 0, y = 0;
 
        ptr = (PARTICLE*)node->ptr;
        x = ptr->object.position[0] - xpos;
        y = ptr->object.position[1] - ypos;
 
        if ((x < -range) || (x > (w + range)) || (y < -range) || (y > (h + range))) {
            node = node->next;
            continue;
        }
 
        for (int it = 0; it < 3; it++) {
            while (ptr->object.orientation[it] < 0.0)
                ptr->object.orientation[it] += 256.0;
 
            if (ptr->object.orientation[it] >= 256.0)
                ptr->object.orientation[it] = fmod(ptr->object.orientation[it], 256.0);
        }
 
        if (ptr->mode == SINUS_PART) {
            if (ptr->object.speed[0] != 0)
                x = x + ptr->object.speed[0] * sin((ptr->object.position[0] / ptr->object.speed[0]));
            else
                x = x + ptr->object.speed[0] * sin(ptr->object.position[0]);
 
            if (ptr->object.speed[1] != 0)
                y = y + ptr->object.speed[1] * cos((ptr->object.speed[1] / ptr->object.speed[1]));
            else
                y = y + ptr->object.speed[1] * sin(ptr->object.position[1]);
 
            if (ptr->spr_id >= 0 && ptr->spr_id < psys->max_sprites && psys->sprites[ptr->spr_id]) {
                int spr_w = al_get_bitmap_width(psys->sprites[ptr->spr_id]);
                int spr_h = al_get_bitmap_height(psys->sprites[ptr->spr_id]);
 
                al_draw_rotated_bitmap(psys->sprites[ptr->spr_id], spr_w / 2, spr_h / 2, x - spr_w / 2, y - spr_h / 2, al_ftofix(ptr->object.orientation[2]), 0);
            } else
                al_draw_circle(x, y, ptr->size, ptr->color, 1);
        }
 
        if (ptr->mode & NORMAL_PART) {
            if (ptr->spr_id >= 0 && ptr->spr_id < psys->max_sprites && psys->sprites[ptr->spr_id]) {
                int bmp_w = al_get_bitmap_width(psys->sprites[ptr->spr_id]);
                int bmp_h = al_get_bitmap_height(psys->sprites[ptr->spr_id]);
 
                al_draw_rotated_bitmap(psys->sprites[ptr->spr_id], bmp_w / 2, bmp_h / 2, x - bmp_w / 2, y - bmp_h / 2, al_ftofix(ptr->object.orientation[2]), 0);
            } else
                al_draw_circle(x, y, ptr->size, ptr->color, 1);
        } else if (ptr->mode & PIXEL_PART) {
            al_draw_filled_rectangle(x - ptr->size, y - ptr->size, x + ptr->size, y + ptr->size, ptr->color);
        } else
            al_draw_circle(x, y, ptr->size, ptr->color, 1);
        node = node->next;
    }
 
    return TRUE;
} /* draw_particle() */
 
int free_particle_system(PARTICLE_SYSTEM** psys) {
    __n_assert((*psys), return FALSE);
 
    PARTICLE* particle = NULL;
    while ((*psys)->list->start) {
        particle = remove_list_node((*psys)->list, (*psys)->list->start, PARTICLE);
        Free(particle);
    }
    Free((*psys));
 
    return TRUE;
} /* free_particle_system() */
 
int move_particles(PARTICLE_SYSTEM* psys, double vx, double vy, double vz) {
    __n_assert(psys, return FALSE);
 
    LIST_NODE* node = NULL;
    PARTICLE* ptr = NULL;
 
    node = psys->list->start;
 
    while (node) {
        ptr = (PARTICLE*)node->ptr;
        ptr->object.position[0] = ptr->object.position[0] + vx;
        ptr->object.position[1] = ptr->object.position[1] + vy;
        ptr->object.position[2] = ptr->object.position[2] + vz;
        node = node->next;
    }
    return TRUE;
}