Colony

/**

 * @file world.c

 * @author Colony Project

 * @brief Simulator world code

 *

 * This is the world.

 **/

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <stdarg.h>

#include "world.h"

world_t world;

int init_world(int max_objs, bbox_t b)

{

    world.max_objs = max_objs;

    world.cur_objs = 0;

    world.objs = calloc(max_objs,  sizeof(object_t));

    world.win = b;

    //PBBOX(b);

}

int destroy_world()

{

    int i;

    for (i = 0; i < world.cur_objs; i++) {

        destroy(&world.objs[i]);

    }

    free(world.objs);

}

double (*collide_func[NUM_SHAPES])(ray_t *ray, object_t *obj) =

    {

    collide_poly

    };

int (*create_func[NUM_SHAPES])(object_t *obj, va_list ap) =

{

    create_poly

};

int (*destroy_func[NUM_SHAPES])(object_t *obj) = 

    {

    destroy_poly

    };

double collide_circle(ray_t *ray, object_t *obj)

{

    return -1;

}

double collide_seg(ray_t *ray, point_t p3, point_t p4)

{   

    double denom, nume_a, nume_b, ua, ub, xint, yint, dist;

    point_t p1 = ray->p;

    point_t p2 = {ray->p.x+cos(ray->d),ray->p.y+sin(ray->d)};

   // printf("(%g,%g) --> (%g,%g) with (%g,%g) --> (%g,%g)\n",p1.x,p1.y,p2.x,p2.y,p3.x,p3.y,p4.x,p4.y);

    denom = (p2.y-p1.y)*(p4.x-p3.x)-(p2.x-p1.x)*(p4.y-p3.y);

    if (denom == 0) {

        return RAY_MISS;

    }

    nume_a = (p2.x-p1.x)*(p3.y-p1.y)-(p2.y-p1.y)*(p3.x-p1.x);

    nume_b = (p4.x-p3.x)*(p3.y-p1.y)-(p4.y-p3.y)*(p3.x-p1.x);

    ua = nume_a/denom;

    if (ua < 0 || ua > 1) {

        return RAY_MISS;

    }

    ub = nume_b/denom;

    if (ub < 0) {

        return RAY_MISS;

    }

    xint = p3.x+ua*(p4.x-p3.x);

    yint = p3.y+ua*(p4.y-p3.y);

    dist = sqrt((xint-p1.x)*(xint-p1.x)+(yint-p1.y)*(yint-p1.y));

    return dist;

}

double collide_poly(ray_t *ray, object_t *obj)

{

    int i;

    double min = RAY_MISS;

    double x;

    poly_t *p = (poly_t *) obj->props;

    if (obj->id != ID_POLY){

        return -1;

    }

    for (i = 0; i < p->num_pts - 1; i++) {

        if ((x = collide_seg(ray, p->pts[i], p->pts[i+1])) < min){

            min = x;

        }

    }

    if (p->type == POLY_CONNECTED) {

        if ((x = collide_seg(ray,p->pts[i],p->pts[0])) < min)

            min = x;

    }

    return min;

}

double collide(ray_t *ray, object_t *obj) 

{

    if (ray == NULL || obj == NULL)

    {

        return -1;

    }

    return collide_func[obj->id+ID_OFFSET](ray, obj);

}

object_t *create(int id, ...)

{

    object_t *obj = &(world.objs[world.cur_objs++]);

    va_list args;

    va_start(args, id);

    if (create_func[id+ID_OFFSET](obj, args) < 0) {

        /* Cleanup ? */

    }

    va_end(args);

    return obj;

}

int destroy(object_t *obj) 

{

    if (obj->id == ID_NULL)

        return 0;

    destroy_func[obj->id+ID_OFFSET](obj);

    obj->id = ID_NULL;

}

/**

 *

 **/

int create_poly(object_t *obj, va_list ap) 

{

    int i;

    poly_t *p;

    int argc =  va_arg(ap, int);

    int poly_type = va_arg(ap, int);

    p = malloc(sizeof(poly_t));

    p->num_pts = argc;

    p->pts = malloc((argc) * sizeof(point_t));

    p->type = poly_type;

    for(i=0;i < argc; i++) {

        p->pts[i].x = va_arg(ap, double);

        p->pts[i].y = va_arg(ap, double);

    }

    obj->id = ID_POLY;

    obj->bbox = NULL;

    obj->props = p;

    return 1;

}

int create_rect(object_t *obj, va_list ap)

{

    int i;

    poly_t *p;

    int argc = va_arg(ap, int);

}

int destroy_poly (object_t *obj)

{

    poly_t *p;

    p =  (poly_t *)obj->props;

    if (p != NULL) free(p->pts);

    free(p);

    return 1;

}

void print_world(void)

{

    int i;

    printf("WORLD: %d object(s) in (%g,%g)->(%g,%g)\n", world.cur_objs, world.win.p1.x,world.win.p1.y,world.win.p2.x,world.win.p2.y);

    for (i = 0; i < world.cur_objs; i++) {

        print_object(&world.objs[i]);

    }

}

void print_object(object_t *obj)

{

    int i;

    poly_t *p;

    switch (obj->id) {

        case ID_NULL:

            printf("\tNULL\n");

        case ID_POLY:

            p = (poly_t *) obj->props;

            printf("\tPOLYGON (%d points, %s) { ", p->num_pts, p->type?"connected" : "disconnected");

            for (i = 0; i < p->num_pts; i++){

                printf("(%g, %g) ", p->pts[i].x, p->pts[i].y);

            }

            printf("}\n");

            break;

        default:

            break;

    }

}