efl: merge ephysics

changes:
 * __UNUSED__ -> EINA_UNUSED
 * Fixed doc hierarchy



SVN revision: 82126

35 files changed, 16885 insertions, 1 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 3d4b5afd88..e409af2ce4 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -64,6 +64,9 @@ include Makefile_Efreet.am
 if HAVE_EEZE
 include Makefile_Eeze.am
 endif
+if HAVE_EPHYSICS
+include Makefile_EPhysics.am
+endif
 
 .PHONY: benchmark examples
 
@@ -99,6 +102,7 @@ clean-local:
         rm -rf lib/edbus/*.gcno
         rm -rf lib/efreet/*.gcno
         rm -rf lib/eeze/*.gcno
+        rm -rf lib/ephysics/*.gcno
         rm -rf modules/eina/mp/pass_through/*.gcno
         rm -rf modules/eina/mp/one_big/*.gcno
         rm -rf modules/eina/mp/chained_pool/*.gcno
diff --git a/src/Makefile_EPhysics.am b/src/Makefile_EPhysics.am
new file mode 100644
index 0000000000..d5704d8c8e
--- /dev/null
+++ b/src/Makefile_EPhysics.am
@@ -0,0 +1,47 @@
+
+### Library
+
+lib_LTLIBRARIES += \
+lib/ephysics/libephysics.la
+
+installed_ephysicsmainheadersdir = $(includedir)/ephysics-@VMAJ@
+dist_installed_ephysicsmainheaders_DATA = \
+lib/ephysics/EPhysics.h
+
+lib_ephysics_libephysics_la_SOURCES = \
+lib/ephysics/ephysics_private.h \
+lib/ephysics/ephysics_trimesh.h \
+lib/ephysics/ephysics_body_materials.h \
+lib/ephysics/ephysics_body.cpp \
+lib/ephysics/ephysics_camera.cpp \
+lib/ephysics/ephysics_constraints.cpp \
+lib/ephysics/ephysics_main.cpp \
+lib/ephysics/ephysics_quaternion.cpp \
+lib/ephysics/ephysics_shape.cpp \
+lib/ephysics/ephysics_world.cpp
+
+lib_ephysics_libephysics_la_CPPFLAGS = \
+-I$(top_srcdir)/src/lib/eina \
+-I$(top_builddir)/src/lib/eina \
+-I$(top_srcdir)/src/lib/eo \
+-I$(top_builddir)/src/lib/eo \
+-I$(top_srcdir)/src/lib/ecore \
+-I$(top_builddir)/src/lib/ecore \
+-I$(top_srcdir)/src/lib/evas \
+-I$(top_builddir)/src/lib/evas \
+-I$(top_srcdir)/src/lib/ephysics \
+-I$(top_builddir)/src/lib/ephysics \
+@EFL_COV_CFLAGS@ \
+@EPHYSICS_CFLAGS@ \
+-DEFL_EPHYSICS_BUILD
+
+lib_ephysics_libephysics_la_LIBADD = \
+lib/eina/libeina.la \
+lib/eo/libeo.la \
+lib/ecore/libecore.la \
+lib/evas/libevas.la \
+@EFL_COV_LIBS@ \
+@EPHYSICS_LIBS@
+
+lib_ephysics_libephysics_la_LDFLAGS = @EFL_LTLIBRARY_FLAGS@
+
diff --git a/src/examples/Makefile.am b/src/examples/Makefile.am
index 8d5c8aa05c..28e04223e8 100644
--- a/src/examples/Makefile.am
+++ b/src/examples/Makefile.am
@@ -1,6 +1,6 @@
 MAINTAINERCLEANFILES = Makefile.in
 
-SUBDIRS = eina eo eet evas ecore eio edbus
+SUBDIRS = eina eo eet evas ecore eio edbus ephysics
 
 examples:
         @$(MAKE) $(AM_MAKEFLAGS) -C eina examples
@@ -10,6 +10,7 @@ examples:
         @$(MAKE) $(AM_MAKEFLAGS) -C ecore examples
         @$(MAKE) $(AM_MAKEFLAGS) -C eio examples
         @$(MAKE) $(AM_MAKEFLAGS) -C edbus examples
+        @$(MAKE) $(AM_MAKEFLAGS) -C ephysics examples
 
 install-examples:
         @$(MAKE) $(AM_MAKEFLAGS) -C eina install-examples
@@ -19,3 +20,4 @@ install-examples:
         @$(MAKE) $(AM_MAKEFLAGS) -C ecore install-examples
         @$(MAKE) $(AM_MAKEFLAGS) -C eio install-examples
         @$(MAKE) $(AM_MAKEFLAGS) -C edbus install-examples
+        @$(MAKE) $(AM_MAKEFLAGS) -C ephysics install-examples
diff --git a/src/examples/ephysics/Makefile.am b/src/examples/ephysics/Makefile.am
new file mode 100644
index 0000000000..00f856003d
--- /dev/null
+++ b/src/examples/ephysics/Makefile.am
@@ -0,0 +1,87 @@
+MAINTAINERCLEANFILES = Makefile.in
+
+AM_CPPFLAGS = \
+-I. \
+-I$(top_srcdir)/src/lib/eina \
+-I$(top_builddir)/src/lib/eina \
+-I$(top_srcdir)/src/lib/eo \
+-I$(top_builddir)/src/lib/eo \
+-I$(top_srcdir)/src/lib/ecore \
+-I$(top_builddir)/src/lib/ecore \
+-I$(top_srcdir)/src/lib/evas \
+-I$(top_builddir)/src/lib/evas \
+-I$(top_srcdir)/src/lib/ecore_evas \
+-I$(top_builddir)/src/lib/ecore_evas \
+-I$(top_srcdir)/src/lib/ephysics \
+-I$(top_builddir)/src/lib/ephysics
+
+LDADD = \
+$(top_builddir)/src/lib/eina/libeina.la \
+$(top_builddir)/src/lib/eo/libeo.la \
+$(top_builddir)/src/lib/ecore/libecore.la \
+$(top_builddir)/src/lib/evas/libevas.la \
+$(top_builddir)/src/lib/ecore_evas/libecore_evas.la \
+$(top_builddir)/src/lib/ephysics/libephysics.la \
+@EPHYSICS_LDFLAGS@
+
+SRCS = \
+ephysics_logo.c \
+ephysics_test.h \
+test_bouncing_ball.c \
+test_bouncing_text.c \
+test.c \
+test_camera.c \
+test_camera_track.c \
+test_colliding_balls.c \
+test_collision_detection.c \
+test_collision_filter.c \
+test_constraint.c \
+test_delete.c \
+test_forces.c \
+test_growing_balls.c \
+test_no_gravity.c \
+test_rotating_forever.c \
+test_shapes.c \
+test_sleeping_threshold.c \
+test_slider.c \
+test_velocity.c
+
+EXTRA_PROGRAMS =
+
+# NOTE: neither ephysics_test or ephysics_logo won't be built as they needs Elementary
+# TODO: convert these to bare ecore_evas, at least a reduced set to have compile-able examples
+
+ephysics_test_SOURCES = \
+ephysics_test.h \
+test_bouncing_ball.c \
+test_bouncing_text.c \
+test.c \
+test_camera.c \
+test_camera_track.c \
+test_colliding_balls.c \
+test_collision_detection.c \
+test_collision_filter.c \
+test_constraint.c \
+test_delete.c \
+test_forces.c \
+test_growing_balls.c \
+test_no_gravity.c \
+test_rotating_forever.c \
+test_shapes.c \
+test_sleeping_threshold.c \
+test_slider.c \
+test_velocity.c
+
+examples: $(EXTRA_PROGRAMS)
+
+clean-local:
+        rm -f $(EXTRA_PROGRAMS)
+
+install-examples:
+        mkdir -p $(datadir)/ephysics/examples
+        $(install_sh_DATA) -c $(SRCS) $(datadir)/ephysics/examples
+
+uninstall-local:
+        for f in $(SRCS) ; do \
+          rm -f $(datadir)/ephysics/examples/$$f ; \
+        done
diff --git a/src/examples/ephysics/ephysics_logo.c b/src/examples/ephysics/ephysics_logo.c
new file mode 100644
index 0000000000..2d055662f8
--- /dev/null
+++ b/src/examples/ephysics/ephysics_logo.c
@@ -0,0 +1,280 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <Elementary.h>
+#include <EPhysics.h>
+#include <Evas.h>
+
+#define WIDTH (512)
+#define HEIGHT (384)
+#define DEPTH (100)
+#define FLOOR_Y (HEIGHT - 80)
+#define SH_THRESHOLD (250)
+#define SH_OFFSET_X (- 16)
+#define OFFSET_X (90)
+#define PADDING_X_1 (16)
+#define PADDING_X_2 (12)
+#define PADDING_X_3 (22)
+#define E_THRESHOLD (WIDTH + 560)
+#define LAYER_SHADOW (10)
+#define LAYER_LETTER (20)
+
+#define CENTER(total, item)  (((total) - (item)) / 2)
+#define LIMIT(val, op, ref) (((val) op (ref)) ? (val) : (ref));
+#define PROP_GET(pos, min, max) (((min) + ((max) - (min)) * (pos)) / (max))
+
+static void
+_update_box_cb(void *data __UNUSED__, EPhysics_Body *body, void *event_info)
+{
+   Evas_Object *image = event_info;
+   Evas_Object *shadow = evas_object_data_get(image, "shadow");
+   Evas_Object *light = evas_object_data_get(image, "light");
+   int x, y, w, h, floor_distance, alpha = 0;
+
+   /* modify the evas object according to the body */
+   ephysics_body_evas_object_update(body);
+   evas_object_geometry_get(image, &x, &y, &w, &h);
+
+   floor_distance = FLOOR_Y - h;
+
+   /* Bodies penetrates the ground slightly before bouncing. */
+   /* This is to be expected in realtime physics engines. */
+   // TODO BUG: should we move the object up by the difference????
+   //y = LIMIT(y, <=, floor_distance);
+
+   /* We should show the shadow when we're close enough to ground */
+   if (y > SH_THRESHOLD)
+     {
+        int sh_w, sh_h;
+        double pos_x;
+
+        evas_object_image_size_get(shadow, &sh_w, &sh_h);
+        /* shadow is darker with bigger y */
+        alpha = 255 * (y - SH_THRESHOLD) / (floor_distance - SH_THRESHOLD);
+        /* and with bigger x -- it's proportional to x / WIDTH, but varies
+         * from 100 to 255.
+         */
+        pos_x = (double) x / (WIDTH - w);
+        alpha = alpha * PROP_GET(pos_x, 100, 255);
+        /* box shadow is not resized, just moved */
+        evas_object_move(shadow, x + CENTER(w, sh_w) + SH_OFFSET_X,
+                         FLOOR_Y - sh_h + 2);
+     }
+   evas_object_color_set(shadow, alpha, alpha, alpha, alpha);
+
+   evas_object_move(light, x, y);
+   /* it's lighter with bigger y */
+   alpha = (y <= 0) ? 0 : y * 255 / floor_distance;
+   /* and with bigger x */
+   alpha = alpha * (x - OFFSET_X + 80) / (WIDTH - OFFSET_X);
+   evas_object_color_set(light, alpha, alpha, alpha, alpha);
+}
+
+static void
+_update_circle_cb(void *data __UNUSED__, EPhysics_Body *body, void *event_info)
+{
+   Evas_Object *image = event_info;
+   Evas_Object *shadow = evas_object_data_get(image, "shadow");
+   Evas_Object *light = evas_object_data_get(image, "light");
+   int x, y, w, h, sh_w, sh_h, alpha = 0;
+   const Evas_Map *map;
+
+   /* modify the evas object according to the body */
+   ephysics_body_evas_object_update(body);
+   evas_object_geometry_get(image, &x, &y, &w, &h);
+
+   evas_object_move(light, x, y);
+   alpha = x * 255 / (WIDTH - w);
+   evas_object_color_set(light, alpha, alpha, alpha, alpha);
+
+   /* use the same map from image to the light (rotate it) */
+   map = evas_object_map_get(image);
+   evas_object_map_set(light, map);
+   evas_object_map_enable_set(light, EINA_TRUE);
+
+   evas_object_image_size_get(shadow, &sh_w, &sh_h);
+   evas_object_move(shadow, x + CENTER(w, sh_w) + SH_OFFSET_X,
+                    FLOOR_Y - sh_h + 2);
+   alpha = 127 + alpha / 2;
+   evas_object_color_set(shadow, alpha, alpha, alpha, alpha);
+
+   if (x > E_THRESHOLD)
+     ephysics_body_move(body, -w - 1, y, -15);
+}
+
+static void
+_letter_add(Evas *evas, const char *letter, Evas_Object **image, Evas_Object **light, Evas_Object **shadow)
+{
+   int w, h, sh_w, sh_h;
+   char buf[1024];
+
+   snprintf(buf, sizeof(buf), PACKAGE_DATA_DIR "/logo_shadow-%s.png", letter);
+   *shadow = evas_object_image_filled_add(evas);
+   evas_object_image_file_set(*shadow, buf, NULL);
+   evas_object_image_size_get(*shadow, &sh_w, &sh_h);
+   evas_object_resize(*shadow, sh_w, sh_h);
+   evas_object_color_set(*shadow, 0, 0, 0, 0);
+   evas_object_layer_set(*shadow, LAYER_SHADOW);
+   evas_object_show(*shadow);
+
+   snprintf(buf, sizeof(buf), PACKAGE_DATA_DIR "/logo_letter-%s.png", letter);
+   *image = evas_object_image_filled_add(evas);
+   evas_object_image_file_set(*image, buf, NULL);
+   evas_object_image_size_get(*image, &w, &h);
+   evas_object_resize(*image, w, h);
+   evas_object_layer_set(*image, LAYER_LETTER);
+   evas_object_show(*image);
+
+   snprintf(buf, sizeof(buf), PACKAGE_DATA_DIR "/logo_light-%s.png", letter);
+   *light = evas_object_image_filled_add(evas);
+   evas_object_image_file_set(*light, buf, NULL);
+   evas_object_resize(*light, w, h);
+   evas_object_layer_set(*light, LAYER_LETTER);
+   evas_object_show(*light);
+
+   /* allow easy access to shadow and light from the letter image */
+   evas_object_data_set(*image, "shadow", *shadow);
+   evas_object_data_set(*image, "light", *light);
+}
+
+static void
+_letter_body_setup_common(EPhysics_Body *body, Evas_Object *view)
+{
+   ephysics_body_evas_object_set(body, view, EINA_TRUE);
+   ephysics_body_mass_set(body, 1.2);
+   ephysics_body_restitution_set(body, 0.6);
+   ephysics_body_angular_movement_enable_set(body, EINA_FALSE, EINA_FALSE,
+                                             EINA_FALSE);
+}
+
+static EPhysics_Body *
+_letter_body_box_add(EPhysics_World *world, Evas_Object *image)
+{
+   EPhysics_Body *body = ephysics_body_box_add(world);
+
+   _letter_body_setup_common(body, image);
+
+   ephysics_body_event_callback_add
+     (body, EPHYSICS_CALLBACK_BODY_UPDATE, _update_box_cb, NULL);
+
+   return body;
+}
+
+static EPhysics_Body *
+_letter_body_circle_add(EPhysics_World *world, Evas_Object *image)
+{
+   EPhysics_Body *body = ephysics_body_cylinder_add(world);
+
+   _letter_body_setup_common(body, image);
+
+   ephysics_body_event_callback_add
+     (body, EPHYSICS_CALLBACK_BODY_UPDATE, _update_circle_cb, NULL);
+
+   return body;
+}
+
+EAPI_MAIN int
+elm_main(int argc __UNUSED__, char **argv __UNUSED__)
+{
+   Evas_Object *win, *bg, *image, *light, *shadow;
+   EPhysics_Body *ground_body, *letter_body;
+   EPhysics_World *world;
+   unsigned int i = 0;
+   int x, w, h, sh_w;
+   Evas *evas;
+
+   struct letter_desc {
+      const char *letter;
+      int padding;
+   } falling_letters[] = {
+     {"P", PADDING_X_1},
+     {"H", PADDING_X_1},
+     {"Y", PADDING_X_3},
+     {"S1", PADDING_X_2},
+     {"I", PADDING_X_2},
+     {"C", PADDING_X_3},
+     {"S2", 0}
+   };
+
+   if (!ephysics_init())
+     return - 1;
+
+   elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
+
+   win = elm_win_add(NULL, "main", ELM_WIN_SPLASH);
+   elm_win_title_set(win, "EPhysics Logo");
+   elm_win_autodel_set(win, EINA_TRUE);
+   evas_object_show(win);
+
+   bg = elm_bg_add(win);
+   elm_bg_file_set(bg, PACKAGE_DATA_DIR "/logo_background.png", NULL);
+   elm_win_resize_object_add(win, bg);
+   evas_object_size_hint_min_set(bg, WIDTH, HEIGHT);
+   evas_object_size_hint_max_set(bg, WIDTH, HEIGHT);
+   evas_object_show(bg);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 0, 0, -50, WIDTH, HEIGHT, DEPTH);
+
+   ground_body = ephysics_body_box_add(world);
+   ephysics_body_mass_set(ground_body, EPHYSICS_BODY_MASS_STATIC);
+   ephysics_body_geometry_set(ground_body, -100, FLOOR_Y, -15, WIDTH + 800, 10,
+                              30);
+   ephysics_body_restitution_set(ground_body, 0.65);
+   ephysics_body_friction_set(ground_body, 0.8);
+
+   evas = evas_object_evas_get(win);
+   x = OFFSET_X;
+
+   for (i = 0; i < EINA_C_ARRAY_LENGTH(falling_letters); i++)
+     {
+        _letter_add(evas, falling_letters[i].letter, &image, &light, &shadow);
+
+        evas_object_image_size_get(shadow, &sh_w, NULL);
+        evas_object_image_size_get(image, &w, &h);
+
+        /* place image and light on top, above what the viewport can show */
+        evas_object_move(image, x, -h * (i + 1) - 50);
+        evas_object_move(light, x, -h * (i + 1) - 50);
+        /* place shadow below the hit-line: FLOOR_Y, centered at image */
+        evas_object_move(shadow, x + CENTER(w, sh_w), FLOOR_Y);
+
+        x += falling_letters[i].padding + w;
+
+        letter_body = _letter_body_box_add(world, image);
+        ephysics_body_friction_set(letter_body, 0.4);
+     }
+
+   /* E is a circle that comes rolling on the floor */
+   _letter_add(evas, "E", &image, &light, &shadow);
+   evas_object_color_set(shadow, 255, 255, 255, 255);
+
+   evas_object_image_size_get(shadow, &sh_w, NULL);
+   evas_object_image_size_get(image, &w, &h);
+   /* place image and light so they are above the floor,
+    * and to the left of viewport
+    */
+   evas_object_move(image, -w - 1, FLOOR_Y - h + 1);
+   evas_object_move(light, -w - 1, FLOOR_Y - h + 1);
+   /* place the shadow below the hit-line: FLOOR_Y, centered at image */
+   evas_object_move(shadow, -w - 1 + CENTER(w, sh_w), FLOOR_Y);
+
+   letter_body = _letter_body_circle_add(world, image);
+   ephysics_body_friction_set(letter_body, 1);
+   ephysics_body_mass_set(letter_body, 1);
+   ephysics_body_angular_movement_enable_set(letter_body, EINA_FALSE,
+                                             EINA_FALSE, EINA_TRUE);
+
+   /* make the "E" logo get into the viewport by applying an horizontal force */
+   ephysics_body_central_impulse_apply(letter_body, 390, 0, 0);
+
+   elm_run();
+
+   ephysics_world_del(world);
+   ephysics_shutdown();
+   elm_shutdown();
+
+   return 0;
+}
+ELM_MAIN()
diff --git a/src/examples/ephysics/ephysics_test.h b/src/examples/ephysics/ephysics_test.h
new file mode 100644
index 0000000000..56db5957b1
--- /dev/null
+++ b/src/examples/ephysics/ephysics_test.h
@@ -0,0 +1,81 @@
+#ifndef _EPHYSICS_PRIVATE_H
+#define _EPHYSICS_PRIVATE_H
+
+#include <Edje.h>
+#include <Elementary.h>
+#include <Eina.h>
+#include <Evas.h>
+
+#include "EPhysics.h"
+
+#ifdef EPHYSICS_LOG_COLOR
+#undef EPHYSICS_LOG_COLOR
+#endif
+#define EPHYSICS_LOG_COLOR EINA_COLOR_BLUE
+
+#ifdef ERR
+# undef ERR
+#endif
+#define ERR(...) EINA_LOG_DOM_ERR(_ephysics_test_log_dom, __VA_ARGS__)
+
+#ifdef DBG
+# undef DBG
+#endif
+#define DBG(...) EINA_LOG_DOM_DBG(_ephysics_test_log_dom, __VA_ARGS__)
+
+#ifdef INF
+# undef INF
+#endif
+#define INF(...) EINA_LOG_DOM_INFO(_ephysics_test_log_dom, __VA_ARGS__)
+
+#ifdef WRN
+# undef WRN
+#endif
+#define WRN(...) EINA_LOG_DOM_WARN(_ephysics_test_log_dom, __VA_ARGS__)
+
+#ifdef CRIT
+# undef CRIT
+#endif
+#define CRIT(...) EINA_LOG_DOM_CRIT(_ephysics_test_log_dom, __VA_ARGS__)
+
+#define EPHYSICS_TEST_THEME "ephysics_test"
+#define WIDTH (512)
+#define HEIGHT (384)
+#define DEPTH (100)
+#define SHADOW_ALPHA_ID (1)
+#define FLOOR_Y (344)
+#define FLOOR_WIDTH (750)
+#define SH_THRESHOLD (200)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int _ephysics_test_log_dom;
+
+typedef struct _Test_Data Test_Data;
+
+struct _Test_Data {
+     EPhysics_World *world;
+     Evas_Object *layout;
+     Evas_Object *win;
+     Eina_List *constraints;
+     Eina_List *evas_objs;
+     Eina_List *bodies;
+     void *data;
+};
+
+Test_Data *test_data_new(void);
+void test_data_del(Test_Data *test_data);
+
+void test_clean(Test_Data *test_data);
+
+void test_win_add(Test_Data *test_data, const char *title, Eina_Bool autodel);
+
+void update_object_cb(void *data, EPhysics_Body *body, void *event_info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/examples/ephysics/test.c b/src/examples/ephysics/test.c
new file mode 100644
index 0000000000..88cbb5ebc9
--- /dev/null
+++ b/src/examples/ephysics/test.c
@@ -0,0 +1,313 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+#define EPHYSICS_TEST_LOG_COLOR EINA_COLOR_GREEN
+
+int _ephysics_test_log_dom = -1;
+
+typedef struct _EPhysics_Test EPhysics_Test;
+struct _EPhysics_Test {
+     const char *name;
+     void (*func)(void *data, Evas_Object *obj, void *event_info);
+};
+
+/* examples prototypes */
+void test_bouncing_3d(void *data, Evas_Object *obj, void *event_info);
+void test_bouncing_ball(void *data, Evas_Object *obj, void *event_info);
+void test_bouncing_text(void *data, Evas_Object *obj, void *event_info);
+void test_camera(void *data, Evas_Object *obj, void *event_info);
+void test_camera_track(void *data, Evas_Object *obj, void *event_info);
+void test_coins(void *data, Evas_Object *obj, void *event_info);
+void test_colliding_balls(void *data, Evas_Object *obj, void *event_info);
+void test_collision(void *data, Evas_Object *obj, void *event_info);
+void test_collision_filter(void *data, Evas_Object *obj, void *event_info);
+void test_collision_speed(void *data, Evas_Object *obj, void *event_info);
+void test_constraint(void *data, Evas_Object *obj, void *event_info);
+void test_cube_3d(void *data, Evas_Object *obj, void *event_info);
+void test_delete(void *data, Evas_Object *obj, void *event_info);
+void test_dices(void *data, Evas_Object *obj, void *event_info);
+void test_falling_letters(void *data, Evas_Object *obj, void *event_info);
+void test_flag(void *data, Evas_Object *obj, void *event_info);
+void test_flip_page(void *data, Evas_Object *obj, void *event_info);
+void test_forces(void *data, Evas_Object *obj, void *event_info);
+void test_grab(void *data, Evas_Object *obj, void *event_info);
+void test_growing_balls(void *data, Evas_Object *obj, void *event_info);
+void test_heavy(void *data, Evas_Object *obj, void *event_info);
+void test_hinge(void *data, Evas_Object *obj, void *event_info);
+void test_jumping_balls(void *data, Evas_Object *obj, void *event_info);
+void test_light(void *data, Evas_Object *obj, void *event_info);
+void test_material(void *data, Evas_Object *obj, void *event_info);
+void test_no_gravity(void *data, Evas_Object *obj, void *event_info);
+void test_rotate(void *data, Evas_Object *obj, void *event_info);
+void test_rotating_forever(void *data, Evas_Object *obj, void *event_info);
+void test_velocity(void *data, Evas_Object *obj, void *event_info);
+void test_shapes(void *data, Evas_Object *obj, void *event_info);
+void test_sleeping(void *data, Evas_Object *obj, void *event_info);
+void test_slider(void *data, Evas_Object *obj, void *event_info);
+void test_soft_body(void *data, Evas_Object *obj, void *event_info);
+void test_soft_button(void *data, Evas_Object *obj, void *event_info);
+void test_soft_sphere(void *data, Evas_Object *obj, void *event_info);
+void test_win_resize(void *data, Evas_Object *obj, void *event_info);
+
+static const EPhysics_Test tests[] = {
+       {"Bouncing 3D", test_bouncing_3d},
+       {"Bouncing Ball", test_bouncing_ball},
+       {"Bouncing Text", test_bouncing_text},
+       {"Camera", test_camera},
+       {"Camera Track", test_camera_track},
+       {"Colliding Balls", test_colliding_balls},
+       {"Collision Detection", test_collision},
+       {"Collision Filter", test_collision_filter},
+       {"Collision High Speed", test_collision_speed},
+       {"Constraint", test_constraint},
+       {"Cube 3D", test_cube_3d},
+       {"Dices", test_dices},
+       {"Delete Body", test_delete},
+       {"Falling Letters", test_falling_letters},
+       {"Flag - Cloth", test_flag},
+       {"Flip Page", test_flip_page},
+       {"Forces", test_forces},
+       {"Grab", test_grab},
+       {"Growing Balls", test_growing_balls},
+       {"Heavy", test_heavy},
+       {"Hinge", test_hinge},
+       {"Jumping Balls", test_jumping_balls},
+       {"Light", test_light},
+       {"Material", test_material},
+       {"No Gravity", test_no_gravity},
+       {"Raster's Coins", test_coins},
+       {"Rotate", test_rotate},
+       {"Rotating Forever", test_rotating_forever},
+       {"Velocity", test_velocity},
+       {"Shapes", test_shapes},
+       {"Sleeping Threshold", test_sleeping},
+       {"Slider", test_slider},
+       {"Soft Body", test_soft_body},
+       {"Soft Button", test_soft_button},
+       {"Soft Sphere", test_soft_sphere},
+       {"Win Resize", test_win_resize},
+};
+
+static void
+_win_del(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   elm_exit();
+}
+
+static void
+_subwin_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   test_data_del(data);
+   ephysics_shutdown();
+}
+
+void
+update_object_cb(void *data, EPhysics_Body *body, void *event_info)
+{
+   Evas_Object *sphere = event_info;
+   Evas_Object *shadow = data;
+   Edje_Message_Float msg;
+   Evas_Object *edje;
+   int x, y, w, h;
+
+   ephysics_body_evas_object_update(body);
+   evas_object_geometry_get(sphere, &x, &y, &w, &h);
+
+   if (y > SH_THRESHOLD)
+     {
+        int sh_w;
+
+        msg.val = (double) (y - SH_THRESHOLD) / (FLOOR_Y - SH_THRESHOLD - h);
+        sh_w = (1 + 2 * msg.val) * w / 3;
+        evas_object_resize(shadow, sh_w, 3);
+        evas_object_move(shadow, x + (w - sh_w) / 2, FLOOR_Y);
+     }
+   else
+        msg.val = 0;
+
+   edje = elm_layout_edje_get(shadow);
+   edje_object_message_send(edje, EDJE_MESSAGE_FLOAT, SHADOW_ALPHA_ID, &msg);
+}
+
+void
+test_clean(Test_Data *test_data)
+{
+   EPhysics_Constraint *constraint;
+   Evas_Object *evas_obj;
+   EPhysics_Body *body;
+
+   EINA_LIST_FREE(test_data->constraints, constraint)
+      ephysics_constraint_del(constraint);
+
+   EINA_LIST_FREE(test_data->bodies, body)
+      ephysics_body_del(body);
+
+   EINA_LIST_FREE(test_data->evas_objs, evas_obj)
+      evas_object_del(evas_obj);
+}
+
+void
+test_data_del(Test_Data *test_data)
+{
+   Evas_Object *evas_obj;
+   EINA_LIST_FREE(test_data->evas_objs, evas_obj)
+      evas_object_del(evas_obj);
+
+   eina_list_free(test_data->bodies);
+   eina_list_free(test_data->constraints);
+
+   evas_object_del(test_data->layout);
+   ephysics_world_del(test_data->world);
+   free(test_data);
+}
+
+Test_Data *
+test_data_new(void)
+{
+   Test_Data *test_data;
+
+   test_data = calloc(1, sizeof(Test_Data));
+   if (!test_data)
+     ERR("Failed to create test data");
+
+   return test_data;
+}
+
+void
+test_win_add(Test_Data *test_data, const char *title, Eina_Bool autodel)
+{
+   Evas_Object *win, *ly;
+
+   win = elm_win_add(NULL, title, ELM_WIN_BASIC);
+   elm_win_title_set(win, title);
+   elm_win_autodel_set(win, EINA_TRUE);
+   evas_object_show(win);
+   test_data->win = win;
+   if (autodel)
+     evas_object_event_callback_add(win, EVAS_CALLBACK_DEL,
+                                    _subwin_del_cb, test_data);
+
+   ly = elm_layout_add(win);
+   elm_win_resize_object_add(win, ly);
+   evas_object_size_hint_min_set(ly, WIDTH, HEIGHT);
+   evas_object_size_hint_max_set(ly, WIDTH, HEIGHT);
+   elm_layout_file_set(ly, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+                       "frame");
+   evas_object_show(ly);
+   test_data->layout = ly;
+}
+
+static void
+_test_run(char *autorun)
+{
+   unsigned int i;
+
+   for (i = 0; i < EINA_C_ARRAY_LENGTH(tests); i++)
+     {
+        EPhysics_Test test = tests[i];
+        if (!strcmp(test.name, autorun))
+          {
+             test.func(NULL, NULL, NULL);
+             return;
+          }
+     }
+}
+
+static void
+_main_win_add(char *autorun)
+{
+   Elm_Object_Item *selected = NULL;
+   Evas_Object *win, *list;
+   unsigned int i;
+
+   win = elm_win_add(NULL, "main", ELM_WIN_BASIC);
+   elm_win_title_set(win, "EPhysics Tests");
+   evas_object_smart_callback_add(win, "delete,request", _win_del, NULL);
+   elm_win_autodel_set(win, EINA_TRUE);
+   evas_object_resize(win, 460, 560);
+   evas_object_show(win);
+
+   list = elm_list_add(win);
+   elm_object_style_set(list, "ephysics-test");
+   elm_list_select_mode_set(list, ELM_OBJECT_SELECT_MODE_ALWAYS);
+   evas_object_size_hint_weight_set(list, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+   elm_win_resize_object_add(win, list);
+   evas_object_show(list);
+
+   for (i = 0; i < EINA_C_ARRAY_LENGTH(tests); i++)
+     {
+        Elm_Object_Item *item;
+        EPhysics_Test test;
+
+        test = tests[i];
+        item = elm_list_item_append(list, test.name, NULL, NULL, test.func,
+                                    NULL);
+
+        if ((autorun) && (!strcmp(test.name, autorun)))
+          selected = item;
+     }
+
+   elm_list_go(list);
+
+   if (selected)
+     elm_list_item_bring_in(selected);
+
+   if (autorun)
+     _test_run(autorun);
+}
+
+EAPI_MAIN int
+elm_main(int argc, char **argv)
+{
+   Eina_Bool test_win_only = EINA_FALSE;
+   char *autorun = NULL;
+
+   _ephysics_test_log_dom = eina_log_domain_register(
+      "ephysics-test", EPHYSICS_TEST_LOG_COLOR);
+   if (_ephysics_test_log_dom < 0)
+     {
+        EINA_LOG_CRIT("Could not register log domain: ephysics-test");
+        return -1;
+     }
+
+   elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED);
+   elm_policy_set(ELM_POLICY_EXIT, ELM_POLICY_EXIT_WINDOWS_DEL);
+
+   elm_app_compile_bin_dir_set(PACKAGE_BIN_DIR);
+   elm_app_compile_data_dir_set(PACKAGE_DATA_DIR);
+
+   /* if called with a single argument try to autorun a test with
+    * the same name as the given param
+    * ex: ephysics_test "Jumping Balls" */
+   if (argc == 2)
+     autorun = argv[1];
+   else if (argc == 3)
+     {
+        if ((!strcmp(argv[1], "--test-win-only")) ||
+            (!strcmp(argv[1], "-to")))
+          {
+             test_win_only = EINA_TRUE;
+             autorun = argv[2];
+          }
+     }
+
+   elm_theme_extension_add(NULL,
+                           PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj");
+
+   if (test_win_only)
+       _test_run(autorun);
+   else
+       _main_win_add(autorun);
+
+   elm_run();
+
+   eina_log_domain_unregister(_ephysics_test_log_dom);
+   _ephysics_test_log_dom = -1;
+
+   elm_shutdown();
+   return 0;
+}
+ELM_MAIN()
diff --git a/src/examples/ephysics/test_bouncing_ball.c b/src/examples/ephysics/test_bouncing_ball.c
new file mode 100644
index 0000000000..00736b09c8
--- /dev/null
+++ b/src/examples/ephysics/test_bouncing_ball.c
@@ -0,0 +1,112 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static Eina_Bool
+_on_keydown(void *data, Evas_Object *obj __UNUSED__, Evas_Object *src __UNUSED__, Evas_Callback_Type type, void *event_info)
+{
+   Evas_Event_Key_Down *ev = event_info;
+   EPhysics_Body *body = data;
+
+   if (type != EVAS_CALLBACK_KEY_UP)
+     return EINA_FALSE;
+
+   if (strcmp(ev->keyname, "Up") == 0)
+     ephysics_body_central_impulse_apply(body, 0, -300, 0);
+   else if (strcmp(ev->keyname, "Down") == 0)
+     ephysics_body_central_impulse_apply(body, 0, 300, 0);
+   else if (strcmp(ev->keyname, "Right") == 0)
+     ephysics_body_central_impulse_apply(body, 300, 0, 0);
+   else if (strcmp(ev->keyname, "Left") == 0)
+     ephysics_body_central_impulse_apply(body, -300, 0, 0);
+
+   return EINA_TRUE;
+}
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   Evas_Object *sphere, *shadow;
+   EPhysics_Body *fall_body;
+
+   shadow = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      shadow, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-ball");
+   evas_object_move(shadow, WIDTH / 3, FLOOR_Y);
+   evas_object_resize(shadow, 70, 3);
+   evas_object_show(shadow);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, shadow);
+
+   sphere = elm_image_add(test_data->win);
+   elm_image_file_set(
+      sphere, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "big-blue-ball");
+   evas_object_move(sphere, WIDTH / 3, HEIGHT / 8);
+   evas_object_resize(sphere, 70, 70);
+   evas_object_show(sphere);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sphere);
+
+   fall_body = ephysics_body_sphere_add(test_data->world);
+   ephysics_body_evas_object_set(fall_body, sphere, EINA_TRUE);
+   ephysics_body_restitution_set(fall_body, 0.95);
+   ephysics_body_friction_set(fall_body, 0.1);
+   ephysics_body_event_callback_add(fall_body, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, shadow);
+   test_data->bodies = eina_list_append(test_data->bodies, fall_body);
+   test_data->data = fall_body;
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   elm_object_event_callback_del(test_data->win, _on_keydown, test_data->data);
+   test_clean(test_data);
+   _world_populate(test_data);
+   elm_object_event_callback_add(test_data->win, _on_keydown, test_data->data);
+}
+
+void
+test_bouncing_ball(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Bouncing Ball", EINA_TRUE);
+
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_object_signal_emit(test_data->layout, "arrows,show", "ephysics_test");
+
+   world = ephysics_world_new();
+   ephysics_world_light_all_bodies_set(world, EINA_TRUE);
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   test_data->world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.65);
+   ephysics_body_friction_set(boundary, 4);
+
+   boundary = ephysics_body_right_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.4);
+   ephysics_body_friction_set(boundary, 3);
+
+   boundary = ephysics_body_left_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.4);
+   ephysics_body_friction_set(boundary, 3);
+
+   ephysics_body_top_boundary_add(test_data->world);
+
+   _world_populate(test_data);
+   elm_object_event_callback_add(test_data->win, _on_keydown, test_data->data);
+}
diff --git a/src/examples/ephysics/test_bouncing_text.c b/src/examples/ephysics/test_bouncing_text.c
new file mode 100644
index 0000000000..c2d7d09c3e
--- /dev/null
+++ b/src/examples/ephysics/test_bouncing_text.c
@@ -0,0 +1,67 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   EPhysics_Body *text_body;
+   Evas_Object *text;
+   int x, y, w;
+
+   text = evas_object_text_add(evas_object_evas_get(test_data->win));
+   evas_object_text_text_set(text, "EPHYSICS");
+   evas_object_text_font_set(text, "Sans", 54);
+   evas_object_color_set(text, 95, 56, 19, 255);
+   evas_object_move(text, WIDTH / 4, HEIGHT / 8);
+   evas_object_show(text);
+   evas_object_geometry_get(text, &x, &y, &w, NULL);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, text);
+
+   text_body = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(text_body, text, EINA_FALSE);
+   ephysics_body_geometry_set(text_body, x, y, -15, w * 5 / 6, 46, 30);
+   ephysics_body_restitution_set(text_body, 0.95);
+   ephysics_body_friction_set(text_body, 0.1);
+   test_data->bodies = eina_list_append(test_data->bodies, text_body);
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_bouncing_text(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Bouncing Text", EINA_TRUE);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, 100);
+   test_data->world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.65);
+   ephysics_body_friction_set(boundary, 2);
+
+   _world_populate(test_data);
+}
diff --git a/src/examples/ephysics/test_camera.c b/src/examples/ephysics/test_camera.c
new file mode 100644
index 0000000000..8dc1dcc74a
--- /dev/null
+++ b/src/examples/ephysics/test_camera.c
@@ -0,0 +1,236 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+typedef struct _Camera_Data Camera_Data;
+
+struct _Camera_Data {
+     Test_Data base;
+     Ecore_Animator *animator;
+     int old_x;
+};
+
+static void
+_update_floor(Evas_Object *floor_obj, Evas_Coord delta)
+{
+   int fx, x, y;
+
+   evas_object_geometry_get(floor_obj, &x, &y, NULL, NULL);
+   fx = x + delta;
+   if (fx < -FLOOR_WIDTH)
+     fx += 2 * FLOOR_WIDTH;
+   evas_object_move(floor_obj, fx, y);
+}
+
+static void
+_camera_moved_cb(void *data, EPhysics_World *world __UNUSED__, void *event_info)
+{
+   EPhysics_Camera *camera = event_info;
+   Camera_Data *camera_data = data;
+   Evas_Object *floor_obj;
+   int x;
+
+   DBG("Camera moved");
+
+   ephysics_camera_position_get(camera, &x, NULL);
+
+   floor_obj = evas_object_data_get(camera_data->base.layout, "floor");
+   _update_floor(floor_obj, camera_data->old_x - x);
+
+   floor_obj = evas_object_data_get(camera_data->base.layout, "floor2");
+   _update_floor(floor_obj, camera_data->old_x - x);
+
+   camera_data->old_x = x;
+}
+
+static Eina_Bool
+_camera_move_cb(void *data)
+{
+   Camera_Data *camera_data = data;
+   EPhysics_Camera *camera;
+   int x, y, w;
+
+   ephysics_world_render_geometry_get(camera_data->base.world,
+                                      NULL, NULL, NULL, &w, NULL, NULL);
+
+   camera = ephysics_world_camera_get(camera_data->base.world);
+   ephysics_camera_position_get(camera, &x, &y);
+
+   if (x + w > WIDTH * 2)
+     {
+        camera_data->animator = NULL;
+        return EINA_FALSE;
+     }
+
+   x += 2;
+   ephysics_camera_position_set(camera, x, y);
+
+   return EINA_TRUE;
+}
+
+static void
+_world_populate(Camera_Data *camera_data)
+{
+   Evas_Object *sphere, *shadow;
+   EPhysics_Body *fall_body;
+
+   shadow = elm_layout_add(camera_data->base.win);
+   elm_layout_file_set(
+      shadow, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-ball");
+   evas_object_move(shadow, WIDTH / 3, FLOOR_Y);
+   evas_object_resize(shadow, 70, 3);
+   evas_object_show(shadow);
+   camera_data->base.evas_objs = eina_list_append(camera_data->base.evas_objs,
+                                                  shadow);
+
+   sphere = elm_image_add(camera_data->base.win);
+   elm_image_file_set(
+      sphere, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+      "big-blue-ball");
+   evas_object_move(sphere, WIDTH / 3, FLOOR_Y - 70);
+   evas_object_resize(sphere, 70, 70);
+   evas_object_show(sphere);
+   camera_data->base.evas_objs = eina_list_append(camera_data->base.evas_objs,
+                                                  sphere);
+
+   fall_body = ephysics_body_sphere_add(camera_data->base.world);
+   ephysics_body_evas_object_set(fall_body, sphere, EINA_TRUE);
+   ephysics_body_restitution_set(fall_body, 0.2);
+   ephysics_body_friction_set(fall_body, 1);
+   ephysics_body_event_callback_add(fall_body, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, shadow);
+   camera_data->base.bodies = eina_list_append(camera_data->base.bodies,
+                                               fall_body);
+   ephysics_body_central_impulse_apply(fall_body, 300, 0, 0);
+
+   shadow = elm_layout_add(camera_data->base.win);
+   elm_layout_file_set(
+      shadow, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-ball");
+   evas_object_move(shadow, WIDTH * 4 / 3, FLOOR_Y);
+   evas_object_resize(shadow, 70, 3);
+   evas_object_show(shadow);
+   camera_data->base.evas_objs = eina_list_append(camera_data->base.evas_objs,
+                                                  shadow);
+
+   sphere = elm_image_add(camera_data->base.win);
+   elm_image_file_set(
+      sphere, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "big-red-ball");
+   evas_object_move(sphere, WIDTH * 4 / 3, FLOOR_Y - 70);
+   evas_object_resize(sphere, 70, 70);
+   evas_object_show(sphere);
+   camera_data->base.evas_objs = eina_list_append(camera_data->base.evas_objs,
+                                                  sphere);
+
+   fall_body = ephysics_body_sphere_add(camera_data->base.world);
+   ephysics_body_mass_set(fall_body, 4.6);
+   ephysics_body_evas_object_set(fall_body, sphere, EINA_TRUE);
+   ephysics_body_restitution_set(fall_body, 0.12);
+   ephysics_body_friction_set(fall_body, 2);
+   ephysics_body_event_callback_add(fall_body, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, shadow);
+   camera_data->base.bodies = eina_list_append(camera_data->base.bodies,
+                                               fall_body);
+
+   camera_data->animator = ecore_animator_add(_camera_move_cb, camera_data);
+}
+
+static void
+_win_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Camera_Data *camera_data = data;
+
+   if (camera_data->animator)
+     ecore_animator_del(camera_data->animator);
+
+   test_clean((Test_Data *)camera_data);
+   evas_object_del(camera_data->base.layout);
+   ephysics_world_del(camera_data->base.world);
+   free(camera_data);
+   ephysics_shutdown();
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Camera_Data *camera_data = data;
+   EPhysics_Camera *camera;
+   Evas_Object *floor_obj;
+
+   DBG("Restart pressed");
+
+   if (camera_data->animator)
+     ecore_animator_del(camera_data->animator);
+
+   camera = ephysics_world_camera_get(camera_data->base.world);
+   ephysics_camera_position_set(camera, 50, 40);
+
+   camera_data->old_x = 0;
+   floor_obj = evas_object_data_get(camera_data->base.layout, "floor");
+   evas_object_move(floor_obj, 0, FLOOR_Y - 20);
+   floor_obj = evas_object_data_get(camera_data->base.layout, "floor2");
+   evas_object_move(floor_obj, FLOOR_WIDTH, FLOOR_Y - 20);
+
+   test_clean((Test_Data *)camera_data);
+   _world_populate(camera_data);
+}
+
+void
+test_camera(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Camera_Data *camera_data;
+   EPhysics_Body *boundary;
+   Evas_Object *floor_obj;
+   EPhysics_World *world;
+
+   if (!ephysics_init())
+     return;
+
+   camera_data = calloc(1, sizeof(Camera_Data));
+   if (!camera_data)
+     {
+        ERR("Failed to create test data");
+        ephysics_shutdown();
+        return;
+     }
+
+   test_win_add((Test_Data *)camera_data, "Camera", EINA_FALSE);
+   evas_object_event_callback_add(camera_data->base.win, EVAS_CALLBACK_DEL,
+                                  _win_del, camera_data);
+
+   elm_layout_signal_callback_add(camera_data->base.layout, "restart",
+                                  "test-theme", _restart, camera_data);
+
+   floor_obj = elm_image_add(camera_data->base.win);
+   elm_image_file_set(
+      floor_obj, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "floor");
+   evas_object_move(floor_obj, 0, FLOOR_Y - 20);
+   evas_object_resize(floor_obj, FLOOR_WIDTH, 224);
+   evas_object_show(floor_obj);
+   evas_object_data_set(camera_data->base.layout, "floor", floor_obj);
+
+   floor_obj = elm_image_add(camera_data->base.win);
+   elm_image_file_set(
+      floor_obj, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "floor");
+   evas_object_move(floor_obj, FLOOR_WIDTH, FLOOR_Y - 20);
+   evas_object_resize(floor_obj, FLOOR_WIDTH, 224);
+   evas_object_show(floor_obj);
+   evas_object_data_set(camera_data->base.layout, "floor2", floor_obj);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   ephysics_world_event_callback_add(world,
+                                     EPHYSICS_CALLBACK_WORLD_CAMERA_MOVED,
+                                     _camera_moved_cb, camera_data);
+   camera_data->base.world = world;
+
+   boundary = ephysics_body_box_add(camera_data->base.world);
+   ephysics_body_mass_set(boundary, 0);
+   ephysics_body_geometry_set(boundary, 0, FLOOR_Y, -15, WIDTH * 2, 10, 30);
+   ephysics_body_restitution_set(boundary, 0.65);
+   ephysics_body_friction_set(boundary, 4);
+
+   _world_populate(camera_data);
+}
diff --git a/src/examples/ephysics/test_camera_track.c b/src/examples/ephysics/test_camera_track.c
new file mode 100644
index 0000000000..443ec3f994
--- /dev/null
+++ b/src/examples/ephysics/test_camera_track.c
@@ -0,0 +1,248 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+typedef struct _Track_Data Track_Data;
+
+struct _Track_Data {
+     Test_Data base;
+     EPhysics_Body *body;
+     Evas_Object *sp;
+     int old_cx;
+};
+
+static void
+_update_floor(Evas_Object *layout, const char *name, int delta_x, int cy, Eina_Bool ver)
+{
+   Evas_Object *floor_obj;
+   int x, y, fx, fy;
+
+   floor_obj = evas_object_data_get(layout, name);
+   evas_object_geometry_get(floor_obj, &x, &y, NULL, NULL);
+   fx = x + delta_x;
+   if (fx < -FLOOR_WIDTH)
+     fx += 2 * FLOOR_WIDTH;
+
+   fy = (ver) ? FLOOR_Y - 20 - cy + 40 : y;
+   evas_object_move(floor_obj, fx, fy);
+}
+
+static void
+_camera_moved_cb(void *data, EPhysics_World *world __UNUSED__, void *event_info)
+{
+   EPhysics_Camera *camera = event_info;
+   Track_Data *track_data = data;
+   int cx, cy, delta_x = 0;
+   Eina_Bool hor, ver;
+
+   DBG("Camera moved");
+
+   ephysics_camera_tracked_body_get(camera, NULL, &hor, &ver);
+   ephysics_camera_position_get(camera, &cx, &cy);
+
+   if (hor)
+     delta_x = track_data->old_cx - cx;
+
+   _update_floor(track_data->base.layout, "floor", delta_x, cy, ver);
+   _update_floor(track_data->base.layout, "floor2", delta_x, cy, ver);
+
+   track_data->old_cx = cx;
+}
+
+static void
+_track_apply(Track_Data *track_data)
+{
+   Eina_Bool hor = EINA_FALSE;
+   Eina_Bool ver = EINA_FALSE;
+   EPhysics_Camera *camera;
+   EPhysics_Body *body;
+   int mode;
+
+   body = track_data->body;
+   camera = ephysics_world_camera_get(track_data->base.world);
+   mode = (int) elm_spinner_value_get(track_data->sp);
+
+   switch (mode)
+     {
+      case 1:
+         hor = EINA_TRUE;
+         break;
+      case 3:
+         hor = EINA_TRUE;
+      case 2:
+         ver = EINA_TRUE;
+     }
+
+   INF("Tracking mode: hor = %i, ver = %i", hor, ver);
+   ephysics_camera_body_track(camera, body, hor, ver);
+}
+
+static void
+_tracking_mode_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   _track_apply(data);
+}
+
+static void
+_world_populate(Track_Data *track_data)
+{
+   static const char *colors[] = {"blue-cube", "purple-cube"};
+   Evas_Object *cube, *sphere;
+   EPhysics_Body *body;
+   int i, color, row;
+
+   for (i = 0; i < 9; i++)
+     {
+        color = i % 3 % 2;
+        row = i / 3;
+
+        cube = elm_image_add(track_data->base.win);
+        elm_image_file_set(
+           cube, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+           colors[color]);
+        evas_object_move(cube, i * 70, (row + 2) * 70);
+        evas_object_resize(cube, 70, 70);
+        evas_object_show(cube);
+        track_data->base.evas_objs = eina_list_append(
+           track_data->base.evas_objs, cube);
+
+        body = ephysics_body_box_add(track_data->base.world);
+        ephysics_body_evas_object_set(body, cube, EINA_TRUE);
+        ephysics_body_restitution_set(body, 0.95);
+        ephysics_body_friction_set(body, 1);
+        ephysics_body_mass_set(body, 0);
+        track_data->base.bodies = eina_list_append(
+           track_data->base.bodies, body);
+     }
+
+   sphere = elm_image_add(track_data->base.win);
+   elm_image_file_set(
+      sphere, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "green-ball");
+   evas_object_move(sphere, 0, 80);
+   evas_object_resize(sphere, 54, 54);
+   evas_object_show(sphere);
+   track_data->base.evas_objs = eina_list_append(track_data->base.evas_objs,
+                                                 sphere);
+
+   body = ephysics_body_sphere_add(track_data->base.world);
+   ephysics_body_evas_object_set(body, sphere, EINA_TRUE);
+   ephysics_body_restitution_set(body, 0.95);
+   ephysics_body_friction_set(body, 1);
+   ephysics_body_damping_set(body, 0.1, 0);
+   ephysics_body_central_impulse_apply(body, 90, 0, 0);
+   track_data->body = body;
+   track_data->base.bodies = eina_list_append(track_data->base.bodies, body);
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Track_Data *track_data = data;
+   EPhysics_Camera *camera;
+   Evas_Object *floor_obj;
+
+   DBG("Restart pressed");
+
+   test_clean((Test_Data *)track_data);
+   _world_populate(track_data);
+
+   floor_obj = evas_object_data_get(track_data->base.layout, "floor");
+   evas_object_move(floor_obj, - WIDTH / 2, FLOOR_Y - 20);
+   floor_obj = evas_object_data_get(track_data->base.layout, "floor2");
+   evas_object_move(floor_obj, FLOOR_WIDTH - WIDTH / 2, FLOOR_Y - 20);
+
+   camera = ephysics_world_camera_get(track_data->base.world);
+   ephysics_camera_position_set(camera, 50, 40);
+   track_data->old_cx = 50;
+
+   _track_apply(track_data);
+}
+
+static void
+_win_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Track_Data *track_data = data;
+
+   test_clean((Test_Data *)track_data);
+   evas_object_del(track_data->base.layout);
+   ephysics_world_del(track_data->base.world);
+   free(track_data);
+   ephysics_shutdown();
+}
+
+void
+test_camera_track(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   Evas_Object *sp, *floor_obj;
+   Track_Data *track_data;
+   EPhysics_World *world;
+
+   if (!ephysics_init())
+     return;
+
+   track_data = calloc(1, sizeof(Track_Data));
+   if (!track_data)
+     {
+        ERR("Failed to create test data");
+        ephysics_shutdown();
+        return;
+     }
+
+   test_win_add((Test_Data *) track_data, "Camera Track", EINA_FALSE);
+   evas_object_event_callback_add(track_data->base.win, EVAS_CALLBACK_DEL,
+                                  _win_del, track_data);
+
+   elm_layout_signal_callback_add(track_data->base.layout, "restart",
+                                  "test-theme", _restart, track_data);
+
+   sp = elm_spinner_add(track_data->base.win);
+   elm_spinner_min_max_set(sp, 0, 3);
+   elm_spinner_step_set(sp, 1);
+   elm_spinner_wrap_set(sp, EINA_TRUE);
+   elm_spinner_special_value_add(sp, 0, "No tracking");
+   elm_spinner_special_value_add(sp, 1, "Horizontal tracking");
+   elm_spinner_special_value_add(sp, 2, "Vertical tracking");
+   elm_spinner_special_value_add(sp, 3, "Full tracking");
+   elm_spinner_editable_set(sp, EINA_FALSE);
+   elm_object_style_set(sp, "ephysics-test");
+   evas_object_smart_callback_add(sp, "delay,changed", _tracking_mode_cb,
+                                  track_data);
+   elm_layout_content_set(track_data->base.layout, "extra_input", sp);
+   track_data->sp = sp;
+
+   floor_obj = elm_image_add(track_data->base.win);
+   elm_image_file_set(
+      floor_obj, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "floor");
+   evas_object_move(floor_obj, - WIDTH / 2, FLOOR_Y - 20);
+   evas_object_resize(floor_obj, FLOOR_WIDTH, 224);
+   evas_object_show(floor_obj);
+   evas_object_data_set(track_data->base.layout, "floor", floor_obj);
+
+   floor_obj = elm_image_add(track_data->base.win);
+   elm_image_file_set(
+      floor_obj, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "floor");
+   evas_object_move(floor_obj, FLOOR_WIDTH - WIDTH / 2, FLOOR_Y - 20);
+   evas_object_resize(floor_obj, FLOOR_WIDTH, 224);
+   evas_object_show(floor_obj);
+   evas_object_data_set(track_data->base.layout, "floor2", floor_obj);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   track_data->base.world = world;
+   ephysics_world_event_callback_add(world,
+                                     EPHYSICS_CALLBACK_WORLD_CAMERA_MOVED,
+                                     _camera_moved_cb, track_data);
+
+   boundary = ephysics_body_box_add(track_data->base.world);
+   ephysics_body_mass_set(boundary, 0);
+   ephysics_body_geometry_set(boundary, 0, FLOOR_Y, -15, WIDTH * 4, 10, 30);
+   ephysics_body_restitution_set(boundary, 0.65);
+   ephysics_body_friction_set(boundary, 4);
+
+   track_data->old_cx = 50;
+   _world_populate(track_data);
+}
diff --git a/src/examples/ephysics/test_colliding_balls.c b/src/examples/ephysics/test_colliding_balls.c
new file mode 100644
index 0000000000..6de20f3569
--- /dev/null
+++ b/src/examples/ephysics/test_colliding_balls.c
@@ -0,0 +1,90 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   static const char *colors[] = {"blue-ball", "red-ball", "green-ball"};
+   Evas_Object *sphere, *shadow;
+   EPhysics_Body *fall_body;
+   int i, column, row;
+
+   for (i = 0; i < 9; i++)
+     {
+        column = i % 3;
+        row = i / 3;
+
+        shadow = elm_layout_add(test_data->win);
+        elm_layout_file_set(
+           shadow, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+           "shadow-ball");
+        evas_object_move(shadow, (1 + column) * WIDTH / 4, FLOOR_Y);
+        evas_object_resize(shadow, 54, 3);
+        evas_object_show(shadow);
+        test_data->evas_objs = eina_list_append(test_data->evas_objs, shadow);
+
+        sphere = elm_image_add(test_data->win);
+        elm_image_file_set(
+           sphere, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+           colors[column]);
+        evas_object_move(sphere, (1 + column) * WIDTH / 4,
+                         100 + row * 60 + row / 2 * 20);
+        evas_object_resize(sphere, 54, 54);
+        evas_object_show(sphere);
+        test_data->evas_objs = eina_list_append(test_data->evas_objs, sphere);
+
+        fall_body = ephysics_body_sphere_add(test_data->world);
+        ephysics_body_evas_object_set(fall_body, sphere, EINA_TRUE);
+        ephysics_body_event_callback_add(fall_body,
+                                         EPHYSICS_CALLBACK_BODY_UPDATE,
+                                         update_object_cb, shadow);
+        ephysics_body_restitution_set(fall_body, 0.95);
+        ephysics_body_friction_set(fall_body, 1);
+        test_data->bodies = eina_list_append(test_data->bodies, fall_body);
+     }
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_colliding_balls(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Colliding Balls", EINA_TRUE);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   test_data->world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.65);
+   ephysics_body_friction_set(boundary, 2);
+
+   ephysics_body_top_boundary_add(test_data->world);
+   ephysics_body_left_boundary_add(test_data->world);
+   ephysics_body_right_boundary_add(test_data->world);
+
+   _world_populate(test_data);
+}
diff --git a/src/examples/ephysics/test_collision_detection.c b/src/examples/ephysics/test_collision_detection.c
new file mode 100644
index 0000000000..5e89163de0
--- /dev/null
+++ b/src/examples/ephysics/test_collision_detection.c
@@ -0,0 +1,187 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+typedef struct _Collision_Data Collision_Data;
+
+struct _Collision_Data {
+     Test_Data base;
+     Evas_Object *impact;
+     EPhysics_Body *sphere;
+     EPhysics_Body *sphere2;
+};
+
+static void
+_collision_cb(void *data, EPhysics_Body *body __UNUSED__, void *event_info)
+{
+   EPhysics_Body *contact_body;
+   Collision_Data *collision_data = data;
+   EPhysics_Body_Collision *collision = event_info;
+   int x, y, z;
+
+   contact_body = ephysics_body_collision_contact_body_get(collision);
+   if (contact_body != collision_data->sphere2) return;
+
+   ephysics_body_collision_position_get(collision, &x, &y, &z);
+
+   evas_object_move(collision_data->impact, x - 10, y - 40);
+   elm_object_signal_emit(collision_data->impact, "impact,show",
+                          "ephysics_test");
+
+   INF("Collision Detected at (%i, %i, %i)", x, y, z);
+}
+
+static void
+_world_populate(Collision_Data *collision_data)
+{
+   Evas_Object *sphere1, *sphere2, *sh1, *sh2, *impact;
+   EPhysics_Body *sphere_body1, *sphere_body2;
+
+   sh1 = elm_layout_add(collision_data->base.win);
+   elm_layout_file_set(
+      sh1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-ball");
+   evas_object_move(sh1, WIDTH / 2, FLOOR_Y);
+   evas_object_resize(sh1, 70, 3);
+   evas_object_show(sh1);
+   collision_data->base.evas_objs = eina_list_append(
+      collision_data->base.evas_objs, sh1);
+
+   sphere1 = elm_image_add(collision_data->base.win);
+   elm_image_file_set(
+      sphere1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+      "big-blue-ball");
+   evas_object_move(sphere1, WIDTH / 2, FLOOR_Y - 70 + 1);
+   evas_object_resize(sphere1, 70, 70);
+   evas_object_show(sphere1);
+   collision_data->base.evas_objs = eina_list_append(
+      collision_data->base.evas_objs, sphere1);
+
+   sphere_body1 = ephysics_body_sphere_add(collision_data->base.world);
+   ephysics_body_evas_object_set(sphere_body1, sphere1, EINA_TRUE);
+   ephysics_body_event_callback_add(sphere_body1,
+                                    EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh1);
+   ephysics_body_restitution_set(sphere_body1, 0.8);
+   ephysics_body_friction_set(sphere_body1, 0.4);
+   collision_data->base.bodies = eina_list_append(
+      collision_data->base.bodies, sphere_body1);
+   collision_data->sphere = sphere_body1;
+
+   sh2 = elm_layout_add(collision_data->base.win);
+   elm_layout_file_set(
+      sh2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-ball");
+   evas_object_move(sh2, WIDTH / 8, FLOOR_Y);
+   evas_object_resize(sh2, 70, 3);
+   evas_object_show(sh2);
+   collision_data->base.evas_objs = eina_list_append(
+      collision_data->base.evas_objs, sh2);
+
+   sphere2 = elm_image_add(collision_data->base.win);
+   elm_image_file_set(
+      sphere2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+      "big-red-ball");
+   evas_object_move(sphere2, WIDTH / 8, FLOOR_Y - 70 + 1);
+   evas_object_resize(sphere2, 70, 70);
+   evas_object_show(sphere2);
+   collision_data->base.evas_objs = eina_list_append(
+      collision_data->base.evas_objs, sphere2);
+
+   sphere_body2 = ephysics_body_sphere_add(collision_data->base.world);
+   ephysics_body_evas_object_set(sphere_body2, sphere2, EINA_TRUE);
+   ephysics_body_event_callback_add(sphere_body2,
+                                    EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh2);
+   ephysics_body_restitution_set(sphere_body2, 1);
+   ephysics_body_friction_set(sphere_body2, 0.4);
+   ephysics_body_central_impulse_apply(sphere_body2, 360, 0, 0);
+   collision_data->sphere2 = sphere_body2;
+   collision_data->base.bodies = eina_list_append(
+      collision_data->base.bodies, sphere_body2);
+
+   impact = elm_layout_add(collision_data->base.win);
+   elm_layout_file_set(
+      impact, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "impact");
+   evas_object_resize(impact, 20, 20);
+   evas_object_show(impact);
+   collision_data->base.evas_objs = eina_list_append(
+      collision_data->base.evas_objs, impact);
+   collision_data->impact = impact;
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Collision_Data *collision_data = data;
+
+   DBG("Restart pressed");
+   ephysics_body_event_callback_del(collision_data->sphere,
+                                    EPHYSICS_CALLBACK_BODY_COLLISION,
+                                    _collision_cb);
+   test_clean((Test_Data *)collision_data);
+   _world_populate(collision_data);
+   ephysics_body_event_callback_add(collision_data->sphere,
+                                    EPHYSICS_CALLBACK_BODY_COLLISION,
+                                    _collision_cb, collision_data);
+}
+
+static void
+_win_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Collision_Data *collision_data = data;
+
+   test_clean((Test_Data *)collision_data);
+   evas_object_del(collision_data->base.layout);
+   ephysics_world_del(collision_data->base.world);
+   free(collision_data);
+   ephysics_shutdown();
+}
+
+void
+test_collision(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Collision_Data *collision_data;
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+
+   if (!ephysics_init())
+     return;
+
+   collision_data = calloc(1, sizeof(Collision_Data));
+   if (!collision_data)
+     {
+        ERR("Failed to create test data");
+        ephysics_shutdown();
+        return;
+     }
+
+   test_win_add((Test_Data *)collision_data, "Collision Detection", EINA_FALSE);
+   elm_object_signal_emit(collision_data->base.layout, "borders,show",
+                          "ephysics_test");
+   evas_object_event_callback_add(collision_data->base.win, EVAS_CALLBACK_DEL,
+                                  _win_del, collision_data);
+   elm_layout_signal_callback_add(collision_data->base.layout, "restart",
+                                  "test-theme", _restart, collision_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   collision_data->base.world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(collision_data->base.world);
+   ephysics_body_restitution_set(boundary, 0);
+   ephysics_body_friction_set(boundary, 20);
+
+   boundary = ephysics_body_right_boundary_add(collision_data->base.world);
+   ephysics_body_restitution_set(boundary, 0.8);
+
+   ephysics_body_left_boundary_add(collision_data->base.world);
+   ephysics_body_top_boundary_add(collision_data->base.world);
+
+   _world_populate(collision_data);
+
+   ephysics_body_event_callback_add(collision_data->sphere,
+                                    EPHYSICS_CALLBACK_BODY_COLLISION,
+                                    _collision_cb, collision_data);
+}
diff --git a/src/examples/ephysics/test_collision_filter.c b/src/examples/ephysics/test_collision_filter.c
new file mode 100644
index 0000000000..b224ff22c6
--- /dev/null
+++ b/src/examples/ephysics/test_collision_filter.c
@@ -0,0 +1,91 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   static const char *colors[] = {"blue-ball", "big-red-ball"};
+   static const int sizes[] = {54, 70};
+   EPhysics_Body *fall_body;
+   Evas_Object *sphere;
+   int i, column, row;
+
+   for (i = 0; i < 4; i++)
+     {
+        column = i % 2;
+        row = i / 2;
+
+        sphere = elm_image_add(test_data->win);
+        elm_image_file_set(
+           sphere, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+           colors[row]);
+        evas_object_move(sphere, (1 + column) * WIDTH / 4 +
+                         (70 - sizes[row]) / 2,
+                         100 + row * 60 + row / 2 * 20);
+        evas_object_resize(sphere, sizes[row], sizes[row]);
+        evas_object_show(sphere);
+        test_data->evas_objs = eina_list_append(test_data->evas_objs, sphere);
+
+        fall_body = ephysics_body_sphere_add(test_data->world);
+        ephysics_body_evas_object_set(fall_body, sphere, EINA_TRUE);
+        ephysics_body_restitution_set(fall_body, 0.95);
+        ephysics_body_friction_set(fall_body, 0.1);
+        ephysics_body_collision_group_add(fall_body, colors[row]);
+        if (column + row == 1)
+          ephysics_body_central_impulse_apply(fall_body, 600 * row - 300, 0, 0);
+        test_data->bodies = eina_list_append(test_data->bodies, fall_body);
+     }
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_collision_filter(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Collision Filter", EINA_TRUE);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 60, 40, -50,
+                                      WIDTH - 120, FLOOR_Y - 32, DEPTH);
+   test_data->world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.65);
+   ephysics_body_friction_set(boundary, 2);
+
+   boundary = ephysics_body_box_add(test_data->world);
+   ephysics_body_geometry_set(boundary, 60, FLOOR_Y - 16, -15, WIDTH - 120, 10,
+                              30);
+   ephysics_body_restitution_set(boundary, 0.65);
+   ephysics_body_friction_set(boundary, 2);
+   ephysics_body_mass_set(boundary, 0);
+   ephysics_body_collision_group_add(boundary, "blue-ball");
+
+   ephysics_body_top_boundary_add(test_data->world);
+   ephysics_body_left_boundary_add(test_data->world);
+   ephysics_body_right_boundary_add(test_data->world);
+
+   _world_populate(test_data);
+}
diff --git a/src/examples/ephysics/test_constraint.c b/src/examples/ephysics/test_constraint.c
new file mode 100644
index 0000000000..988ed7b415
--- /dev/null
+++ b/src/examples/ephysics/test_constraint.c
@@ -0,0 +1,117 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static void
+_constraint_set(Test_Data *test_data, EPhysics_Body *body1, EPhysics_Body *body2)
+{
+   EPhysics_Constraint *constraint;
+   Evas_Coord b1x, b1y, b1z, b1w, b1h, b1d, b2x, b2y, b2z, b2w, b2h, b2d;
+
+   ephysics_body_geometry_get(body1, &b1x, &b1y, &b1z, &b1w, &b1h, &b1d);
+   ephysics_body_geometry_get(body2, &b2x, &b2y, &b2z, &b2w, &b2h, &b2d);
+
+   constraint = ephysics_constraint_linked_add(body1, body2);
+
+   ephysics_constraint_anchor_set(constraint, b1x + b1w / 2, b1y + b1h / 2 + 100,
+                                  b1z, b2x + b2w / 2, b2y + b2h / 2, b2z);
+   test_data->constraints = eina_list_append(test_data->constraints, constraint);
+}
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   EPhysics_Body *box_body1, *box_body2;
+   Evas_Object *box1, *box2, *sh1, *sh2;
+
+   sh1 = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      sh1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-cube");
+   evas_object_move(sh1, WIDTH / 3, FLOOR_Y);
+   evas_object_resize(sh1, 70, 3);
+   evas_object_show(sh1);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sh1);
+
+   box1 = elm_image_add(test_data->win);
+   elm_image_file_set(
+      box1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "blue-cube");
+   evas_object_move(box1, WIDTH / 3, HEIGHT / 8);
+   evas_object_resize(box1, 70, 70);
+   evas_object_show(box1);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, box1);
+
+   box_body1 = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(box_body1, box1, EINA_TRUE);
+   ephysics_body_event_callback_add(box_body1, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh1);
+   ephysics_body_restitution_set(box_body1, 0.3);
+   ephysics_body_friction_set(box_body1, 0.1);
+   test_data->bodies = eina_list_append(test_data->bodies, box_body1);
+
+   sh2 = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      sh2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-cube");
+   evas_object_move(sh2, WIDTH / 3 + 110, FLOOR_Y);
+   evas_object_resize(sh2, 70, 3);
+   evas_object_show(sh2);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sh2);
+
+   box2 = elm_image_add(test_data->win);
+   elm_image_file_set(
+      box2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "purple-cube");
+   evas_object_move(box2, WIDTH / 3 + 110, HEIGHT / 8);
+   evas_object_resize(box2, 70, 70);
+   evas_object_show(box2);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, box2);
+
+   box_body2 = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(box_body2, box2, EINA_TRUE);
+   ephysics_body_mass_set(box_body2, 5);
+   ephysics_body_event_callback_add(box_body2, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh2);
+   ephysics_body_restitution_set(box_body2, 0.5);
+   ephysics_body_friction_set(box_body2, 0.1);
+   test_data->bodies = eina_list_append(test_data->bodies, box_body2);
+
+   _constraint_set(test_data, box_body1, box_body2);
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_constraint(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Constraint", EINA_TRUE);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   test_data->world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.65);
+   ephysics_body_friction_set(boundary, 3);
+
+   _world_populate(test_data);
+}
diff --git a/src/examples/ephysics/test_delete.c b/src/examples/ephysics/test_delete.c
new file mode 100644
index 0000000000..a9d3fc4008
--- /dev/null
+++ b/src/examples/ephysics/test_delete.c
@@ -0,0 +1,193 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+typedef struct _Collision_Data Collision_Data;
+
+struct _Collision_Data {
+     Test_Data base;
+     EPhysics_Body *sphere;
+     EPhysics_Body *sphere2;
+};
+
+static void
+_del_cb(void *data, EPhysics_Body *body, void *event_info __UNUSED__)
+{
+   Collision_Data *collision_data = data;
+   Evas_Object *obj, *shadow;
+
+   obj = ephysics_body_evas_object_get(body);
+   shadow = evas_object_data_get(obj, "shadow");
+
+   collision_data->base.evas_objs = eina_list_remove(
+      collision_data->base.evas_objs, shadow);
+   collision_data->base.evas_objs = eina_list_remove(
+      collision_data->base.evas_objs, obj);
+
+   evas_object_del(shadow);
+   evas_object_del(obj);
+
+   collision_data->sphere = NULL;
+}
+
+static void
+_collision_cb(void *data, EPhysics_Body *body, void *event_info)
+{
+   EPhysics_Body_Collision *collision = event_info;
+   Collision_Data *collision_data = data;
+   EPhysics_Body *contact_body;
+
+   contact_body = ephysics_body_collision_contact_body_get(collision);
+   if (contact_body != collision_data->sphere2) return;
+
+   collision_data->base.bodies = eina_list_remove(collision_data->base.bodies,
+                                                  body);
+
+   INF("Collision Detected");
+   ephysics_body_del(body);
+}
+
+static void
+_world_populate(Collision_Data *collision_data)
+{
+   Evas_Object *sphere1, *sphere2, *sh1, *sh2;
+   EPhysics_Body *sphere_body1, *sphere_body2;
+
+   sh1 = elm_layout_add(collision_data->base.win);
+   elm_layout_file_set(
+      sh1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-ball");
+   evas_object_move(sh1, WIDTH / 2, FLOOR_Y);
+   evas_object_resize(sh1, 70, 3);
+   evas_object_show(sh1);
+   collision_data->base.evas_objs = eina_list_append(
+      collision_data->base.evas_objs, sh1);
+
+   sphere1 = elm_image_add(collision_data->base.win);
+   elm_image_file_set(
+      sphere1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+      "big-red-ball");
+   evas_object_move(sphere1, WIDTH / 2, FLOOR_Y - 70 + 1);
+   evas_object_resize(sphere1, 70, 70);
+   evas_object_show(sphere1);
+   evas_object_data_set(sphere1, "shadow", sh1);
+   collision_data->base.evas_objs = eina_list_append(
+      collision_data->base.evas_objs, sphere1);
+
+   sphere_body1 = ephysics_body_sphere_add(collision_data->base.world);
+   ephysics_body_evas_object_set(sphere_body1, sphere1, EINA_TRUE);
+   ephysics_body_event_callback_add(sphere_body1,
+                                    EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh1);
+   ephysics_body_event_callback_add(sphere_body1,
+                                    EPHYSICS_CALLBACK_BODY_DEL,
+                                    _del_cb, collision_data);
+   ephysics_body_restitution_set(sphere_body1, 0.8);
+   ephysics_body_friction_set(sphere_body1, 0.4);
+   collision_data->base.bodies = eina_list_append(
+      collision_data->base.bodies, sphere_body1);
+   collision_data->sphere = sphere_body1;
+
+   sh2 = elm_layout_add(collision_data->base.win);
+   elm_layout_file_set(
+      sh2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-ball");
+   evas_object_move(sh2, WIDTH / 8, FLOOR_Y);
+   evas_object_resize(sh2, 70, 3);
+   evas_object_show(sh2);
+   collision_data->base.evas_objs = eina_list_append(
+      collision_data->base.evas_objs, sh2);
+
+   sphere2 = elm_image_add(collision_data->base.win);
+   elm_image_file_set(
+      sphere2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+      "big-green-ball");
+   evas_object_move(sphere2, WIDTH / 8, FLOOR_Y - 70 + 1);
+   evas_object_resize(sphere2, 70, 70);
+   evas_object_show(sphere2);
+   collision_data->base.evas_objs = eina_list_append(
+      collision_data->base.evas_objs, sphere2);
+
+   sphere_body2 = ephysics_body_sphere_add(collision_data->base.world);
+   ephysics_body_evas_object_set(sphere_body2, sphere2, EINA_TRUE);
+   ephysics_body_event_callback_add(sphere_body2,
+                                    EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh2);
+   ephysics_body_restitution_set(sphere_body2, 1);
+   ephysics_body_friction_set(sphere_body2, 0.4);
+   ephysics_body_central_impulse_apply(sphere_body2, 360, 0, 0);
+   collision_data->sphere2 = sphere_body2;
+   collision_data->base.bodies = eina_list_append(
+      collision_data->base.bodies, sphere_body2);
+
+   ephysics_body_event_callback_add(collision_data->sphere,
+                                    EPHYSICS_CALLBACK_BODY_COLLISION,
+                                    _collision_cb, collision_data);
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Collision_Data *collision_data = data;
+
+   DBG("Restart pressed");
+   test_clean((Test_Data *)collision_data);
+   _world_populate(collision_data);
+}
+
+static void
+_win_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Collision_Data *collision_data = data;
+
+   test_clean((Test_Data *)collision_data);
+   evas_object_del(collision_data->base.layout);
+   ephysics_world_del(collision_data->base.world);
+   free(collision_data);
+   ephysics_shutdown();
+}
+
+void
+test_delete(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Collision_Data *collision_data;
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+
+   if (!ephysics_init())
+     return;
+
+   collision_data = calloc(1, sizeof(Collision_Data));
+   if (!collision_data)
+     {
+        ERR("Failed to create test data");
+        ephysics_shutdown();
+        return;
+     }
+
+   test_win_add((Test_Data *)collision_data, "Delete Body", EINA_FALSE);
+   evas_object_event_callback_add(collision_data->base.win, EVAS_CALLBACK_DEL,
+                                  _win_del, collision_data);
+   elm_object_signal_emit(collision_data->base.layout, "borders,show",
+                          "ephysics_test");
+   elm_layout_signal_callback_add(collision_data->base.layout, "restart",
+                                  "test-theme", _restart, collision_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   collision_data->base.world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(collision_data->base.world);
+   ephysics_body_restitution_set(boundary, 0);
+   ephysics_body_friction_set(boundary, 20);
+
+   ephysics_body_left_boundary_add(collision_data->base.world);
+   ephysics_body_right_boundary_add(collision_data->base.world);
+
+   _world_populate(collision_data);
+
+   ephysics_body_event_callback_add(collision_data->sphere,
+                                    EPHYSICS_CALLBACK_BODY_COLLISION,
+                                    _collision_cb, collision_data);
+}
diff --git a/src/examples/ephysics/test_forces.c b/src/examples/ephysics/test_forces.c
new file mode 100644
index 0000000000..44870cc729
--- /dev/null
+++ b/src/examples/ephysics/test_forces.c
@@ -0,0 +1,114 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static void
+_update_object_cb(void *data __UNUSED__, EPhysics_Body *body, void *event_info __UNUSED__)
+{
+   double x, y, z, torque, vx, vy, vz, va;
+
+   ephysics_body_evas_object_update(body);
+   ephysics_body_forces_get(body, &x, &y, &z);
+   ephysics_body_torques_get(body, NULL, NULL, &torque);
+   DBG("Body %p, fx: %lf, fy: %lf, fz: %lf, torque: %lf", body, x, y, z,
+       torque);
+
+   ephysics_body_linear_velocity_get(body, &vx, &vy, &vz);
+   ephysics_body_angular_velocity_get(body, NULL, NULL, &va);
+   DBG("Body %p, vx: %lf, vy: %lf, vz: %lf, va: %lf", body, vx, vy, vz, va);
+}
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   EPhysics_Body *box_body1, *box_body2;
+   Evas_Object *box1, *box2;
+
+   box1 = elm_image_add(test_data->win);
+   elm_image_file_set(
+      box1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "blue-cube");
+   evas_object_move(box1, 80, FLOOR_Y - 200);
+   evas_object_resize(box1, 70, 70);
+   evas_object_show(box1);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, box1);
+
+   box_body1 = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(box_body1, box1, EINA_TRUE);
+   ephysics_body_event_callback_add(box_body1, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    _update_object_cb, NULL);
+   ephysics_body_restitution_set(box_body1, 0.7);
+   ephysics_body_friction_set(box_body1, 0);
+   ephysics_body_force_apply(box_body1, 60, 0, 0, 0, 10, 0);
+   test_data->bodies = eina_list_append(test_data->bodies, box_body1);
+
+   box2 = elm_image_add(test_data->win);
+   elm_image_file_set(
+      box2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "purple-cube");
+   evas_object_move(box2, 80, FLOOR_Y - 100);
+   evas_object_resize(box2, 70, 70);
+   evas_object_show(box2);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, box2);
+
+   box_body2 = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(box_body2, box2, EINA_TRUE);
+   ephysics_body_event_callback_add(box_body2, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    _update_object_cb, NULL);
+   ephysics_body_restitution_set(box_body2, 0.7);
+   ephysics_body_friction_set(box_body2, 0);
+   ephysics_body_central_force_apply(box_body2, 60, 0, 0);
+   test_data->bodies = eina_list_append(test_data->bodies, box_body2);
+   test_data->data = box_body2;
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_forces(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Forces", EINA_TRUE);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   test_data->world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 1);
+   ephysics_body_friction_set(boundary, 0);
+
+   boundary = ephysics_body_top_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 1);
+   ephysics_body_friction_set(boundary, 0);
+
+   boundary = ephysics_body_left_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 1);
+   ephysics_body_friction_set(boundary, 0);
+
+   boundary = ephysics_body_right_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 1);
+   ephysics_body_friction_set(boundary, 0);
+
+   _world_populate(test_data);
+   ephysics_world_gravity_set(world, 0, 0, 0);
+}
diff --git a/src/examples/ephysics/test_growing_balls.c b/src/examples/ephysics/test_growing_balls.c
new file mode 100644
index 0000000000..f92de5f149
--- /dev/null
+++ b/src/examples/ephysics/test_growing_balls.c
@@ -0,0 +1,122 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static Eina_Bool
+_grow_cb(void *data)
+{
+   Test_Data *test_data = data;
+   Evas_Object *obj;
+   Eina_List *l;
+   int size, i = -1;
+
+   EINA_LIST_FOREACH(test_data->evas_objs, l, obj)
+     {
+        evas_object_geometry_get(obj, NULL, NULL, &size, NULL);
+        size += i * 8;
+        i++;
+
+        if ((size < 20) || (size > 120))
+          continue;
+
+        evas_object_resize(obj, size, size);
+     }
+
+   return EINA_TRUE;
+}
+
+static void
+_add_sphere(Test_Data *test_data, const char *group, int size, int x, int y)
+{
+   EPhysics_Body *sphere_body;
+   Evas_Object *sphere;
+
+   sphere = elm_image_add(test_data->win);
+   elm_image_file_set(sphere, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+                      group);
+   evas_object_move(sphere, x, y);
+   evas_object_resize(sphere, size, size);
+   evas_object_show(sphere);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sphere);
+
+   sphere_body = ephysics_body_sphere_add(test_data->world);
+   ephysics_body_evas_object_set(sphere_body, sphere, EINA_TRUE);
+   ephysics_body_restitution_set(sphere_body, 0.5);
+   ephysics_body_central_impulse_apply(sphere_body, 300, 0, 0);
+   test_data->bodies = eina_list_append(test_data->bodies, sphere_body);
+}
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   _add_sphere(test_data, "big-red-ball", 60, 100, 100);
+   _add_sphere(test_data, "big-blue-ball", 60, 150, 150);
+   _add_sphere(test_data, "big-green-ball", 60, 200, 200);
+   test_data->data = ecore_timer_add(1, _grow_cb, test_data);
+}
+
+static void
+_win_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Test_Data *test_data = data;
+   Ecore_Timer *timer = test_data->data;
+
+   if (timer)
+     ecore_timer_del(timer);
+
+   test_data_del(test_data);
+   ephysics_shutdown();
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+   Ecore_Timer *timer = test_data->data;
+
+   if (timer)
+     ecore_timer_del(timer);
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_growing_balls(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Growing Balls", EINA_FALSE);
+   evas_object_event_callback_add(test_data->win, EVAS_CALLBACK_DEL,
+                                  _win_del, test_data);
+
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   test_data->world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.8);
+
+   boundary = ephysics_body_top_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.8);
+   boundary = ephysics_body_left_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.8);
+   boundary = ephysics_body_right_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.8);
+
+   _world_populate(test_data);
+}
diff --git a/src/examples/ephysics/test_no_gravity.c b/src/examples/ephysics/test_no_gravity.c
new file mode 100644
index 0000000000..0052bd2082
--- /dev/null
+++ b/src/examples/ephysics/test_no_gravity.c
@@ -0,0 +1,133 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static void
+_stop(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Test_Data *test_data = data;
+   EPhysics_Body *body = test_data->data;
+
+   ephysics_body_stop(body);
+   INF("Stop purple cube");
+}
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   EPhysics_Body *box_body1, *box_body2;
+   Evas_Object *box1, *box2, *sh1, *sh2;
+
+   sh1 = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      sh1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-cube");
+   evas_object_move(sh1, WIDTH / 2 - 80, FLOOR_Y);
+   evas_object_resize(sh1, 70, 3);
+   evas_object_show(sh1);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sh1);
+
+   box1 = elm_image_add(test_data->win);
+   elm_image_file_set(
+      box1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "blue-cube");
+   evas_object_move(box1, WIDTH / 2 - 80, FLOOR_Y - 200);
+   evas_object_resize(box1, 70, 70);
+   evas_object_show(box1);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, box1);
+
+   box_body1 = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(box_body1, box1, EINA_TRUE);
+   ephysics_body_event_callback_add(box_body1, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh1);
+   ephysics_body_restitution_set(box_body1, 0.7);
+   ephysics_body_friction_set(box_body1, 0);
+   ephysics_body_linear_velocity_set(box_body1, -30, 40, 0);
+   ephysics_body_sleeping_threshold_set(box_body1, 0.1, 0.1);
+   test_data->bodies = eina_list_append(test_data->bodies, box_body1);
+
+   sh2 = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      sh2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-cube");
+   evas_object_move(sh2, WIDTH / 2 - 80, FLOOR_Y);
+   evas_object_resize(sh2, 70, 3);
+   evas_object_show(sh2);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sh2);
+
+   box2 = elm_image_add(test_data->win);
+   elm_image_file_set(
+      box2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "purple-cube");
+   evas_object_move(box2, WIDTH / 2 + 10, FLOOR_Y - 200);
+   evas_object_resize(box2, 70, 70);
+   evas_object_show(box2);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, box2);
+
+   box_body2 = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(box_body2, box2, EINA_TRUE);
+   ephysics_body_event_callback_add(box_body2, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh2);
+   ephysics_body_restitution_set(box_body2, 0.7);
+   ephysics_body_friction_set(box_body2, 0);
+   ephysics_body_linear_velocity_set(box_body2, 40, -30, 0);
+   ephysics_body_angular_velocity_set(box_body2, 0, 0, 36);
+   ephysics_body_sleeping_threshold_set(box_body2, 0.1, 0.1);
+   test_data->bodies = eina_list_append(test_data->bodies, box_body2);
+   test_data->data = box_body2;
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_no_gravity(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+   Evas_Object *bt;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "No Gravity", EINA_TRUE);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+
+   bt = elm_button_add(test_data->win);
+   elm_object_style_set(bt, "ephysics-test-stop");
+   elm_layout_content_set(test_data->layout, "extra_button", bt);
+   evas_object_smart_callback_add(bt, "clicked", _stop, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   test_data->world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 1);
+   ephysics_body_friction_set(boundary, 0);
+
+   boundary = ephysics_body_top_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 1);
+   ephysics_body_friction_set(boundary, 0);
+
+   boundary = ephysics_body_left_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 1);
+   ephysics_body_friction_set(boundary, 0);
+
+   boundary = ephysics_body_right_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 1);
+   ephysics_body_friction_set(boundary, 0);
+
+   _world_populate(test_data);
+   ephysics_world_gravity_set(world, 0, 0, 0);
+}
diff --git a/src/examples/ephysics/test_rotating_forever.c b/src/examples/ephysics/test_rotating_forever.c
new file mode 100644
index 0000000000..f0445887bd
--- /dev/null
+++ b/src/examples/ephysics/test_rotating_forever.c
@@ -0,0 +1,206 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static Eina_Bool
+_rotate_cb(void *data)
+{
+   EPhysics_Quaternion *quat_prev, quat_delta, quat;
+   EPhysics_Body *body = data;
+
+   quat_prev = ephysics_body_rotation_get(body, NULL);
+   ephysics_quaternion_set(&quat_delta, 0, 0, -0.15, 0.98);
+   ephysics_quaternion_normalize(&quat_delta);
+   ephysics_body_rotation_set(
+      body, ephysics_quaternion_multiply(&quat_delta, quat_prev, &quat));
+   free(quat_prev);
+
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_increase_torque_cb(void *data)
+{
+   EPhysics_Body *body = data;
+   Evas_Object *obj;
+
+   ephysics_body_torque_apply(body, 0, 0, 2);
+   obj = ephysics_body_evas_object_get(body);
+   evas_object_data_set(obj, "increase_timer", NULL);
+
+   return EINA_FALSE;
+}
+
+static Eina_Bool
+_stop_torque_cb(void *data)
+{
+   EPhysics_Body *body = data;
+   Evas_Object *obj;
+
+   ephysics_body_forces_clear(body);
+   obj = ephysics_body_evas_object_get(body);
+   evas_object_data_set(obj, "stop_timer", NULL);
+
+   return EINA_FALSE;
+}
+
+static void
+_del_cb(void *data, EPhysics_Body *body __UNUSED__, void *event_info __UNUSED__)
+{
+   ecore_timer_del(data);
+}
+
+static void
+_del_torque_cb(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
+{
+   Ecore_Timer *timer;
+
+   timer = evas_object_data_get(obj, "increase_timer");
+   if (timer)
+     ecore_timer_del(timer);
+
+   timer = evas_object_data_get(obj, "stop_timer");
+   if (timer)
+     ecore_timer_del(timer);
+}
+
+static void
+_update_object_cb(void *data __UNUSED__, EPhysics_Body *body, void *event_info __UNUSED__)
+{
+   double rx, ry, rz, rw, vrot, torque;
+   EPhysics_Quaternion quat;
+
+   ephysics_body_angular_velocity_get(body, NULL, NULL, &vrot);
+   ephysics_body_torques_get(body, NULL, NULL, &torque);
+
+   ephysics_body_rotation_get(body, &quat);
+   ephysics_quaternion_get(&quat, &rx, &ry, &rz, &rw);
+
+   ephysics_body_evas_object_update(body);
+
+   DBG("body: %p, rot: (%lf, %lf, %lf, %lf), vrot: %lf, torque: %lf", body,
+       rx, ry, rz, rw, vrot, torque);
+}
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   EPhysics_Body *body;
+   Ecore_Timer *timer;
+   Evas_Object *cube;
+
+   cube = elm_image_add(test_data->win);
+   elm_image_file_set(
+      cube, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "blue-cube");
+   evas_object_move(cube, WIDTH / 3, HEIGHT / 2 - 30);
+   evas_object_resize(cube, 70, 70);
+   evas_object_show(cube);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, cube);
+
+   body = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(body, cube, EINA_TRUE);
+   test_data->bodies = eina_list_append(test_data->bodies, body);
+   ephysics_body_event_callback_add(body,
+                                    EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    _update_object_cb, NULL);
+
+   ephysics_body_torque_impulse_apply(body, 0, 0, 1);
+
+   cube = elm_image_add(test_data->win);
+   elm_image_file_set(
+      cube, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "purple-cube");
+   evas_object_move(cube, WIDTH / 3, FLOOR_Y - 70);
+   evas_object_resize(cube, 70, 70);
+   evas_object_show(cube);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, cube);
+
+   body = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(body, cube, EINA_TRUE);
+   test_data->bodies = eina_list_append(test_data->bodies, body);
+   ephysics_body_event_callback_add(body,
+                                    EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    _update_object_cb, NULL);
+
+   ephysics_body_impulse_apply(body, 30, 0, 0, 0, -10, 0);
+
+   cube = elm_image_add(test_data->win);
+   elm_image_file_set(
+      cube, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "purple-cube");
+   evas_object_move(cube, WIDTH / 3, 60);
+   evas_object_resize(cube, 70, 70);
+   evas_object_show(cube);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, cube);
+
+   body = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(body, cube, EINA_TRUE);
+   test_data->bodies = eina_list_append(test_data->bodies, body);
+   ephysics_body_event_callback_add(body,
+                                    EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    _update_object_cb, NULL);
+
+   timer = ecore_timer_add(1, _rotate_cb, body);
+
+   ephysics_body_event_callback_add(body,
+                                    EPHYSICS_CALLBACK_BODY_DEL,
+                                    _del_cb, timer);
+
+   cube = elm_image_add(test_data->win);
+   elm_image_file_set(
+      cube, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "blue-cube");
+   evas_object_move(cube, WIDTH * 2 / 3, 60);
+   evas_object_resize(cube, 70, 70);
+   evas_object_show(cube);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, cube);
+
+   body = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(body, cube, EINA_TRUE);
+   test_data->bodies = eina_list_append(test_data->bodies, body);
+   ephysics_body_event_callback_add(body,
+                                    EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    _update_object_cb, NULL);
+
+   ephysics_body_torque_apply(body, 0, 0, 2);
+   evas_object_event_callback_add(cube, EVAS_CALLBACK_DEL,
+                                  _del_torque_cb, NULL);
+
+   timer = ecore_timer_add(3, _increase_torque_cb, body);
+   evas_object_data_set(cube, "increase_timer", timer);
+   timer = ecore_timer_add(5, _stop_torque_cb, body);
+   evas_object_data_set(cube, "stop_timer", timer);
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_rotating_forever(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Rotating Forever", EINA_TRUE);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   test_data->world = world;
+   ephysics_world_gravity_set(world, 0, 0, 0);
+
+   _world_populate(test_data);
+}
diff --git a/src/examples/ephysics/test_shapes.c b/src/examples/ephysics/test_shapes.c
new file mode 100644
index 0000000000..8b01222211
--- /dev/null
+++ b/src/examples/ephysics/test_shapes.c
@@ -0,0 +1,110 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   EPhysics_Shape *pentagon_shape, *hexagon_shape;
+   EPhysics_Body *pentagon_body, *hexagon_body;
+   Evas_Object *pentagon, *hexagon;
+
+   pentagon = elm_image_add(test_data->win);
+   elm_image_file_set(
+      pentagon, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "pentagon");
+   evas_object_move(pentagon, WIDTH / 3, HEIGHT / 2 - 80);
+   evas_object_resize(pentagon, 70, 68);
+   evas_object_show(pentagon);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, pentagon);
+
+   pentagon_shape = ephysics_shape_new();
+   ephysics_shape_point_add(pentagon_shape, -1, -9/33., -1);
+   ephysics_shape_point_add(pentagon_shape, -1, -9/33., 1);
+   ephysics_shape_point_add(pentagon_shape, 0, -1, -1);
+   ephysics_shape_point_add(pentagon_shape, 0, -1, 1);
+   ephysics_shape_point_add(pentagon_shape, 1, -9/33., -1);
+   ephysics_shape_point_add(pentagon_shape, 1, -9/33., 1);
+   ephysics_shape_point_add(pentagon_shape, -21/35., 1, -1);
+   ephysics_shape_point_add(pentagon_shape, -21/35., 1, 1);
+   ephysics_shape_point_add(pentagon_shape, 21/35., 1, -1);
+   ephysics_shape_point_add(pentagon_shape, 21/35., 1, 1);
+
+   pentagon_body = ephysics_body_shape_add(test_data->world, pentagon_shape);
+   ephysics_body_evas_object_set(pentagon_body, pentagon, EINA_TRUE);
+   ephysics_body_restitution_set(pentagon_body, 1);
+   test_data->bodies = eina_list_append(test_data->bodies, pentagon_body);
+
+   hexagon = elm_image_add(test_data->win);
+   elm_image_file_set(
+      hexagon, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "hexagon");
+   evas_object_move(hexagon, WIDTH / 3 + 100, HEIGHT / 2 - 100);
+   evas_object_resize(hexagon, 70, 60);
+   evas_object_show(hexagon);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, hexagon);
+
+   hexagon_shape = ephysics_shape_new();
+   ephysics_shape_point_add(hexagon_shape, 0, 30, -10);
+   ephysics_shape_point_add(hexagon_shape, 0, 30, 10);
+   ephysics_shape_point_add(hexagon_shape, 18, 0, -10);
+   ephysics_shape_point_add(hexagon_shape, 18, 0, 10);
+   ephysics_shape_point_add(hexagon_shape, 52, 0, -10);
+   ephysics_shape_point_add(hexagon_shape, 52, 0, 10);
+   ephysics_shape_point_add(hexagon_shape, 70, 30, -10);
+   ephysics_shape_point_add(hexagon_shape, 70, 30, 10);
+   ephysics_shape_point_add(hexagon_shape, 52, 60, -10);
+   ephysics_shape_point_add(hexagon_shape, 52, 60, 10);
+   ephysics_shape_point_add(hexagon_shape, 18, 60, -10);
+   ephysics_shape_point_add(hexagon_shape, 18, 60, 10);
+
+   hexagon_body = ephysics_body_shape_add(test_data->world, hexagon_shape);
+   ephysics_body_evas_object_set(hexagon_body, hexagon, EINA_TRUE);
+   ephysics_body_restitution_set(hexagon_body, 1);
+   test_data->bodies = eina_list_append(test_data->bodies, hexagon_body);
+   ephysics_body_torque_apply(hexagon_body, 0, 0, -3);
+
+   ephysics_shape_del(pentagon_shape);
+   ephysics_shape_del(hexagon_shape);
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_shapes(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Shapes", EINA_TRUE);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   test_data->world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.65);
+
+   ephysics_body_top_boundary_add(test_data->world);
+   ephysics_body_left_boundary_add(test_data->world);
+   ephysics_body_right_boundary_add(test_data->world);
+
+   _world_populate(test_data);
+}
diff --git a/src/examples/ephysics/test_sleeping_threshold.c b/src/examples/ephysics/test_sleeping_threshold.c
new file mode 100644
index 0000000000..e6b2d513ed
--- /dev/null
+++ b/src/examples/ephysics/test_sleeping_threshold.c
@@ -0,0 +1,119 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   Evas_Object *sphere1, *sphere2, *sh1, *sh2;
+   EPhysics_Body *sphere_body1, *sphere_body2;
+   double linear, angular;
+
+   sh1 = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      sh1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-ball");
+   evas_object_move(sh1, 50, FLOOR_Y);
+   evas_object_resize(sh1, 70, 3);
+   evas_object_show(sh1);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sh1);
+
+   sphere1 = elm_image_add(test_data->win);
+   elm_image_file_set(sphere1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+                      "big-blue-ball");
+   evas_object_move(sphere1, 50, FLOOR_Y - 70);
+   evas_object_resize(sphere1, 70, 70);
+   evas_object_show(sphere1);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sphere1);
+
+   sphere_body1 = ephysics_body_sphere_add(test_data->world);
+   ephysics_body_evas_object_set(sphere_body1, sphere1, EINA_TRUE);
+   ephysics_body_event_callback_add(sphere_body1,
+                                    EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh1);
+   ephysics_body_restitution_set(sphere_body1, 1);
+   ephysics_body_friction_set(sphere_body1, 0.4);
+   ephysics_body_sleeping_threshold_set(sphere_body1, 60, 360);
+   ephysics_body_linear_velocity_set(sphere_body1, 100, 0, 0);
+   ephysics_body_damping_set(sphere_body1, 0.5, 0.5);
+   test_data->bodies = eina_list_append(test_data->bodies, sphere_body1);
+
+   sh2 = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      sh2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-ball");
+   evas_object_move(sh2, WIDTH - 120, FLOOR_Y);
+   evas_object_resize(sh2, 70, 3);
+   evas_object_show(sh2);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sh2);
+
+   sphere2 = elm_image_add(test_data->win);
+   elm_image_file_set(sphere2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj",
+                      "big-red-ball");
+   evas_object_move(sphere2, WIDTH - 120, FLOOR_Y - 70);
+   evas_object_resize(sphere2, 70, 70);
+   evas_object_show(sphere2);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sphere2);
+
+   sphere_body2 = ephysics_body_sphere_add(test_data->world);
+   ephysics_body_evas_object_set(sphere_body2, sphere2, EINA_TRUE);
+   ephysics_body_event_callback_add(sphere_body2,
+                                    EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh2);
+   ephysics_body_restitution_set(sphere_body2, 1);
+   ephysics_body_friction_set(sphere_body2, 0.4);
+   ephysics_body_sleeping_threshold_set(sphere_body2, 10, 360);
+   ephysics_body_linear_velocity_set(sphere_body2, -100, 0, 0);
+   ephysics_body_damping_set(sphere_body2, 0.5, 0.5);
+   test_data->bodies = eina_list_append(test_data->bodies, sphere_body2);
+
+   ephysics_body_sleeping_threshold_get(sphere_body1, &linear, &angular);
+   INF("Body 1: linear threshold: %.2f, angular: %.2f", linear, angular);
+   ephysics_body_sleeping_threshold_get(sphere_body2, &linear, &angular);
+   INF("Body 2: linear threshold: %.2f, angular: %.2f", linear, angular);
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_sleeping(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Sleeping Threshold", EINA_TRUE);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart",
+                                  "test-theme", _restart, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   test_data->world = world;
+   ephysics_world_max_sleeping_time_set(world, 0.3);
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0);
+   ephysics_body_friction_set(boundary, 20);
+
+   boundary = ephysics_body_right_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.8);
+
+   ephysics_body_left_boundary_add(test_data->world);
+   ephysics_body_top_boundary_add(test_data->world);
+
+   _world_populate(test_data);
+}
diff --git a/src/examples/ephysics/test_slider.c b/src/examples/ephysics/test_slider.c
new file mode 100644
index 0000000000..f17ca01d7f
--- /dev/null
+++ b/src/examples/ephysics/test_slider.c
@@ -0,0 +1,170 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+static void
+_world_populate(Test_Data *test_data)
+{
+   EPhysics_Body *box_body1, *box_body2, *box_body3, *box_body4;
+   Evas_Object *box1, *box2, *box3, *box4, *sh1, *sh2, *sh3, *sh4;
+   EPhysics_Constraint *constraint;
+
+   sh1 = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      sh1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-cube");
+   evas_object_move(sh1, WIDTH / 6, FLOOR_Y);
+   evas_object_resize(sh1, 70, 3);
+   evas_object_show(sh1);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sh1);
+
+   box1 = elm_image_add(test_data->win);
+   elm_image_file_set(
+      box1, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "blue-cube");
+   evas_object_move(box1, WIDTH / 6, FLOOR_Y - 70);
+   evas_object_resize(box1, 70, 70);
+   evas_object_show(box1);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, box1);
+
+   box_body1 = ephysics_body_box_add(test_data->world);
+   ephysics_body_mass_set(box_body1, 0);
+   ephysics_body_evas_object_set(box_body1, box1, EINA_TRUE);
+   ephysics_body_event_callback_add(box_body1, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh1);
+   ephysics_body_restitution_set(box_body1, 0.3);
+   ephysics_body_friction_set(box_body1, 0.1);
+   test_data->bodies = eina_list_append(test_data->bodies, box_body1);
+
+   sh2 = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      sh2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-cube");
+   evas_object_move(sh2, WIDTH / 6 + 60, FLOOR_Y);
+   evas_object_resize(sh2, 70, 3);
+   evas_object_show(sh2);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sh2);
+
+   box2 = elm_image_add(test_data->win);
+   elm_image_file_set(
+      box2, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "purple-cube");
+   evas_object_move(box2, WIDTH / 6 + 65, HEIGHT / 8);
+   evas_object_resize(box2, 70, 70);
+   evas_object_show(box2);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, box2);
+
+   box_body2 = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(box_body2, box2, EINA_TRUE);
+   ephysics_body_event_callback_add(box_body2, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh2);
+   ephysics_body_restitution_set(box_body2, 0.5);
+   ephysics_body_friction_set(box_body2, 0.1);
+   test_data->bodies = eina_list_append(test_data->bodies, box_body2);
+
+   constraint = ephysics_constraint_add(box_body2);
+   ephysics_constraint_linear_limit_set(constraint, 0, 0, 0,
+                                        HEIGHT - (HEIGHT / 8), 0, 0);
+   ephysics_constraint_angular_limit_set(constraint, 0, 0, 0, 0, 0, 45);
+   test_data->constraints = eina_list_append(test_data->constraints,
+                                             constraint);
+
+   sh3 = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      sh3, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-cube");
+   evas_object_move(sh3, WIDTH / 6 + 60, FLOOR_Y);
+   evas_object_resize(sh3, 70, 3);
+   evas_object_show(sh3);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sh3);
+
+   box3 = elm_image_add(test_data->win);
+   elm_image_file_set(
+      box3, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "blue-cube");
+   evas_object_move(box3, WIDTH - 120, HEIGHT / 8);
+   evas_object_resize(box3, 70, 70);
+   evas_object_show(box3);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, box3);
+
+   box_body3 = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(box_body3, box3, EINA_TRUE);
+   ephysics_body_event_callback_add(box_body3, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh3);
+   ephysics_body_restitution_set(box_body3, 0.5);
+   ephysics_body_friction_set(box_body3, 0.1);
+   test_data->bodies = eina_list_append(test_data->bodies, box_body3);
+
+   constraint = ephysics_constraint_add(box_body3);
+   ephysics_constraint_linear_limit_set(constraint, WIDTH - 120, 0, 0, 0, 0, 0);
+   ephysics_body_central_impulse_apply(box_body3, -240, 0, 0);
+   test_data->constraints = eina_list_append(test_data->constraints,
+                                             constraint);
+
+   sh4 = elm_layout_add(test_data->win);
+   elm_layout_file_set(
+      sh4, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-cube");
+   evas_object_move(sh4, WIDTH / 6 + 60, FLOOR_Y);
+   evas_object_resize(sh4, 70, 3);
+   evas_object_show(sh4);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, sh4);
+
+   box4 = elm_image_add(test_data->win);
+   elm_image_file_set(
+      box4, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "purple-cube");
+   evas_object_move(box4, WIDTH - 120, FLOOR_Y - 70);
+   evas_object_resize(box4, 70, 70);
+   evas_object_show(box4);
+   test_data->evas_objs = eina_list_append(test_data->evas_objs, box4);
+
+   box_body4 = ephysics_body_box_add(test_data->world);
+   ephysics_body_evas_object_set(box_body4, box4, EINA_TRUE);
+   ephysics_body_event_callback_add(box_body4, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, sh4);
+   ephysics_body_restitution_set(box_body4, 0.5);
+   ephysics_body_friction_set(box_body4, 0.1);
+   test_data->bodies = eina_list_append(test_data->bodies, box_body4);
+
+   constraint = ephysics_constraint_add(box_body4);
+   ephysics_constraint_linear_limit_set(constraint, WIDTH / 3, 0, 0, 0, 0, 0);
+   ephysics_body_central_impulse_apply(box_body4, -600, 0, 0);
+   test_data->constraints = eina_list_append(test_data->constraints,
+                                             constraint);
+
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Test_Data *test_data = data;
+
+   DBG("Restart pressed");
+   test_clean(test_data);
+   _world_populate(test_data);
+}
+
+void
+test_slider(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+   Test_Data *test_data;
+
+   if (!ephysics_init())
+     return;
+
+   test_data = test_data_new();
+   test_win_add(test_data, "Slider", EINA_TRUE);
+   elm_object_signal_emit(test_data->layout, "borders,show", "ephysics_test");
+   elm_layout_signal_callback_add(test_data->layout, "restart", "test-theme",
+                                  _restart, test_data);
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   test_data->world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(test_data->world);
+   ephysics_body_restitution_set(boundary, 0.65);
+   ephysics_body_friction_set(boundary, 3);
+
+   ephysics_body_left_boundary_add(test_data->world);
+
+   _world_populate(test_data);
+}
diff --git a/src/examples/ephysics/test_velocity.c b/src/examples/ephysics/test_velocity.c
new file mode 100644
index 0000000000..785767bff1
--- /dev/null
+++ b/src/examples/ephysics/test_velocity.c
@@ -0,0 +1,211 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "ephysics_test.h"
+
+typedef struct _Velocity_Data Velocity_Data;
+
+struct _Velocity_Data {
+     Test_Data base;
+     EPhysics_Body *body;
+     double old_vx;
+     double old_vy;
+     double old_vaz;
+     double last_time;
+};
+
+static Eina_Bool
+_on_keydown(void *data, Evas_Object *obj __UNUSED__, Evas_Object *src __UNUSED__, Evas_Callback_Type type, void *event_info)
+{
+   Evas_Event_Key_Down *ev = event_info;
+   EPhysics_Body *body = data;
+
+   if (type != EVAS_CALLBACK_KEY_UP)
+     return EINA_FALSE;
+
+   if (strcmp(ev->keyname, "Up") == 0)
+     ephysics_body_central_impulse_apply(body, 0, -300, 0);
+   else if (strcmp(ev->keyname, "Down") == 0)
+     ephysics_body_central_impulse_apply(body, 0, 300, 0);
+   else if (strcmp(ev->keyname, "Right") == 0)
+     ephysics_body_central_impulse_apply(body, 300, 0, 0);
+   else if (strcmp(ev->keyname, "Left") == 0)
+     ephysics_body_central_impulse_apply(body, -300, 0, 0);
+
+   return EINA_TRUE;
+}
+
+static void
+_update_vel_cb(void *data, EPhysics_Body *body, void *event_info __UNUSED__)
+{
+   Velocity_Data *velocity_data = data;
+   Eina_Bool first_call = EINA_FALSE;
+   double vx, vy, ax, ay, vaz, aaz;
+   double time_now, delta_time;
+   char buff[64];
+
+   if (!velocity_data->last_time)
+     first_call = EINA_TRUE;
+
+   time_now = ecore_time_get();
+   delta_time = time_now - velocity_data->last_time;
+   velocity_data->last_time = time_now;
+
+   ephysics_body_angular_velocity_get(body, NULL, NULL, &vaz);
+   ephysics_body_linear_velocity_get(body, &vx, &vy, NULL);
+   vx = (vx > 0 || vx <= -0.01) ? vx : 0;
+   vy = (vy > 0 || vy <= -0.01) ? vy : 0;
+
+   aaz = (vaz - velocity_data->old_vaz) / delta_time;
+   velocity_data->old_vaz = vaz;
+   ax = (vx - velocity_data->old_vx) / delta_time;
+   velocity_data->old_vx = vx;
+   ay = (vy - velocity_data->old_vy) / delta_time;
+   velocity_data->old_vy = vy;
+
+   if (first_call) return;
+
+   DBG("Delta Time: %0.3lf", delta_time);
+
+   snprintf(buff, sizeof(buff), "Linear velocity: %.2f, %.2f", vx, vy);
+   elm_layout_text_set(velocity_data->base.layout, "linear_vel", buff);
+   snprintf(buff, sizeof(buff), "Linear acceleration: %.2f, %.2f", ax, ay);
+   elm_layout_text_set(velocity_data->base.layout, "linear_acc", buff);
+   DBG("Vx: %0.3lf p/s Ax: %0.3lf p/s/s", vx, ax);
+   DBG("Vy: %0.3lf p/s Ay: %0.3lf p/s/s", vy, ay);
+
+   snprintf(buff, sizeof(buff), "Angular velocity: %.2f", vaz);
+   elm_layout_text_set(velocity_data->base.layout, "angular_vel", buff);
+   snprintf(buff, sizeof(buff), "Angular acceleration: %.2f", aaz);
+   elm_layout_text_set(velocity_data->base.layout, "angular_acc", buff);
+   DBG("Va: %0.3lf d/s Aa: %0.3lf d/s/s", vaz, aaz);
+}
+
+static void
+_world_populate(Velocity_Data *velocity_data)
+{
+   Evas_Object *sphere, *shadow;
+   EPhysics_Body *sphere_body;
+
+   shadow = elm_layout_add(velocity_data->base.win);
+   elm_layout_file_set(
+      shadow, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "shadow-ball");
+   evas_object_move(shadow, WIDTH / 3, FLOOR_Y);
+   evas_object_resize(shadow, 54, 3);
+   evas_object_show(shadow);
+   velocity_data->base.evas_objs = eina_list_append(
+      velocity_data->base.evas_objs, shadow);
+
+   sphere = elm_image_add(velocity_data->base.win);
+   elm_image_file_set(
+      sphere, PACKAGE_DATA_DIR "/" EPHYSICS_TEST_THEME ".edj", "red-ball");
+   evas_object_move(sphere, WIDTH / 3, FLOOR_Y - 54);
+   evas_object_resize(sphere, 54, 54);
+   evas_object_show(sphere);
+   velocity_data->base.evas_objs = eina_list_append(
+      velocity_data->base.evas_objs, sphere);
+
+   sphere_body = ephysics_body_sphere_add(velocity_data->base.world);
+   ephysics_body_evas_object_set(sphere_body, sphere, EINA_TRUE);
+   ephysics_body_restitution_set(sphere_body, 0.8);
+   ephysics_body_friction_set(sphere_body, 1);
+   ephysics_body_sleeping_threshold_set(sphere_body, 0, 0);
+   ephysics_body_damping_set(sphere_body, 0.2, 0.2);
+   ephysics_body_event_callback_add(sphere_body, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    update_object_cb, shadow);
+   ephysics_body_event_callback_add(sphere_body, EPHYSICS_CALLBACK_BODY_UPDATE,
+                                    _update_vel_cb, velocity_data);
+   ephysics_body_event_callback_add(sphere_body, EPHYSICS_CALLBACK_BODY_STOPPED,
+                                    _update_vel_cb, velocity_data);
+   velocity_data->base.bodies = eina_list_append(velocity_data->base.bodies,
+                                                 sphere_body);
+   velocity_data->body = sphere_body;
+}
+
+static void
+_restart(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
+{
+   Velocity_Data *velocity_data = data;
+
+   elm_object_event_callback_del(velocity_data->base.win, _on_keydown,
+                                 velocity_data->body);
+
+   DBG("Restart pressed");
+   test_clean((Test_Data *)velocity_data);
+   _world_populate(velocity_data);
+   velocity_data->old_vx = 0;
+   velocity_data->old_vy = 0;
+   velocity_data->old_vaz = 0;
+   velocity_data->last_time = 0;
+
+   elm_object_event_callback_add(velocity_data->base.win, _on_keydown,
+                                 velocity_data->body);
+}
+
+static void
+_win_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Velocity_Data *velocity_data = data;
+
+   test_clean((Test_Data *)velocity_data);
+   evas_object_del(velocity_data->base.layout);
+   ephysics_world_del(velocity_data->base.world);
+   free(velocity_data);
+   ephysics_shutdown();
+}
+
+void
+test_velocity(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Velocity_Data *velocity_data;
+   EPhysics_Body *boundary;
+   EPhysics_World *world;
+
+   if (!ephysics_init())
+     return;
+
+   velocity_data = calloc(1, sizeof(Velocity_Data));
+   if (!velocity_data)
+     {
+        ERR("Failed to create test data");
+        ephysics_shutdown();
+        return;
+     }
+
+   test_win_add((Test_Data *)velocity_data, "Velocity Getters", EINA_FALSE);
+   evas_object_event_callback_add(velocity_data->base.win, EVAS_CALLBACK_DEL,
+                                  _win_del, velocity_data);
+   elm_layout_signal_callback_add(velocity_data->base.layout, "restart",
+                                  "test-theme", _restart, velocity_data);
+
+   elm_object_signal_emit(velocity_data->base.layout, "borders,show",
+                          "ephysics_test");
+   elm_object_signal_emit(velocity_data->base.layout, "arrows,show",
+                          "ephysics_test");
+   elm_object_signal_emit(velocity_data->base.layout, "velocity,show",
+                          "ephysics_test");
+
+   world = ephysics_world_new();
+   ephysics_world_render_geometry_set(world, 50, 40, -50,
+                                      WIDTH - 100, FLOOR_Y - 40, DEPTH);
+   velocity_data->base.world = world;
+
+   boundary = ephysics_body_bottom_boundary_add(velocity_data->base.world);
+   ephysics_body_restitution_set(boundary, 0.65);
+   ephysics_body_friction_set(boundary, 4);
+
+   boundary = ephysics_body_right_boundary_add(velocity_data->base.world);
+   ephysics_body_restitution_set(boundary, 0.4);
+   ephysics_body_friction_set(boundary, 3);
+
+   boundary = ephysics_body_left_boundary_add(velocity_data->base.world);
+   ephysics_body_restitution_set(boundary, 0.4);
+   ephysics_body_friction_set(boundary, 3);
+
+   ephysics_body_top_boundary_add(velocity_data->base.world);
+
+   _world_populate(velocity_data);
+   elm_object_event_callback_add(velocity_data->base.win, _on_keydown,
+                                 velocity_data->body);
+}
diff --git a/src/lib/ephysics/EPhysics.h b/src/lib/ephysics/EPhysics.h
new file mode 100644
index 0000000000..90ea09f046
--- /dev/null
+++ b/src/lib/ephysics/EPhysics.h
@@ -0,0 +1,4733 @@
+#ifndef EPHYSICS_H
+#define EPHYSICS_H
+
+/**
+ * @page ephysics_main EPhysics
+ *
+ * @date 2012 (created)
+ *
+ * @section toc Table of Contents
+ *
+ * @li @ref ephysics_main_intro
+ * @li @ref ephysics_main_compiling
+ * @li @ref ephysics_main_next_steps
+ * @li @ref ephysics_main_intro_example
+ *
+ * @section ephysics_main_intro Introduction
+ *
+ * EPhysics is a library that makes it easy to use Ecore, Evas and Bullet
+ * Physics together. It's a kind of wrapper, a glue, between these libraries.
+ * It's not intended to be a physics library (we already have many out there).
+ *
+ * @image html diagram_ephysics.png
+ * @image latex diagram_ephysics.eps
+ *
+ * @section ephysics_main_compiling How to compile
+ *
+ * Ephysics is a library your application links to. The procedure for this is
+ * very simple. You simply have to compile your application with the
+ * appropriate compiler flags that the @c pkg-config script outputs. For
+ * example:
+ *
+ * Compiling C or C++ files into object files:
+ *
+ * @verbatim
+   gcc -c -o main.o main.c `pkg-config --cflags ephysics`
+   @endverbatim
+ *
+ * Linking object files into a binary executable:
+ *
+ * @verbatim
+   gcc -o my_application main.o `pkg-config --libs ephysics`
+   @endverbatim
+ *
+ * See @ref pkgconfig
+ *
+ * @section ephysics_main_next_steps Next Steps
+ *
+ * After you understood what EPhysics is and installed it in your system
+ * you should proceed understanding the programming interface.
+ *
+ * Recommended reading:
+ * @li @ref EPhysics
+ * @li @ref EPhysics_World
+ * @li @ref EPhysics_Body
+ * @li @ref EPhysics_Camera
+ * @li @ref EPhysics_Constraint
+ * @li @ref EPhysics_Quaternion
+ * @li @ref EPhysics_Shape
+ *
+ * @section ephysics_main_intro_example Introductory Example
+ *
+ * @include test_bouncing_ball.c
+ *
+ * More examples can be found at @ref ephysics_examples.
+ */
+
+#include <Evas.h>
+
+#ifdef EAPI
+# undef EAPI
+#endif
+
+#ifdef _WIN32
+# ifdef EFL_EPHYSICS_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EPHYSICS_BUILD */
+#else
+# ifdef __GNUC__
+#  if __GNUC__ >= 4
+#   define EAPI __attribute__ ((visibility("default")))
+#  else
+#   define EAPI
+#  endif
+# else
+#  define EAPI
+# endif
+#endif /* ! _WIN32 */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define EPHYSICS_VERSION_MAJOR 0
+#define EPHYSICS_VERSION_MINOR 1
+
+/**
+ * @file
+ * @brief These routines are used for EPhysics library interaction.
+ */
+
+/**
+ * @brief Physics simulation integration and visual effects.
+ * @defgroup EPhysics EPhysics
+ *
+ * @{
+ *
+ */
+
+/**
+ * Initialize EPhysics
+ *
+ * Initializes Bullet physics engine.
+ *
+ * @return The init counter value.
+ *
+ * @see ephysics_shutdown().
+ *
+ * @ingroup EPhysics
+ */
+EAPI int ephysics_init(void);
+
+/**
+ * Shutdown EPhysics
+ *
+ * Shutdown Bullet physics engine. If init count reaches 0, all the existing
+ * worlds will be deleted, and consequently all the bodies.
+ *
+ * @return EPhysics' init counter value.
+ *
+ * @see ephysics_init().
+ *
+ * @ingroup EPhysics
+ */
+EAPI int ephysics_shutdown(void);
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup EPhysics_Quaternion EPhysics Quaternion
+ * @ingroup EPhysics
+ *
+ * @{
+ *
+ * Quaternions are used to perform linear algebra rotations.
+ *
+ * Functions regarding rotation, like @ref ephysics_body_rotation_set()
+ * and @ref ephysics_body_rotation_get() would need that. Quaternions
+ * can be used to rotate evas maps as well, with evas_map_util_quat_rotate(),
+ * but in this case quaternion values need to be get with
+ * @ref ephysics_quaternion_get(), since evas don't accept
+ * EPhysics_Quaternion type.
+ *
+ * A quaternion can be created with ephysics_quaternion_new(), and many
+ * operations can be performed with that, as:
+ * @li Sum: @ref ephysics_quaternion_sum()
+ * @li Difference: @ref ephysics_quaternion_diff()
+ * @li Multiple by another quaternion: @ref ephysics_quaternion_multiply()
+ * @li Multiply by scalar: @ref ephysics_quaternion_scale()
+ * @li Divide by scalar: @ref ephysics_quaternion_inverse_scale()
+ * @li Calculate length: @ref ephysics_quaternion_length_get()
+ * @li Calculate angle between quaternions: @ref ephysics_quaternion_angle_get()
+ */
+
+/**
+ * @typedef EPhysics_Quaternion
+ *
+ * Quaternion handle, represents a quaternion to be used to rotate bodies.
+ *
+ * Created with @ref ephysics_quaternion_new() and deleted with free().
+ *
+ * @ingroup EPhysics_Quaternion
+ */
+typedef struct _EPhysics_Quaternion EPhysics_Quaternion;
+
+/**
+ * @struct _EPhysics_Quaternion
+ *
+ * Quaternion coordinates and rotation (w, x, y, z)
+ */
+struct _EPhysics_Quaternion
+{
+   double w; /**< rotation */
+   double x; /**< x coordinate */
+   double y; /**< y coordinate */
+   double z; /**< z coordinate */
+};
+
+/**
+ * @brief
+ * Create a new quaternion.
+ *
+ * By default a quaternion is created as identity  (w = 1, x = 0, y = 0, z = 0).
+ * This values can be modified later by quaternion operations or set directly.
+ *
+ * @return The created quaternion or @c NULL on error.
+ *
+ * @note It should be deleted with free() after usage is concluded.
+ *
+ * @see ephysics_quaternion_set();
+ * @see ephysics_quaternion_axis_angle_set();
+ * @see ephysics_quaternion_euler_set();
+ * @see ephysics_quaternion_scale();
+ * @see ephysics_quaternion_sum();
+ *
+ * @ingroup EPhysics_Quaternion
+ */
+EAPI EPhysics_Quaternion *ephysics_quaternion_new(void);
+
+/**
+ * @brief
+ * Get quaternion values.
+ *
+ * @param quat Quaternion to get values from.
+ * @param x The x coordinate.
+ * @param y The y coordinate.
+ * @param z The z coordinate.
+ * @param w The rotation.
+ *
+ * @see ephysics_quaternion_set();
+ *
+ * @ingroup EPhysics_Quaternion
+ */
+EAPI void ephysics_quaternion_get(const EPhysics_Quaternion *quat, double *x, double *y, double *z, double *w);
+