X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;ds=sidebyside;f=main.c;fp=main.c;h=0aec615ad7650ac2c0019fd07cdf068495a33d3b;hb=9bdb07522bfbb2611a7e70f1204d96b98bc0e615;hp=0000000000000000000000000000000000000000;hpb=e1406efa6e1f29a8a72ddaa2db18f250fdf2ec42;p=akamaru diff --git a/main.c b/main.c new file mode 100644 index 0000000..0aec615 --- /dev/null +++ b/main.c @@ -0,0 +1,775 @@ +/* -*- mode: c; c-basic-offset: 2 -*- + * To compile: + * + * gcc -Wall -g $(pkg-config --cflags --libs gtk+-2.0 cairo) \ + * akamaru.c main.c -o akamaru + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "akamaru.h" + +static void +model_init_polygons (Model *model) +{ + const int num_polygons = 5; + const double ground_level = 500; + + 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 = 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 = 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 = 10; + 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 = 1; + + 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++; + } + } +} + +typedef struct _Color Color; +struct _Color { + double red, green, blue; +}; + +static void +draw_sticks (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, 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_stroke (cr); +} + +static void +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_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->springs[i].b->position.x, + model->springs[i].b->position.y); + } + + cairo_stroke (cr); +} + +static void +draw_offset_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_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_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 }; + +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) +{ + cairo_t *cr; + + cr = gdk_cairo_create (widget->window); + + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + + 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 +button_press_event (GtkWidget *widget, + GdkEventButton *event, + gpointer data) +{ + Closure *closure = data; + + if (event->button != 1) + return TRUE; + + 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 +button_release_event (GtkWidget *widget, + GdkEventButton *event, + gpointer data) +{ + Closure *closure = data; + + if ((event->state & GDK_BUTTON1_MASK) == 0) + return TRUE; + + closure->model->anchor_object = NULL; + + return TRUE; +} + +static gboolean +motion_notify_event (GtkWidget *widget, + GdkEventMotion *event, + gpointer data) +{ + Closure *closure = data; + int x, y; + GdkModifierType state; + + gdk_window_get_pointer (event->window, &x, &y, &state); + + 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 +model_changed (GtkComboBox *combo, gpointer 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; + + gtk_tree_model_get (tree_model, &iter, 0, &name, 1, &init, -1); + + model_fini (closure->model); + (*init) (closure->model); +} + +static GtkTreeModel * +create_model_store (void) +{ + 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); + +} + +static GtkWidget * +create_model_combo (Closure *closure) +{ + GtkWidget *hbox; + GtkWidget *combo, *label; + GtkTreeModel *store; + GtkCellRenderer *renderer; + + hbox = gtk_hbox_new (FALSE, 8); + + label = gtk_label_new_with_mnemonic ("_Model:"); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + + 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); + + closure->fps_label = label; + + return hbox; +} + +static void +create_window (Closure *closure) +{ + GtkWidget *window; + GtkWidget *frame; + GtkWidget *vbox; + GtkWidget *da; + GtkWidget *model_combo; + + window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Akamaru"); + + g_signal_connect (window, "destroy", + G_CALLBACK (gtk_main_quit), &window); + + gtk_container_set_border_width (GTK_CONTAINER (window), 8); + + vbox = gtk_vbox_new (FALSE, 8); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); + gtk_container_add (GTK_CONTAINER (window), vbox); + + /* + * Create the drawing area + */ + + frame = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); + gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); + + da = gtk_drawing_area_new (); + /* set a minimum size */ + 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 (expose_event), closure); + + /* Event signals */ + + g_signal_connect (da, "motion_notify_event", + G_CALLBACK (motion_notify_event), closure); + g_signal_connect (da, "button_press_event", + G_CALLBACK (button_press_event), closure); + g_signal_connect (da, "button_release_event", + G_CALLBACK (button_release_event), closure); + + /* Ask to receive events the drawing area doesn't normally + * subscribe to + */ + gtk_widget_set_events (da, gtk_widget_get_events (da) + | GDK_LEAVE_NOTIFY_MASK + | GDK_BUTTON_PRESS_MASK + | GDK_BUTTON_RELEASE_MASK + | GDK_POINTER_MOTION_MASK + | GDK_POINTER_MOTION_HINT_MASK); + + model_combo = create_model_combo (closure); + gtk_box_pack_start (GTK_BOX (vbox), model_combo, FALSE, FALSE, 0); + + closure->drawing_area = da; +} + +static gint +timeout_callback (gpointer data) +{ + Closure *closure = data; + + 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; +} + +int +main (int argc, char *argv[]) +{ + Closure closure; + Model model; + + gtk_init (&argc, &argv); + model_init_rope (&model); + create_window (&closure); + closure.i = 0; + gtk_widget_show_all (gtk_widget_get_toplevel (closure.drawing_area)); + closure.model = &model; + closure.frame_count = 0; + gettimeofday (&closure.start, NULL); + g_timeout_add (40, timeout_callback, &closure); + gtk_main (); + + return 0; +}