Merge branch 'master' of git://itanic.dy.fi/sdl-planets

Signed-off-by: Timo Kokkonen <kaapeli@itanic.dy.fi>

diff --git a/planet.c b/planet.c
index a79c085a8ef714d6e67bb10036247292929d1245..24b2d21da259f90d280ee6fd76bfb475d23221ee 100644 (file)
--- a/planet.c
+++ b/planet.c
@@ -86,8 +86,8 @@ static void setup_planet(struct planet *p, double mass, double total_mass,
 
        velocity *= pow(distance / radius, 0.2);
 
-       p->pos.x = cos(angle) * distance;
-       p->pos.y = sin(angle) * distance;
+       p->tree.pos.x = cos(angle) * distance;
+       p->tree.pos.y = sin(angle) * distance;
 
        p->speed.x = -sin(angle) * velocity;
        p->speed.y = cos(angle) * velocity;
@@ -179,7 +179,7 @@ void draw_planet(SDL_Surface *screen, struct planet *p,
        float radius = p->radius * cam->zoom;
        int i;
 
-       vector_sub(&p->pos, &cam->pos, &pos);
+       vector_sub(&p->tree.pos, &cam->pos, &pos);
        vector_scale(&pos, cam->zoom, &pos);
        pos.x += screen->w / 2;
        pos.y += screen->h / 2;
@@ -191,7 +191,7 @@ void draw_planet(SDL_Surface *screen, struct planet *p,
 
                        struct planet *q = tree_to_planet(p->tree.child[i]);
 
-                       draw_line(screen, &p->pos, &q->pos,
+                       draw_line(screen, &p->tree.pos, &q->tree.pos,
                                  p->r, p->g, p->b, cam);
                }
        }
@@ -204,7 +204,7 @@ int gravitize_planets(struct planet *a, struct planet *b, const double time)
        struct vector distance, sum;
        double dist, f, acc;
 
-       vector_sub(&a->pos, &b->pos, &distance);
+       vector_sub(&a->tree.pos, &b->tree.pos, &distance);
 
        dist = vector_abs(&distance);
 
@@ -243,7 +243,7 @@ static void _merge_planets(struct planet *a, struct planet *b)
        mass = a->mass + b->mass;
 
        if (a->mass < b->mass)
-               a->pos = b->pos;
+               a->tree.pos = b->tree.pos;
 
        a->r = (a->r * a->mass + b->r * b->mass) / mass;
        a->g = (a->g * a->mass + b->g * b->mass) / mass;
@@ -280,11 +280,11 @@ static int planet_search_when_moving(struct quadtree *node,
        int up = 0, left = 0, right = 0, down = 0;
 
        for (i = 0; i < 2; i++) {
-               if (it->limit[i].x < p->pos.x)
+               if (it->limit[i].x < p->tree.pos.x)
                        left = 1;
                else
                        right = 1;
-               if (it->limit[i].y < p->pos.y)
+               if (it->limit[i].y < p->tree.pos.y)
                        up = 1;
                else
                        down = 1;
@@ -325,19 +325,19 @@ struct planet *move_planet(struct planet *p, const double time)
        int modify = 0;
 
        vector_scale(&p->speed, time, &tmp);
-       vector_add(&p->pos, &tmp, &new_pos);
+       vector_add(&p->tree.pos, &tmp, &new_pos);
 
        /* Check if we have crossed any of the parents */
        parent = p->tree.parent;
        while (parent) {
                pa = tree_to_planet(parent);
-               if (p->pos.x < pa->pos.x && new_pos.x > pa->pos.x)
+               if (p->tree.pos.x < pa->tree.pos.x && new_pos.x > pa->tree.pos.x)
                        modify = 1;
-               if (p->pos.x > pa->pos.x && new_pos.x < pa->pos.x)
+               if (p->tree.pos.x > pa->tree.pos.x && new_pos.x < pa->tree.pos.x)
                        modify = 1;
-               if (p->pos.y < pa->pos.y && new_pos.y > pa->pos.y)
+               if (p->tree.pos.y < pa->tree.pos.y && new_pos.y > pa->tree.pos.y)
                        modify = 1;
-               if (p->pos.y > pa->pos.y && new_pos.y < pa->pos.y)
+               if (p->tree.pos.y > pa->tree.pos.y && new_pos.y < pa->tree.pos.y)
                        modify = 1;
 
                if (!modify) {
@@ -346,7 +346,7 @@ struct planet *move_planet(struct planet *p, const double time)
                }
 
                tree_parent = quadtree_del(&p->tree, &planet_ops);
-               p->pos = new_pos;
+               p->tree.pos = new_pos;
                quadtree_add(tree_parent, &p->tree, &planet_ops);
                return tree_to_planet(tree_parent);
        }
@@ -357,13 +357,13 @@ struct planet *move_planet(struct planet *p, const double time)
                 * them into correct place within the tree.
                 */
                it.qt_iterator.head = &p->tree;
-               it.limit[0] = p->pos;
+               it.limit[0] = p->tree.pos;
                it.limit[1] = new_pos;
                it.qt_iterator.direction = planet_search_when_moving;
                it.qt_iterator.callback = planet_move_iterator;
                walk_quadtree(&it.qt_iterator);
        }
-       p->pos = new_pos;
+       p->tree.pos = new_pos;
 
        return tree_to_planet(quadtree_find_parent(&p->tree));
 }
@@ -371,26 +371,7 @@ struct planet *move_planet(struct planet *p, const double time)
 void print_planet(const struct planet *p)
 {
        printf("pos: (%f,%f), speed: (%f,%f), mass: %f, radius %f\n",
-              p->pos.x, p->pos.y, p->speed.x, p->speed.y, p->mass, p->radius);
-}
-
-int planet_spatial_compare(struct quadtree *ta, struct quadtree *tb)
-{
-       struct planet *a, *b;
-       int up, left;
-       a = tree_to_planet(ta);
-       b = tree_to_planet(tb);
-
-       up = b->pos.y < a->pos.y;
-       left = b->pos.x < a->pos.x;
-
-       if (up && left)
-               return 0;
-       if (up && !left)
-               return 1;
-       if (left)
-               return 2;
-       return 3;
+              p->tree.pos.x, p->tree.pos.y, p->speed.x, p->speed.y, p->mass, p->radius);
 }
 
 int planet_search_rectangular(struct quadtree *node,
@@ -402,11 +383,11 @@ int planet_search_rectangular(struct quadtree *node,
        int up = 0, left = 0, right = 0, down = 0;
 
        for (i = 0; i < 2; i++) {
-               if (it->limit[i].x < p->pos.x)
+               if (it->limit[i].x < p->tree.pos.x)
                        left = 1;
                else
                        right = 1;
-               if (it->limit[i].y < p->pos.y)
+               if (it->limit[i].y < p->tree.pos.y)
                        up = 1;
                else
                        down = 1;
@@ -452,7 +433,7 @@ static void planet_recalculate_stats(struct quadtree *node)
                c = tree_to_planet(node->child[i]);
                p->tree_mass += c->tree_mass;
 
-               vector_sub(&p->pos, &c->pos, &vect);
+               vector_sub(&p->tree.pos, &c->tree.pos, &vect);
                dist = vector_abs(&vect);
                dist += c->tree_area;
                p->tree_area = MAX(p->tree_area, dist);
@@ -460,7 +441,6 @@ static void planet_recalculate_stats(struct quadtree *node)
 }
 
 struct quadtree_ops planet_ops = {
-       .compare = planet_spatial_compare,
        .recalculate_stats = planet_recalculate_stats,
 };
 

diff --git a/planet.h b/planet.h
index 89f232ac3d706dcc9d7f924e73f1434c40d7b5d5..9f71b99fa679259ccae61692b83b4f2ed6d7755b 100644 (file)
--- a/planet.h
+++ b/planet.h
@@ -11,7 +11,6 @@
 
 struct planet {
        struct vector speed;
-       struct vector pos;
        struct list_head list;
        struct quadtree tree;
        double mass;

diff --git a/quadtree.c b/quadtree.c
index 61a26997c1555a7ee5c3419633d67164051bee28..10c4ec86f3ec3d93baae1b9543e578516c3922c3 100644 (file)
--- a/quadtree.c
+++ b/quadtree.c
@@ -99,22 +99,29 @@ static void validate_tree(const struct quadtree *node)
                validate_subtree(quadtree_find_parent(node));
 }
 
+static int quadtree_compare(struct quadtree *a, struct quadtree *b)
+{
+       int up, left;
+
+       up = b->pos.y < a->pos.y;
+       left = b->pos.x < a->pos.x;
+
+       if (up && left)
+               return 0;
+       if (up && !left)
+               return 1;
+       if (left)
+               return 2;
+       return 3;
+}
+
 /**
  * quadtree_add - add a node to a quadtree
  * @parent: parent node
  * @new: the new node to be added
- * @compare: pointer to a comparison function
  *
  * Add a node to a quadtree. The tree is kept in order, the new node
- * is placed in the end of appropriate branch. The compare function is
- * used to compare the new node against a branch in the tree. The
- * comparison function must have following return value depending on
- * the position of node a compared to the position of node b:
- *
- * 0: upper left
- * 1: upper right
- * 2: lower left
- * 3: lower right
+ * is placed in the end of appropriate branch.
  *
  * The case of nodes sharing identical coordinates is not taken into
  * account at all.
@@ -129,7 +136,7 @@ struct quadtree *quadtree_add(struct quadtree *parent, struct quadtree *new,
 
        validate_tree(parent);
 
-       ret = ops->compare(parent, new);
+       ret = quadtree_compare(parent, new);
 
        if (ret < 0 || ret >= 4) {
                printf("Invalid comparison result of %d\n", ret);

diff --git a/quadtree.h b/quadtree.h
index 0784147d50c58264ee08b02296b59eea3bbde3b9..619a67574fc045f69ed3f7ea959f42d2e1046e7a 100644 (file)
--- a/quadtree.h
+++ b/quadtree.h
@@ -4,8 +4,10 @@
 #include <string.h>
 
 #include "utils.h"
+#include "vector.h"
 
 struct quadtree {
+       struct vector pos;
        struct quadtree *child[4];
        struct quadtree *parent;
 
@@ -15,12 +17,6 @@ struct quadtree {
 };
 
 struct quadtree_ops {
-       /*
-        * Comparison function that is needed to find out the correct
-        * location for a node in the tree
-        */
-       int (*compare)(struct quadtree *a, struct quadtree *b);
-
        /*
         * Calculates required statistical information for a node
         */