p->tree.pos.x, p->tree.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->tree.pos.y < a->tree.pos.y;
- left = b->tree.pos.x < a->tree.pos.x;
-
- if (up && left)
- return 0;
- if (up && !left)
- return 1;
- if (left)
- return 2;
- return 3;
-}
-
int planet_search_rectangular(struct quadtree *node,
struct quadtree_iterator *itr)
{
}
struct quadtree_ops planet_ops = {
- .compare = planet_spatial_compare,
.recalculate_stats = planet_recalculate_stats,
};
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.
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);
};
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
*/