-/* -*- mode: c; c-basic-offset: 2 -*-
+/* -*- mode: c; c-basic-offset: 8 -*-
* See:
*
* http://en.wikipedia.org/wiki/Verlet_integration
void
object_init (Object *object, double x, double y, double mass)
{
- object->position.x = x;
- object->position.y = y;
- object->previous_position.x = x;
- object->previous_position.y = y;
- object->mass = mass;
+ object->position.x = x;
+ object->position.y = y;
+ object->previous_position.x = x;
+ object->previous_position.y = y;
+ object->mass = mass;
}
void
spring_init (Spring *spring, Object *a, Object *b, double length)
{
- spring->a = a;
- spring->b = b;
- spring->length = length;
+ spring->a = a;
+ spring->b = b;
+ spring->length = length;
}
void
stick_init (Stick *stick, Object *a, Object *b, double length)
{
- stick->a = a;
- stick->b = b;
- stick->length = length;
+ stick->a = a;
+ stick->b = b;
+ stick->length = length;
}
void
string_init (String *string, Object *a, Object *b, double length)
{
- string->a = a;
- string->b = b;
- string->length = length;
+ string->a = a;
+ string->b = b;
+ string->length = length;
}
void
offset_spring_init (OffsetSpring *spring, Object *a, Object *b,
double dx, double dy)
{
- spring->a = a;
- spring->b = b;
- spring->dx = dx;
- spring->dy = dy;
+ spring->a = a;
+ spring->b = b;
+ spring->dx = dx;
+ spring->dy = dy;
}
void
spacer_init (Spacer *spacer, Object *a, Object *b, double length)
{
- spacer->a = a;
- spacer->b = b;
- spacer->length = length;
+ spacer->a = a;
+ spacer->b = b;
+ spacer->length = length;
}
void
anchor_init (Anchor *anchor, Object *object, double x, double y)
{
- anchor->object = object;
- anchor->x = x;
- anchor->y = y;
+ anchor->object = object;
+ anchor->x = x;
+ anchor->y = y;
}
void
polygon_init (Polygon *p, int enclosing, int num_points, ...)
{
- double dx, dy, length;
- int i, j;
- va_list ap;
-
- /* Polygons are defined counter-clock-wise in a coordinate system
- * with the y-axis pointing down. */
-
- va_start (ap, num_points);
- p->num_points = num_points;
- p->points = g_new (Point, num_points);
- p->enclosing = enclosing;
-
- for (i = 0; i < num_points; i++) {
- p->points[i].x = va_arg (ap, double);
- p->points[i].y = va_arg (ap, double);
- }
- va_end (ap);
+ double dx, dy, length;
+ int i, j;
+ va_list ap;
+
+ /* Polygons are defined counter-clock-wise in a coordinate system
+ * with the y-axis pointing down. */
+
+ va_start (ap, num_points);
+ p->num_points = num_points;
+ p->points = g_new (Point, num_points);
+ p->enclosing = enclosing;
+
+ for (i = 0; i < num_points; i++) {
+ p->points[i].x = va_arg (ap, double);
+ p->points[i].y = va_arg (ap, double);
+ }
+ va_end (ap);
- p->normals = g_new (Vector, p->num_points);
- /* Compute outward pointing normals. p->normals[i] is the normal
- * for the edged between p->points[i] and p->points[i + 1]. */
- for (i = 0; i < p->num_points; i++) {
- j = (i + 1) % p->num_points;
- dx = p->points[j].x - p->points[i].x;
- dy = p->points[j].y - p->points[i].y;
- length = sqrt (dx * dx + dy * dy);
- p->normals[i].x = -dy / length;
- p->normals[i].y = dx / length;
- }
+ p->normals = g_new (Vector, p->num_points);
+ /* Compute outward pointing normals. p->normals[i] is the normal
+ * for the edged between p->points[i] and p->points[i + 1]. */
+ for (i = 0; i < p->num_points; i++) {
+ j = (i + 1) % p->num_points;
+ dx = p->points[j].x - p->points[i].x;
+ dy = p->points[j].y - p->points[i].y;
+ length = sqrt (dx * dx + dy * dy);
+ p->normals[i].x = -dy / length;
+ p->normals[i].y = dx / length;
+ }
}
void
polygon_init_diamond (Polygon *polygon, double x, double y)
{
- return polygon_init (polygon, FALSE, 5,
- x, y,
- x + 10, y + 40,
- x + 90, y + 40,
- x + 100, y,
- x + 50, y - 20);
+ return polygon_init (polygon, FALSE, 5,
+ x, y,
+ x + 10, y + 40,
+ x + 90, y + 40,
+ x + 100, y,
+ x + 50, y - 20);
}
void
polygon_init_rectangle (Polygon *polygon, double x0, double y0,
double x1, double y1)
{
- return polygon_init (polygon, FALSE, 4, x0, y0, x0, y1, x1, y1, x1, y0);
+ return polygon_init (polygon, FALSE, 4, x0, y0, x0, y1, x1, y1, x1, y0);
}
void
polygon_init_enclosing_rectangle (Polygon *polygon, double x0, double y0,
- double x1, double y1)
+ double x1, double y1)
{
- return polygon_init (polygon, TRUE, 4, x0, y0, x0, y1, x1, y1, x1, y0);
+ return polygon_init (polygon, TRUE, 4, x0, y0, x0, y1, x1, y1, x1, y0);
}
void
model_fini (Model *model)
{
- int i;
-
- g_free (model->objects);
- g_free (model->sticks);
- g_free (model->strings);
- for (i = 0; i < model->num_offsets; i++)
- g_free (model->offsets[i].objects);
- g_free (model->springs);
- g_free (model->offset_springs);
- g_free (model->spacers);
- for (i = 0; i < model->num_polygons; i++)
- g_free (model->polygons[i].points);
- g_free (model->polygons);
-
- memset (model, 0, sizeof *model);
+ int i;
+
+ g_free (model->objects);
+ g_free (model->sticks);
+ g_free (model->strings);
+ for (i = 0; i < model->num_offsets; i++)
+ g_free (model->offsets[i].objects);
+ g_free (model->springs);
+ g_free (model->offset_springs);
+ g_free (model->spacers);
+ for (i = 0; i < model->num_polygons; i++)
+ g_free (model->polygons[i].points);
+ g_free (model->polygons);
+
+ memset (model, 0, sizeof *model);
}
static void
model_accumulate_forces (Model *model)
{
- int i;
- double x, y, dx, dy, distance, displacement;
- Point middle;
- Vector u, v;
-
- for (i = 0; i < model->num_objects; i++) {
- /* Gravity */
- model->objects[i].force.x = 0;
- model->objects[i].force.y = gravity * model->objects[i].mass;
-
- /* Friction */
- v.x = model->objects[i].position.x - model->objects[i].previous_position.x;
- v.y = model->objects[i].position.y - model->objects[i].previous_position.y;
- model->objects[i].force.x -= v.x * friction;
- model->objects[i].force.y -= v.y * friction;
- }
-
- for (i = 0; i < model->num_springs; i++) {
- x = model->springs[i].a->position.x;
- y = model->springs[i].a->position.y;
- dx = model->springs[i].b->position.x - x;
- dy = model->springs[i].b->position.y - y;
- distance = sqrt (dx * dx + dy * dy);
- u.x = dx / distance;
- u.y = dy / distance;
- displacement = distance - model->springs[i].length;
- model->springs[i].a->force.x += u.x * model->k * displacement;
- model->springs[i].a->force.y += u.y * model->k * displacement;
- model->springs[i].b->force.x -= u.x * model->k * displacement;
- model->springs[i].b->force.y -= u.y * model->k * displacement;
- }
-
- for (i = 0; i < model->num_offset_springs; i++) {
- middle.x =
- (model->offset_springs[i].a->position.x +
- model->offset_springs[i].b->position.x) / 2;
- middle.y =
- (model->offset_springs[i].a->position.y +
- model->offset_springs[i].b->position.y) / 2;
-
- x = middle.x - model->offset_springs[i].dx / 2;
- y = middle.y - model->offset_springs[i].dy / 2;
-
- dx = x - model->offset_springs[i].a->position.x;
- dy = y - model->offset_springs[i].a->position.y;
-
- model->offset_springs[i].a->force.x += dx * model->k;
- model->offset_springs[i].a->force.y += dy * model->k;
- model->offset_springs[i].b->force.x -= dx * model->k;
- model->offset_springs[i].b->force.y -= dy * model->k;
- }
-
- for (i = 0; i < model->num_objects; i++) {
- double f =
- model->objects[i].force.x * model->objects[i].force.x +
- model->objects[i].force.y * model->objects[i].force.y;
-
- if (f > 100000000)
- abort();
- }
+ int i;
+ double x, y, dx, dy, distance, displacement;
+ Point middle;
+ Vector u, v;
+
+ for (i = 0; i < model->num_objects; i++) {
+ /* Gravity */
+ model->objects[i].force.x = 0;
+ model->objects[i].force.y = gravity * model->objects[i].mass;
+
+ /* Friction */
+ v.x = model->objects[i].position.x - model->objects[i].previous_position.x;
+ v.y = model->objects[i].position.y - model->objects[i].previous_position.y;
+ model->objects[i].force.x -= v.x * friction;
+ model->objects[i].force.y -= v.y * friction;
+ }
+
+ for (i = 0; i < model->num_springs; i++) {
+ x = model->springs[i].a->position.x;
+ y = model->springs[i].a->position.y;
+ dx = model->springs[i].b->position.x - x;
+ dy = model->springs[i].b->position.y - y;
+ distance = sqrt (dx * dx + dy * dy);
+ u.x = dx / distance;
+ u.y = dy / distance;
+ displacement = distance - model->springs[i].length;
+ model->springs[i].a->force.x += u.x * model->k * displacement;
+ model->springs[i].a->force.y += u.y * model->k * displacement;
+ model->springs[i].b->force.x -= u.x * model->k * displacement;
+ model->springs[i].b->force.y -= u.y * model->k * displacement;
+ }
+
+ for (i = 0; i < model->num_offset_springs; i++) {
+ middle.x =
+ (model->offset_springs[i].a->position.x +
+ model->offset_springs[i].b->position.x) / 2;
+ middle.y =
+ (model->offset_springs[i].a->position.y +
+ model->offset_springs[i].b->position.y) / 2;
+
+ x = middle.x - model->offset_springs[i].dx / 2;
+ y = middle.y - model->offset_springs[i].dy / 2;
+
+ dx = x - model->offset_springs[i].a->position.x;
+ dy = y - model->offset_springs[i].a->position.y;
+
+ model->offset_springs[i].a->force.x += dx * model->k;
+ model->offset_springs[i].a->force.y += dy * model->k;
+ model->offset_springs[i].b->force.x -= dx * model->k;
+ model->offset_springs[i].b->force.y -= dy * model->k;
+ }
+
+ for (i = 0; i < model->num_objects; i++) {
+ double f =
+ model->objects[i].force.x * model->objects[i].force.x +
+ model->objects[i].force.y * model->objects[i].force.y;
+
+ if (f > 100000000)
+ abort();
+ }
}
static void
model_integrate (Model *model, double step)
{
- double x, y;
- Object *o;
- int i;
-
- for (i = 0; i < model->num_objects; i++) {
- o = &model->objects[i];
- x = o->position.x;
- y = o->position.y;
+ double x, y;
+ Object *o;
+ int i;
+
+ for (i = 0; i < model->num_objects; i++) {
+ o = &model->objects[i];
+ x = o->position.x;
+ y = o->position.y;
- o->position.x =
- x + (x - o->previous_position.x) + o->force.x * step * step;
- o->position.y =
- y + (y - o->previous_position.y) + o->force.y * step * step;
-
- o->previous_position.x = x;
- o->previous_position.y = y;
- }
+ o->position.x =
+ x + (x - o->previous_position.x) + o->force.x * step * step;
+ o->position.y =
+ y + (y - o->previous_position.y) + o->force.y * step * step;
+
+ o->previous_position.x = x;
+ o->previous_position.y = y;
+ }
}
/* The square root in the distance computation for the string and
estimate_distance (double dx, double dy, double r)
{
#ifdef APPROXIMATE_SQUARE_ROOTS
- return (r + (dx * dx + dy * dy) / r) / 2;
+ return (r + (dx * dx + dy * dy) / r) / 2;
#else
- return sqrt (dx * dx + dy * dy);
+ return sqrt (dx * dx + dy * dy);
#endif
}
static int
polygon_contains_point (Polygon *polygon, Point *point)
{
- int i;
- double dx, dy;
+ int i;
+ double dx, dy;
- for (i = 0; i < polygon->num_points; i++) {
- dx = point->x - polygon->points[i].x;
- dy = point->y - polygon->points[i].y;
+ for (i = 0; i < polygon->num_points; i++) {
+ dx = point->x - polygon->points[i].x;
+ dy = point->y - polygon->points[i].y;
- if (polygon->normals[i].x * dx + polygon->normals[i].y * dy >= 0)
- return polygon->enclosing;
- }
+ if (polygon->normals[i].x * dx + polygon->normals[i].y * dy >= 0)
+ return polygon->enclosing;
+ }
- return !polygon->enclosing;
+ return !polygon->enclosing;
}
static void
polygon_reflect_object (Polygon *polygon, Object *object)
{
- int i, edge;
- double d, distance;
- Vector *n;
-
- distance = -1000;
- for (i = 0; i < polygon->num_points; i++) {
- d = polygon->normals[i].x * (object->position.x - polygon->points[i].x) +
- polygon->normals[i].y * (object->position.y - polygon->points[i].y);
-
- if (d > distance) {
- distance = d;
- edge = i;
- n = &polygon->normals[i];
- }
- }
-
- object->position.x -= (1 + elasticity) * distance * n->x;
- object->position.y -= (1 + elasticity) * distance * n->y;
-
- distance =
- n->x * (object->previous_position.x - polygon->points[edge].x) +
- n->y * (object->previous_position.y - polygon->points[edge].y);
-
- object->previous_position.x -= (1 + elasticity) * distance * n->x;
- object->previous_position.y -= (1 + elasticity) * distance * n->y;
+ int i, edge;
+ double d, distance;
+ Vector *n;
+
+ distance = -1000;
+ for (i = 0; i < polygon->num_points; i++) {
+ d = polygon->normals[i].x * (object->position.x - polygon->points[i].x) +
+ polygon->normals[i].y * (object->position.y - polygon->points[i].y);
+
+ if (d > distance) {
+ distance = d;
+ edge = i;
+ n = &polygon->normals[i];
+ }
+ }
+
+ object->position.x -= (1 + elasticity) * distance * n->x;
+ object->position.y -= (1 + elasticity) * distance * n->y;
+
+ distance =
+ n->x * (object->previous_position.x - polygon->points[edge].x) +
+ n->y * (object->previous_position.y - polygon->points[edge].y);
+
+ object->previous_position.x -= (1 + elasticity) * distance * n->x;
+ object->previous_position.y -= (1 + elasticity) * distance * n->y;
}
static void
model_constrain_polygon (Model *model, Polygon *polygon)
{
- int i;
+ int i;
- for (i = 0; i < model->num_objects; i++) {
- if (polygon_contains_point (polygon, &model->objects[i].position))
- polygon_reflect_object (polygon, &model->objects[i]);
- }
+ for (i = 0; i < model->num_objects; i++) {
+ if (polygon_contains_point (polygon, &model->objects[i].position))
+ polygon_reflect_object (polygon, &model->objects[i]);
+ }
}
static void
model_constrain_anchor (Model *model, Anchor *anchor)
{
- anchor->object->position.x = anchor->x;
- anchor->object->position.y = anchor->y;
- anchor->object->previous_position.x = anchor->x;
- anchor->object->previous_position.y = anchor->y;
+ anchor->object->position.x = anchor->x;
+ anchor->object->position.y = anchor->y;
+ anchor->object->previous_position.x = anchor->x;
+ anchor->object->previous_position.y = anchor->y;
}
static void
model_constrain_offset (Model *model, Offset *offset)
{
- double x, y;
- int i;
-
- x = 0;
- y = 0;
- for (i = 0; i < offset->num_objects; i++) {
- x += offset->objects[i]->position.x;
- y += offset->objects[i]->position.y;
- }
-
- x = x / offset->num_objects - offset->dx * (offset->num_objects - 1) / 2;
- y = y / offset->num_objects - offset->dy * (offset->num_objects - 1) / 2;
+ double x, y;
+ int i;
+
+ x = 0;
+ y = 0;
+ for (i = 0; i < offset->num_objects; i++) {
+ x += offset->objects[i]->position.x;
+ y += offset->objects[i]->position.y;
+ }
+
+ x = x / offset->num_objects - offset->dx * (offset->num_objects - 1) / 2;
+ y = y / offset->num_objects - offset->dy * (offset->num_objects - 1) / 2;
- for (i = 0; i < offset->num_objects; i++) {
- offset->objects[i]->position.x = x + offset->dx * i;
- offset->objects[i]->position.y = y + offset->dy * i;
- }
+ for (i = 0; i < offset->num_objects; i++) {
+ offset->objects[i]->position.x = x + offset->dx * i;
+ offset->objects[i]->position.y = y + offset->dy * i;
+ }
}
static void
model_constrain (Model *model)
{
- double dx, dy, x, y, distance, fraction;
- int i;
-
- if (model->mouse_anchor.object != NULL)
- model_constrain_anchor (model, &model->mouse_anchor);
- for (i = 0; i < model->num_anchors; i++)
- model_constrain_anchor (model, &model->anchors[i]);
-
- /* String constraints. */
- for (i = 0; i < model->num_strings; i++) {
- x = model->strings[i].a->position.x;
- y = model->strings[i].a->position.y;
- dx = model->strings[i].b->position.x - x;
- dy = model->strings[i].b->position.y - y;
- distance = estimate_distance (dx, dy, model->strings[i].length);
- if (distance < model->strings[i].length)
- continue;
- fraction = (distance - model->strings[i].length) / distance / 2;
- model->strings[i].a->position.x = x + dx * fraction;
- model->strings[i].a->position.y = y + dy * fraction;
- model->strings[i].b->position.x = x + dx * (1 - fraction);
- model->strings[i].b->position.y = y + dy * (1 - fraction);
- }
-
- /* Spacer constraints. */
- for (i = 0; i < model->num_spacers; i++) {
- x = model->spacers[i].a->position.x;
- y = model->spacers[i].a->position.y;
- dx = model->spacers[i].b->position.x - x;
- dy = model->spacers[i].b->position.y - y;
- distance = estimate_distance (dx, dy, model->spacers[i].length);
- if (distance > model->spacers[i].length)
- continue;
- fraction = (distance - model->spacers[i].length) / distance / 2;
- model->spacers[i].a->position.x = x + dx * fraction;
- model->spacers[i].a->position.y = y + dy * fraction;
- model->spacers[i].b->position.x = x + dx * (1 - fraction);
- model->spacers[i].b->position.y = y + dy * (1 - fraction);
- }
-
- /* Stick constraints. */
- for (i = 0; i < model->num_sticks; i++) {
- x = model->sticks[i].a->position.x;
- y = model->sticks[i].a->position.y;
- dx = model->sticks[i].b->position.x - x;
- dy = model->sticks[i].b->position.y - y;
- distance = estimate_distance (dx, dy, model->sticks[i].length);
- fraction = (distance - model->sticks[i].length) / distance / 2;
- model->sticks[i].a->position.x = x + dx * fraction;
- model->sticks[i].a->position.y = y + dy * fraction;
- model->sticks[i].b->position.x = x + dx * (1 - fraction);
- model->sticks[i].b->position.y = y + dy * (1 - fraction);
- }
-
- /* Offset constraints. */
- for (i = 0; i < model->num_offsets; i++)
- model_constrain_offset (model, &model->offsets[i]);
-
- /* Polygon constraints. */
- for (i = 0; i < model->num_polygons; i++)
- model_constrain_polygon (model, &model->polygons[i]);
+ double dx, dy, x, y, distance, fraction;
+ int i;
+
+ if (model->mouse_anchor.object != NULL)
+ model_constrain_anchor (model, &model->mouse_anchor);
+ for (i = 0; i < model->num_anchors; i++)
+ model_constrain_anchor (model, &model->anchors[i]);
+
+ /* String constraints. */
+ for (i = 0; i < model->num_strings; i++) {
+ x = model->strings[i].a->position.x;
+ y = model->strings[i].a->position.y;
+ dx = model->strings[i].b->position.x - x;
+ dy = model->strings[i].b->position.y - y;
+ distance = estimate_distance (dx, dy, model->strings[i].length);
+ if (distance < model->strings[i].length)
+ continue;
+ fraction = (distance - model->strings[i].length) / distance / 2;
+ model->strings[i].a->position.x = x + dx * fraction;
+ model->strings[i].a->position.y = y + dy * fraction;
+ model->strings[i].b->position.x = x + dx * (1 - fraction);
+ model->strings[i].b->position.y = y + dy * (1 - fraction);
+ }
+
+ /* Spacer constraints. */
+ for (i = 0; i < model->num_spacers; i++) {
+ x = model->spacers[i].a->position.x;
+ y = model->spacers[i].a->position.y;
+ dx = model->spacers[i].b->position.x - x;
+ dy = model->spacers[i].b->position.y - y;
+ distance = estimate_distance (dx, dy, model->spacers[i].length);
+ if (distance > model->spacers[i].length)
+ continue;
+ fraction = (distance - model->spacers[i].length) / distance / 2;
+ model->spacers[i].a->position.x = x + dx * fraction;
+ model->spacers[i].a->position.y = y + dy * fraction;
+ model->spacers[i].b->position.x = x + dx * (1 - fraction);
+ model->spacers[i].b->position.y = y + dy * (1 - fraction);
+ }
+
+ /* Stick constraints. */
+ for (i = 0; i < model->num_sticks; i++) {
+ x = model->sticks[i].a->position.x;
+ y = model->sticks[i].a->position.y;
+ dx = model->sticks[i].b->position.x - x;
+ dy = model->sticks[i].b->position.y - y;
+ distance = estimate_distance (dx, dy, model->sticks[i].length);
+ fraction = (distance - model->sticks[i].length) / distance / 2;
+ model->sticks[i].a->position.x = x + dx * fraction;
+ model->sticks[i].a->position.y = y + dy * fraction;
+ model->sticks[i].b->position.x = x + dx * (1 - fraction);
+ model->sticks[i].b->position.y = y + dy * (1 - fraction);
+ }
+
+ /* Offset constraints. */
+ for (i = 0; i < model->num_offsets; i++)
+ model_constrain_offset (model, &model->offsets[i]);
+
+ /* Polygon constraints. */
+ for (i = 0; i < model->num_polygons; i++)
+ model_constrain_polygon (model, &model->polygons[i]);
}
void
model_step (Model *model, double delta_t)
{
- int i;
+ int i;
- model_accumulate_forces (model);
- model_integrate (model, delta_t);
- for (i = 0; i < 20; i++)
- model_constrain (model);
+ model_accumulate_forces (model);
+ model_integrate (model, delta_t);
+ for (i = 0; i < 20; i++)
+ model_constrain (model);
- model->theta += delta_t;
+ model->theta += delta_t;
}
static double
object_distance (Object *object, double x, double y)
{
- double dx, dy;
+ double dx, dy;
- dx = object->position.x - x;
- dy = object->position.y - y;
+ dx = object->position.x - x;
+ dy = object->position.y - y;
- return sqrt (dx*dx + dy*dy);
+ return sqrt (dx*dx + dy*dy);
}
Object *
model_find_nearest (Model *model, double x, double y)
{
- Object *object;
- double distance, min_distance;
- int i;
-
- for (i = 0; i < model->num_objects; i++) {
- distance = object_distance (&model->objects[i], x, y);
- if (i == 0 || distance < min_distance) {
- min_distance = distance;
- object = &model->objects[i];
- }
- }
-
- return object;
+ Object *object;
+ double distance, min_distance;
+ int i;
+
+ for (i = 0; i < model->num_objects; i++) {
+ distance = object_distance (&model->objects[i], x, y);
+ if (i == 0 || distance < min_distance) {
+ min_distance = distance;
+ object = &model->objects[i];
+ }
+ }
+
+ return object;
}
projects / akamaru / blobdiff