X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=akamaru.c;h=2ee99ad17fe0b4f4e5da6061b10605a6b5cb239a;hb=e1406efa6e1f29a8a72ddaa2db18f250fdf2ec42;hp=f6375e8438666566e0e0b0c1a3d9443c0ff4c4d5;hpb=3f5cdf3d255b9c1a5d96bb93b5e481787efe5547;p=akamaru diff --git a/akamaru.c b/akamaru.c index f6375e8..2ee99ad 100644 --- a/akamaru.c +++ b/akamaru.c @@ -11,23 +11,23 @@ * * TODO: * - * - Fix box collision test - * - Add stick objects instead of hardcoding sticks - * - Add code to add boxes - * - Add circle object + * - Add code to add boxes + * - Add circle object + * - Try out this idea: make constraint solver take mean of all + * corrections at the end instead of meaning as it goes. */ #include #include #include #include +#include +#include +#include #include -const double stick_length = 30; -const double ground_friction = 0.1, ground_level = 400; -const double box_left = 200, box_top = 200, box_bottom = 210; -const double elasticity = 0.7; -const double edge_fuzz = 1; +const double ground_level = 500; +const double elasticity = 0.8; typedef struct _xy_pair Point; typedef struct _xy_pair Vector; @@ -37,6 +37,11 @@ struct _xy_pair { typedef struct _Object Object; typedef struct _Stick Stick; +typedef struct _String String; +typedef struct _Spring Spring; +typedef struct _OffsetSpring OffsetSpring; +typedef struct _Polygon Polygon; +typedef struct _Offset Offset; typedef struct _Model Model; struct _Object { @@ -52,6 +57,35 @@ struct _Object { struct _Stick { Object *a, *b; + int length; +}; + +struct _String { + Object *a, *b; + int length; +}; + +struct _Offset { + int num_objects; + Object **objects; + int dx, dy; +}; + +struct _Spring { + Object *a, *b; + int length; +}; + +struct _OffsetSpring { + Object *a, *b; + int dx, dy; +}; + +struct _Polygon { + int num_points; + Point *points; + Vector *normals; + int edge; }; struct _Model { @@ -59,6 +93,16 @@ struct _Model { Object *objects; int num_sticks; Stick *sticks; + int num_strings; + String *strings; + int num_offsets; + Offset *offsets; + int num_springs; + Spring *springs; + int num_offset_springs; + OffsetSpring *offset_springs; + int num_polygons; + Polygon *polygons; double k; double friction; @@ -69,44 +113,395 @@ struct _Model { }; static void -model_init (Model *model) +polygon_init (Polygon *p, 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); + + 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; + } +} + +static void +polygon_init_diamond (Polygon *polygon, double x, double y) +{ + return polygon_init (polygon, 5, + x, y, + x + 10, y + 40, + x + 90, y + 40, + x + 100, y, + x + 50, y - 20); +} + +static void +polygon_init_rectangle (Polygon *polygon, double x0, double y0, + double x1, double y1) +{ + return polygon_init (polygon, 4, x0, y0, x0, y1, x1, y1, x1, y0); +} + +static void +model_init_polygons (Model *model) +{ + const int num_polygons = 5; + + model->polygons = g_new (Polygon, num_polygons); + polygon_init_diamond (&model->polygons[0], 250, 300); + polygon_init_diamond (&model->polygons[1], 400, 150); + polygon_init_rectangle (&model->polygons[2], -100, 200, 200, 250); + polygon_init_rectangle (&model->polygons[3], -200, ground_level, + 1200, ground_level + 400); + + polygon_init_rectangle (&model->polygons[4], 300, 320, 400, 350); + + model->num_polygons = num_polygons; +} + +static void +model_init_snake (Model *model) { const int num_objects = 20; - const int num_sticks = 40 - 3; + const int num_sticks = num_objects * 2 - 3; int i; + memset (model, 0, sizeof *model); model->objects = g_new (Object, num_objects); model->num_objects = num_objects; model->sticks = g_new (Stick, num_sticks); model->num_sticks = num_sticks; + model_init_polygons (model); for (i = 0; i < num_objects; i++) { - model->objects[i].position.x = 200; - model->objects[i].position.y = i * stick_length + 40; - model->objects[i].previous_position.x = 200; - model->objects[i].previous_position.y = i * stick_length + 40; + model->objects[i].position.x = random() % 200 + 20; + model->objects[i].position.y = random() % 200 + 20; + model->objects[i].previous_position.x = random() % 200 + 20; + model->objects[i].previous_position.y = random() % 200 + 20; + model->objects[i].mass = 1; if (i + 1 < num_objects) { model->sticks[i * 2].a = &model->objects[i]; model->sticks[i * 2].b = &model->objects[i + 1]; + model->sticks[i * 2].length = random() % 20 + 20; } if (i + 2 < num_objects) { model->sticks[i * 2 + 1].a = &model->objects[i]; model->sticks[i * 2 + 1].b = &model->objects[i + 2]; + model->sticks[i * 2 + 1].length = random() % 20 + 20; + } + } + + model->anchor_object = NULL; +} + +static void +model_init_rope (Model *model) +{ + const int num_objects = 20; + const int num_sticks = num_objects - 1; + const int stick_length = 10; + int i; + + memset (model, 0, sizeof *model); + model->objects = g_new (Object, num_objects); + model->num_objects = num_objects; + model->sticks = g_new (Stick, num_sticks); + model->num_sticks = num_sticks; + model_init_polygons (model); + + for (i = 0; i < num_objects; i++) { + model->objects[i].position.x = 200; + model->objects[i].position.y = 40 + i * stick_length; + model->objects[i].previous_position.x = 200; + model->objects[i].previous_position.y = 40 + i * stick_length; + model->objects[i].mass = 1; + + if (i + 1 < num_objects) { + model->sticks[i].a = &model->objects[i]; + model->sticks[i].b = &model->objects[i + 1]; + model->sticks[i].length = stick_length; } } model->anchor_object = NULL; } +static void +model_init_curtain (Model *model) +{ + const int num_ropes = 5; + const int num_rope_objects = 15; + const int num_objects = num_ropes * num_rope_objects; + const int num_sticks = num_ropes * (num_rope_objects - 1); + const int stick_length = 10; + const int rope_offset = 30; + double x, y; + int i, j, index, stick_index; + + memset (model, 0, sizeof *model); + model->objects = g_new (Object, num_objects); + model->num_objects = num_objects; + model->sticks = g_new (Stick, num_sticks); + model->num_sticks = num_sticks; + model->offsets = g_new (Offset, 1); + model->num_offsets = 1; + model_init_polygons (model); + + model->offsets[0].num_objects = num_ropes; + model->offsets[0].objects = g_new (Object *, num_ropes); + model->offsets[0].dx = rope_offset; + model->offsets[0].dy = 0; + + for (i = 0; i < num_ropes; i++) { + for (j = 0; j < num_rope_objects; j++) { + x = 200 + i * rope_offset; + y = 40 + j * stick_length; + index = i * num_rope_objects + j; + model->objects[index].position.x = x; + model->objects[index].position.y = y; + model->objects[index].previous_position.x = x; + model->objects[index].previous_position.y = y; + model->objects[i].mass = 1; + + if (j + 1 < num_rope_objects) { + stick_index = i * (num_rope_objects - 1) + j; + model->sticks[stick_index].a = &model->objects[index]; + model->sticks[stick_index].b = &model->objects[index + 1]; + model->sticks[stick_index].length = stick_length; + } + } + + model->offsets[0].objects[i] = &model->objects[i * num_rope_objects]; + } + + model->anchor_object = NULL; +} + +static void +model_init_grid (Model *model) +{ + const int num_ropes = 4; + const int num_rope_objects = 4; + const int num_objects = num_ropes * num_rope_objects; + const int num_strings = num_ropes * (num_rope_objects - 1) + + (num_ropes - 1) * num_rope_objects; + const int string_length = 20; + const int rope_offset = 20; + double x, y; + int i, j, index, string_index; + + memset (model, 0, sizeof *model); + model->objects = g_new (Object, num_objects); + model->num_objects = num_objects; + model->strings = g_new (String, num_strings); + model->num_strings = num_strings; + model->offsets = g_new (Offset, 1); + model->num_offsets = 1; + model_init_polygons (model); + + model->offsets[0].num_objects = num_ropes; + model->offsets[0].objects = g_new (Object *, num_ropes); + model->offsets[0].dx = rope_offset; + model->offsets[0].dy = 0; + + for (i = 0; i < num_ropes; i++) { + for (j = 0; j < num_rope_objects; j++) { + x = 200 + i * rope_offset; + y = 40 + j * string_length; + index = i * num_rope_objects + j; + model->objects[index].position.x = x; + model->objects[index].position.y = y; + model->objects[index].previous_position.x = x; + model->objects[index].previous_position.y = y; + model->objects[index].mass = 1; + + if (i + 1 < num_ropes) { + string_index = i * num_rope_objects + j; + model->strings[string_index].a = &model->objects[index]; + model->strings[string_index].b = &model->objects[index + num_rope_objects]; + model->strings[string_index].length = string_length; + } + + if (j + 1 < num_rope_objects) { + string_index = + (num_ropes - 1) * num_rope_objects + i * (num_rope_objects - 1) + j; + model->strings[string_index].a = &model->objects[index]; + model->strings[string_index].b = &model->objects[index + 1]; + model->strings[string_index].length = string_length; + } + } + + model->offsets[0].objects[i] = &model->objects[i * num_rope_objects]; + } + + model->anchor_object = NULL; +} + +static void +model_init_molecule (Model *model) +{ + const int num_objects = 8; + const int num_springs = num_objects * 2; + const int spring_length = 50; + int i; + + memset (model, 0, sizeof *model); + model->objects = g_new (Object, num_objects); + model->num_objects = num_objects; + model->springs = g_new (Spring, num_springs); + model->num_springs = num_springs; + model->k = 0.2; + + for (i = 0; i < num_objects; i++) { + model->objects[i].position.x = 200 + i * 20; + model->objects[i].position.y = 200; + model->objects[i].previous_position.x = 200 + i * 20; + model->objects[i].previous_position.y = 200; + model->objects[i].mass = 0; + } + + for (i = 0; i < num_objects; i++) { + model->springs[i * 2].a = &model->objects[i]; + model->springs[i * 2].b = &model->objects[(i + 1) % num_objects]; + model->springs[i * 2].length = spring_length; + model->springs[i * 2 + 1].a = &model->objects[i]; + model->springs[i * 2 + 1].b = &model->objects[(i + 2) % num_objects]; + model->springs[i * 2 + 1].length = spring_length; + } +} + + +static void +model_init_wobbly (Model *model) +{ + const int width = 6, height = 6; + const int num_objects = width * height; + const int num_offset_springs = (width - 1) * height + width * (height - 1); + const int distance = 30; + double x, y; + int i, j, object_index, spring_index; + + memset (model, 0, sizeof *model); + model->objects = g_new (Object, num_objects); + model->num_objects = num_objects; + model->offset_springs = g_new (OffsetSpring, num_offset_springs); + model->num_offset_springs = num_offset_springs; + model->k = 0.6; + + model_init_polygons (model); + + object_index = 0; + spring_index = 0; + for (i = 0; i < width; i++) { + for (j = 0; j < height; j++) { + x = 200 + i * distance; + y = 40 + j * distance; + model->objects[object_index].position.x = x; + model->objects[object_index].position.y = y; + model->objects[object_index].previous_position.x = x; + model->objects[object_index].previous_position.y = y; + model->objects[object_index].mass = 0.3; + + if (i + 1 < width) { + model->offset_springs[spring_index].a = &model->objects[object_index]; + model->offset_springs[spring_index].b = &model->objects[object_index + height]; + model->offset_springs[spring_index].dx = distance; + model->offset_springs[spring_index].dy = 0; + spring_index++; + } + + if (j + 1 < height) { + model->offset_springs[spring_index].a = &model->objects[object_index]; + model->offset_springs[spring_index].b = &model->objects[object_index + 1]; + model->offset_springs[spring_index].dx = 0; + model->offset_springs[spring_index].dy = distance; + spring_index++; + } + + object_index++; + } + } +} + + +static void +model_fini (Model *model) +{ + g_free (model->objects); + g_free (model->sticks); + g_free (model->strings); + g_free (model->offsets); + 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; for (i = 0; i < model->num_objects; i++) { model->objects[i].force.x = 0; - model->objects[i].force.y = 3; + model->objects[i].force.y = 3 * model->objects[i].mass; + } + + 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; } } @@ -123,19 +518,123 @@ model_integrate (Model *model, double step) y = o->position.y; o->position.x = - x + (x - o->previous_position.x) + o->force.x * step * step; + x + 0.9 * (x - o->previous_position.x) + o->force.x * step * step; o->position.y = - y + (y - o->previous_position.y) + o->force.y * step * step; + y + 0.9 * (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 + * stick constraints can be aproximated using Newton: + * + * distance = + * (model->sticks[i].length + + * (dx * dx + dy * dy) / model->sticks[i].length) / 2; + * + * This works really well, since the constraints aren't typically + * violated much. Thus, the distance is really close to the stick + * length, which then makes a good initial guess. However, the + * approximation seems to be slower that just calling sqrt()... + */ + +static inline double +estimate_distance (double dx, double dy, double r) +{ +#ifdef APPROXIMATE_SQUARE_ROOTS + return (r + (dx * dx + dy * dy) / r) / 2; +#else + return sqrt (dx * dx + dy * dy); +#endif +} + +static int +polygon_contains_point (Polygon *polygon, Point *point) +{ + 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; + + if (polygon->normals[i].x * dx + polygon->normals[i].y * dy >= 0) + return FALSE; + } + + return TRUE; +} + +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; + polygon->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; + + 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_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; + + 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 step) +model_constrain (Model *model) { - double dx, dy, x, y, distance, fraction, squared; + double dx, dy, x, y, distance, fraction; int i; /* Anchor object constraint. */ @@ -146,70 +645,43 @@ model_constrain (Model *model, double step) model->anchor_object->previous_position.y = model->anchor_position.y; } - /* FIXME: this should be "is point inside box" test instead. Figure - * out from previous_position which edge the point has passed - * through and reflect in that. */ - for (i = 0; i < model->num_objects; i++) { - x = model->objects[i].position.x; - y = model->objects[i].position.y; - if (box_top - edge_fuzz <= y && - model->objects[i].previous_position.y <= box_top + edge_fuzz && - x < box_left) { - model->objects[i].position.y = box_top - (y - box_top) * elasticity; - model->objects[i].previous_position.y = - box_top - (model->objects[i].previous_position.y - box_top) * elasticity; - } + /* 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); } - /* Ground collision detection constraints. This puts a ground level - * in to make sure the points don't fall off the screen. */ - for (i = 0; i < model->num_objects; i++) { - x = model->objects[i].position.x; - y = model->objects[i].position.y; - - if (model->objects[i].position.y > ground_level) { - model->objects[i].position.y = - ground_level - (model->objects[i].position.y - ground_level) * elasticity; - model->objects[i].previous_position.y = - ground_level - (model->objects[i].previous_position.y - ground_level) * elasticity; - - /* Friction on impact */ - model->objects[i].position.x = - model->objects[i].position.x * (1 - ground_friction) + - model->objects[i].previous_position.x * ground_friction; - } - } - -#if 1 /* 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 = sqrt (dx * dx + dy * dy); - fraction = (distance - stick_length) / distance / 2; + 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); } -#else - /* Stick constraints, without square roots. */ - squared = stick_length * stick_length; - for (i = 0; i < model->num_objects - 1; i++) { - j = i + 1; - x = model->objects[i].position.x; - y = model->objects[i].position.y; - dx = model->objects[j].position.x - x; - dy = model->objects[j].position.y - y; - fraction = squared / (dx * dx + dy * dy + squared) - 0.5; - model->objects[i].position.x = x + dx * fraction; - model->objects[i].position.y = y + dy * fraction; - model->objects[j].position.x = x + dx * (1 - fraction); - model->objects[j].position.y = y + dy * (1 - fraction); - } -#endif + + /* 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]); } static void @@ -221,7 +693,7 @@ model_step (Model *model, double delta_t) model_integrate (model, delta_t); for (i = 0; i < 50; i++) - model_constrain (model, delta_t); + model_constrain (model); model->theta += delta_t; } @@ -261,90 +733,180 @@ struct _Color { }; static void -draw_star (cairo_t *cr, - gdouble cx, - gdouble cy, - double theta, - Color *color) -{ - const int spike_count = 5; - const int inner_radius = 2; - const int outer_radius = 4; - double x, y; +draw_sticks (cairo_t *cr, + Model *model, + Color *color) +{ int i; - cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.5); + cairo_set_source_rgba (cr, color->red, color->green, color->blue, 1); cairo_new_path (cr); - for (i = 0; i < spike_count; i++) { - x = cx + cos ((i * 2) * M_PI / spike_count + theta) * inner_radius; - y = cy + sin ((i * 2) * M_PI / spike_count + theta) * inner_radius; - - if (i == 0) - cairo_move_to (cr, x, y); - else - cairo_line_to (cr, x, y); - - x = cx + cos ((i * 2 + 1) * M_PI / spike_count + theta) * outer_radius; - y = cy + sin ((i * 2 + 1) * M_PI / spike_count + theta) * outer_radius; - - cairo_line_to (cr, x, y); + cairo_set_line_width (cr, 2); + cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + + for (i = 0; i < model->num_sticks; i++) { + cairo_move_to (cr, + model->sticks[i].a->position.x, + model->sticks[i].a->position.y); + cairo_line_to (cr, + model->sticks[i].b->position.x, + model->sticks[i].b->position.y); } - cairo_fill (cr); + + cairo_stroke (cr); } static void -draw_lines (cairo_t *cr, - Model *model, - Color *color) +draw_strings (cairo_t *cr, + Model *model, + Color *color) { int i; + cairo_set_source_rgba (cr, color->red, color->green, color->blue, 1); + cairo_new_path (cr); + cairo_set_line_width (cr, 1); + cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + + for (i = 0; i < model->num_strings; i++) { + cairo_move_to (cr, + model->strings[i].a->position.x, + model->strings[i].a->position.y); + cairo_line_to (cr, + model->strings[i].b->position.x, + model->strings[i].b->position.y); + } + + cairo_stroke (cr); +} + +static void +draw_offsets (cairo_t *cr, + Model *model, + Color *color) +{ + int i, j; + cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.5); cairo_new_path (cr); cairo_set_line_width (cr, 4); cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); - for (i = 0; i < model->num_objects; i++) { + for (i = 0; i < model->num_offsets; i++) { + for (j = 0; j < model->offsets[i].num_objects; j++) { + cairo_line_to (cr, + model->offsets[i].objects[j]->position.x, + model->offsets[i].objects[j]->position.y); + } + cairo_stroke (cr); + } + +} + +static void +draw_springs (cairo_t *cr, + Model *model, + Color *color) +{ + int i; + + cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4); + cairo_new_path (cr); + cairo_set_line_width (cr, 2); + cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + + for (i = 0; i < model->num_springs; i++) { + cairo_move_to (cr, + model->springs[i].a->position.x, + model->springs[i].a->position.y); cairo_line_to (cr, - model->objects[i].position.x, - model->objects[i].position.y); + model->springs[i].b->position.x, + model->springs[i].b->position.y); } cairo_stroke (cr); } static void -draw_constraints (cairo_t *cr, - Model *model, - Color *color) +draw_offset_springs (cairo_t *cr, + Model *model, + Color *color) { - cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.5); + int i; - cairo_move_to (cr, 0, ground_level); - cairo_line_to (cr, 1500, ground_level); - cairo_line_to (cr, 1500, ground_level + 10); - cairo_line_to (cr, 0, ground_level + 10); - cairo_close_path (cr); + cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4); + cairo_new_path (cr); + cairo_set_line_width (cr, 2); + cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND); + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + + for (i = 0; i < model->num_offset_springs; i++) { + cairo_move_to (cr, + model->offset_springs[i].a->position.x, + model->offset_springs[i].a->position.y); + cairo_line_to (cr, + model->offset_springs[i].b->position.x, + model->offset_springs[i].b->position.y); + } - cairo_move_to (cr, 0, box_top); - cairo_line_to (cr, box_left, box_top); - cairo_line_to (cr, box_left, box_bottom); - cairo_line_to (cr, 0, box_bottom); - cairo_close_path (cr); + cairo_stroke (cr); +} +static void +draw_polygons (cairo_t *cr, Model *model, Color *color) +{ + Polygon *p; + int i, j; + + for (i = 0; i < model->num_polygons; i++) { + p = &model->polygons[i]; + cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4); + + + for (j = 0; j < p->num_points; j++) + cairo_line_to (cr, p->points[j].x, p->points[j].y); + cairo_close_path (cr); + } cairo_fill (cr); + +} + +static void +draw_objects (cairo_t *cr, Model *model, Color *color) +{ + int i; + + cairo_set_source_rgba (cr, color->red, color->green, color->blue, 0.4); + for (i = 0; i < model->num_objects; i++) { + cairo_arc (cr, model->objects[i].position.x, + model->objects[i].position.y, + 3, 0, 2*M_PI); + cairo_fill (cr); + } } static Color blue = { 0, 0, 1 }; +static Color green = { 0, 1, 0 }; static Color red = { 1, 0, 0 }; +static Color black = { 0, 0, 0 }; -static gboolean -sproing_expose_event (GtkWidget *widget, - GdkEventExpose *event, - gpointer data) +typedef struct _Closure Closure; +struct _Closure { + GtkWidget *drawing_area; + GtkWidget *fps_label; + Model *model; + int frame_count; + int i; + struct timeval start; +}; + +static void +draw_model (GtkWidget *widget, Model *model) { - Model *model = data; cairo_t *cr; cr = gdk_cairo_create (widget->window); @@ -352,126 +914,179 @@ sproing_expose_event (GtkWidget *widget, cairo_set_source_rgb (cr, 1, 1, 1); cairo_paint (cr); - draw_constraints (cr, model, &red); - draw_lines (cr, model, &blue); - -#if 0 - for (i = 0; i < model->num_objects; i++) { - draw_star (widget, model->objects[i].position.x, - model->objects[i].position.y, model->objects[i].theta, &blue); - } -#endif + draw_polygons (cr, model, &blue); + draw_sticks (cr, model, &black); + draw_strings (cr, model, &green); + draw_springs (cr, model, &black); + draw_offsets (cr, model, &blue); + draw_offset_springs (cr, model, &blue); + draw_objects (cr, model, &red); cairo_destroy (cr); +} + +static gboolean +expose_event (GtkWidget *widget, + GdkEventExpose *event, + gpointer data) +{ + Closure *closure = data; + + draw_model (widget, closure->model); return TRUE; } static gboolean -sproing_button_press_event (GtkWidget *widget, - GdkEventButton *event, - gpointer data) +button_press_event (GtkWidget *widget, + GdkEventButton *event, + gpointer data) { - Model *model = data; + Closure *closure = data; if (event->button != 1) return TRUE; - model->anchor_position.x = event->x; - model->anchor_position.y = event->y; - model->anchor_object = model_find_nearest (model, event->x, event->y); + closure->model->anchor_position.x = event->x; + closure->model->anchor_position.y = event->y; + closure->model->anchor_object = model_find_nearest (closure->model, + event->x, event->y); return TRUE; } static gboolean -sproing_button_release_event (GtkWidget *widget, - GdkEventButton *event, - gpointer data) +button_release_event (GtkWidget *widget, + GdkEventButton *event, + gpointer data) { - Model *model = data; + Closure *closure = data; if ((event->state & GDK_BUTTON1_MASK) == 0) return TRUE; - model->anchor_object = NULL; + closure->model->anchor_object = NULL; return TRUE; } static gboolean -sproing_motion_notify_event (GtkWidget *widget, - GdkEventMotion *event, - gpointer data) +motion_notify_event (GtkWidget *widget, + GdkEventMotion *event, + gpointer data) { - Model *model = data; + Closure *closure = data; int x, y; GdkModifierType state; gdk_window_get_pointer (event->window, &x, &y, &state); - - model->anchor_position.x = x + 0.5; - model->anchor_position.y = y + 0.5; + + closure->model->anchor_position.x = x + 0.5; + closure->model->anchor_position.y = y + 0.5; return TRUE; } +typedef void (*ModelInitFunc) (Model *model); + static void -spring_constant_changed (GtkSpinButton *spinbutton, gpointer user_data) +model_changed (GtkComboBox *combo, gpointer user_data) { - Model *model = user_data; + Closure *closure = user_data; + GtkTreeIter iter; + GtkTreeModel *tree_model; + ModelInitFunc init; + char *name; + + tree_model = gtk_combo_box_get_model (combo); + if (!gtk_combo_box_get_active_iter (combo, &iter)) + return; - model->k = gtk_spin_button_get_value (spinbutton); + gtk_tree_model_get (tree_model, &iter, 0, &name, 1, &init, -1); + + model_fini (closure->model); + (*init) (closure->model); } -static void -friction_changed (GtkSpinButton *spinbutton, gpointer user_data) +static GtkTreeModel * +create_model_store (void) { - Model *model = user_data; + static struct { + const char *name; + ModelInitFunc init; + } models[] = { + { "Rope", model_init_rope }, + { "Snake", model_init_snake }, + { "Curtain", model_init_curtain }, + { "Grid", model_init_grid }, + { "Molecule", model_init_molecule }, + { "Wobbly", model_init_wobbly } + }; + + GtkTreeIter iter; + GtkTreeStore *store; + gint i; + + store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); + + for (i = 0; i < G_N_ELEMENTS(models); i++) { + gtk_tree_store_append (store, &iter, NULL); + gtk_tree_store_set (store, &iter, + 0, models[i].name, 1, models[i].init, -1); + } + + return GTK_TREE_MODEL (store); - model->friction = gtk_spin_button_get_value (spinbutton); } static GtkWidget * -create_spinners (Model *model) +create_model_combo (Closure *closure) { GtkWidget *hbox; - GtkWidget *spinner, *label; + GtkWidget *combo, *label; + GtkTreeModel *store; + GtkCellRenderer *renderer; hbox = gtk_hbox_new (FALSE, 8); - label = gtk_label_new_with_mnemonic ("_Spring constant:"); + label = gtk_label_new_with_mnemonic ("_Model:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); - spinner = gtk_spin_button_new_with_range (0.05, 30.00, 0.05); - gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinner); - gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0); - gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), model->k); - g_signal_connect (spinner, "value-changed", - G_CALLBACK (spring_constant_changed), model); - - label = gtk_label_new_with_mnemonic ("_Friction:"); + + store = create_model_store (); + combo = gtk_combo_box_new_with_model (store); + gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0); + g_object_unref (store); + + renderer = gtk_cell_renderer_text_new (); + gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE); + gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, + "text", 0, + NULL); + + gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); + gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0); + g_signal_connect (combo, "changed", + G_CALLBACK (model_changed), closure); + + label = gtk_label_new ("Frames per second: 0"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); - spinner = gtk_spin_button_new_with_range (0.05, 15.00, 0.05); - gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinner); - gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0); - gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinner), model->friction); - g_signal_connect (spinner, "value-changed", - G_CALLBACK (friction_changed), model); + + closure->fps_label = label; return hbox; } -static GtkWidget * -create_window (Model *model) +static void +create_window (Closure *closure) { GtkWidget *window; GtkWidget *frame; GtkWidget *vbox; GtkWidget *da; - GtkWidget *spinners; + GtkWidget *model_combo; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); - gtk_window_set_title (GTK_WINDOW (window), "Drawing Area"); + gtk_window_set_title (GTK_WINDOW (window), "Akamaru"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), &window); @@ -492,23 +1107,23 @@ create_window (Model *model) da = gtk_drawing_area_new (); /* set a minimum size */ - gtk_widget_set_size_request (da, 600, 500); + gtk_widget_set_size_request (da, 200, 200); gtk_container_add (GTK_CONTAINER (frame), da); /* Signals used to handle backing pixmap */ g_signal_connect (da, "expose_event", - G_CALLBACK (sproing_expose_event), model); + G_CALLBACK (expose_event), closure); /* Event signals */ g_signal_connect (da, "motion_notify_event", - G_CALLBACK (sproing_motion_notify_event), model); + G_CALLBACK (motion_notify_event), closure); g_signal_connect (da, "button_press_event", - G_CALLBACK (sproing_button_press_event), model); + G_CALLBACK (button_press_event), closure); g_signal_connect (da, "button_release_event", - G_CALLBACK (sproing_button_release_event), model); + G_CALLBACK (button_release_event), closure); /* Ask to receive events the drawing area doesn't normally * subscribe to @@ -520,32 +1135,48 @@ create_window (Model *model) | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); - spinners = create_spinners (model); - gtk_box_pack_start (GTK_BOX (vbox), spinners, FALSE, FALSE, 0); + model_combo = create_model_combo (closure); + gtk_box_pack_start (GTK_BOX (vbox), model_combo, FALSE, FALSE, 0); - return da; + closure->drawing_area = da; } -typedef struct _Closure Closure; -struct _Closure { - GtkWidget *drawing_area; - Model *model; - int i; -}; - static gint timeout_callback (gpointer data) { Closure *closure = data; - int i; - for (i = 0; i < 3; i++) - model_step (closure->model, 0.5); + model_step (closure->model, 1); closure->i++; if (closure->i == 1) { gtk_widget_queue_draw (closure->drawing_area); closure->i = 0; + closure->frame_count++; + } + + if (closure->frame_count == 200) { + struct timeval end, elapsed; + double total; + char text[50]; + + closure->frame_count = 0; + gettimeofday (&end, NULL); + if (closure->start.tv_usec > end.tv_usec) { + end.tv_usec += 1000000; + end.tv_sec--; + } + + elapsed.tv_usec = end.tv_usec - closure->start.tv_usec; + elapsed.tv_sec = end.tv_sec - closure->start.tv_sec; + + total = elapsed.tv_sec + ((double) elapsed.tv_usec / 1e6); + if (total < 0) { + total = 0; + } + closure->start = end; + snprintf (text, sizeof text, "Frames per second: %.2f", 200 / total); + gtk_label_set_text (GTK_LABEL (closure->fps_label), text); } return TRUE; @@ -558,12 +1189,14 @@ main (int argc, char *argv[]) Model model; gtk_init (&argc, &argv); - model_init (&model); - closure.drawing_area = create_window (&model); + model_init_rope (&model); + create_window (&closure); closure.i = 0; gtk_widget_show_all (gtk_widget_get_toplevel (closure.drawing_area)); closure.model = &model; - g_timeout_add (100, timeout_callback, &closure); + closure.frame_count = 0; + gettimeofday (&closure.start, NULL); + g_timeout_add (40, timeout_callback, &closure); gtk_main (); return 0;