efl/legacy/ephysics/src/lib/ephysics_body.cpp

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <Evas.h>
#include <Ecore.h>
#include <BulletCollision/CollisionShapes/btShapeHull.h>
#include <LinearMath/btGeometryUtil.h>

#include <math.h>

#include "ephysics_private.h"
#include "ephysics_trimesh.h"
#include "ephysics_body_materials.h"

#ifdef  __cplusplus
extern "C" {
#endif

#define SHAPE_BOX "Box"
#define SHAPE_CYLINDER "CylinderZ"

typedef struct _EPhysics_Body_Callback EPhysics_Body_Callback;
typedef struct _EPhysics_Body_Evas_Stacking EPhysics_Body_Evas_Stacking;
typedef struct _EPhysics_Body_Soft_Body_Slice EPhysics_Body_Soft_Body_Slice;
typedef struct _EPhysics_Body_Face_Obj EPhysics_Body_Face_Obj;

struct _EPhysics_Body_Callback {
     EINA_INLIST;
     void (*func) (void *data, EPhysics_Body *body, void *event_info);
     void *data;
     EPhysics_Callback_Body_Type type;
     Eina_Bool deleted:1;
};

struct _EPhysics_Body_Collision {
     EPhysics_Body *contact_body;
     Evas_Coord x;
     Evas_Coord y;
     Evas_Coord z;
};

struct _EPhysics_Body_Evas_Stacking {
     Evas_Object *evas;
     float stacking;
};

struct _EPhysics_Body_Soft_Body_Slice
{
     Evas_Object *evas_obj;
     int index;
     struct {
          double x;
          double y;
     } p[3];
     float stacking;
};

struct _EPhysics_Body_Face_Obj {
    EPhysics_Body_Face face;
    Evas_Object *obj;
};

static void
_ephysics_body_soft_body_slices_apply(EPhysics_Body *body)
{
   double rate;
   void *list_data;
   Eina_List *l;
   Evas_Coord wy, wh, y0, y1, y2, x0, x1, x2, z0, z1, z2, w, h;
   Evas_Map *map;
   btVector3 p0, p1, p2;
   btSoftBody::tFaceArray faces;
   EPhysics_Body_Soft_Body_Slice *slice;
   int lr, lg, lb, ar, ag, ab;
   Evas_Coord lx, ly, lz;
   Eina_Bool light = EINA_FALSE;
   EPhysics_Camera *camera;
   int px, py, pz, foc;
   Eina_Bool perspective = EINA_FALSE;

   camera = ephysics_world_camera_get(body->world);
   rate = ephysics_world_rate_get(body->world);
   ephysics_world_render_geometry_get(body->world, NULL, &wy, NULL, NULL, &wh,
                                      NULL);
   evas_object_geometry_get(body->evas_obj, NULL, NULL, &w, &h);

   if ((body->light_apply) ||
       (ephysics_world_light_all_bodies_get(body->world)))
     {
        ephysics_world_point_light_position_get(body->world, &lx, &ly, &lz);
        ephysics_world_point_light_color_get(body->world, &lr, &lg, &lb);
        ephysics_world_ambient_light_color_get(body->world, &ar, &ag, &ab);
        light = EINA_TRUE;
     }

   if (ephysics_camera_perspective_enabled_get(camera))
     {
        ephysics_camera_perspective_get(camera, &px, &py, &pz, &foc);
        perspective = EINA_TRUE;
     }

   EINA_LIST_FOREACH(body->slices_list, l, list_data)
     {
        slice = (EPhysics_Body_Soft_Body_Slice *)list_data;

        faces = body->soft_body->m_faces;
        p0 = faces[slice->index].m_n[0]->m_x;
        p1 = faces[slice->index].m_n[1]->m_x;
        p2 = faces[slice->index].m_n[2]->m_x;

        slice->stacking = p0.z() + p1.z() + p2.z();

        map = evas_map_new(4);

        evas_map_point_image_uv_set(map, 0, slice->p[0].x * w,
                                    slice->p[0].y * h);
        evas_map_point_image_uv_set(map, 1, slice->p[1].x * w,
                                    slice->p[1].y * h);
        evas_map_point_image_uv_set(map, 2, slice->p[2].x * w,
                                    slice->p[2].y * h);
        evas_map_point_image_uv_set(map, 3, slice->p[2].x * w,
                                    slice->p[2].y * h);

        x0 = p0.x() * rate;
        x1 = p1.x() * rate;
        x2 = p2.x() * rate;

        y0 = wh + wy - (p0.y() * rate);
        y1 = wh + wy - (p1.y() * rate);
        y2 = wh + wy - (p2.y() * rate);

        z0 = p0.z() * rate;
        z1 = p1.z() * rate;
        z2 = p2.z() * rate;

        evas_map_point_coord_set(map, 0, x0, y0, z0);
        evas_map_point_coord_set(map, 1, x1, y1, z1);
        evas_map_point_coord_set(map, 2, x2, y2, z2);
        evas_map_point_coord_set(map, 3, x2, y2, z2);

        if (perspective)
          evas_map_util_3d_perspective(map, px, py, pz, foc);

        if (body->back_face_culling)
          {
             if (evas_map_util_clockwise_get(map))
                  evas_object_show(slice->evas_obj);
             else
               {
                  evas_map_free(map);
                  evas_object_hide(slice->evas_obj);
                  continue;
               }
          }

        if (light)
          evas_map_util_3d_lighting(map, lx, ly, lz, lr, lg, lb, ar, ag, ab);

        evas_object_map_set(slice->evas_obj, map);
        evas_object_map_enable_set(slice->evas_obj, EINA_TRUE);
        evas_map_free(map);
     }
}

static inline double
_ephysics_body_soft_body_slice_calc(double val, double delta, double max)
{
   double ret = val + delta / max;
   if (ret < 0)
     ret = 0;
   else if (ret > 1)
     ret = 1;
   return ret;
}

static EPhysics_Body_Soft_Body_Slice *
_ephysics_body_soft_body_slice_new(EPhysics_Body *body, double delta, double max, int index)
{
   EPhysics_Body_Soft_Body_Slice *slice;
   btSoftBody::tFaceArray faces;

   slice = (EPhysics_Body_Soft_Body_Slice *)calloc(
      1, sizeof(EPhysics_Body_Soft_Body_Slice));
   if (!slice)
     {
        ERR("Couldn't allocate EPhysics_Soft_Body_Slice memory.");
        return NULL;
     }

   faces = body->soft_body->m_faces;

   slice->index = index;
   slice->p[0].x = _ephysics_body_soft_body_slice_calc(
      faces[slice->index].m_n[0]->m_x.x(), delta, max);
   slice->p[0].y = 1 - _ephysics_body_soft_body_slice_calc(
      faces[slice->index].m_n[0]->m_x.y(), delta, max);
   slice->p[1].x = _ephysics_body_soft_body_slice_calc(
      faces[slice->index].m_n[1]->m_x.x(), delta, max);
   slice->p[1].y = 1 - _ephysics_body_soft_body_slice_calc(
      faces[slice->index].m_n[1]->m_x.y(), delta, max);
   slice->p[2].x = _ephysics_body_soft_body_slice_calc(
      faces[slice->index].m_n[2]->m_x.x(), delta, max);
   slice->p[2].y = 1 - _ephysics_body_soft_body_slice_calc(
      faces[slice->index].m_n[2]->m_x.y(), delta, max);

   return slice;
}

static void
_ephysics_body_soft_body_slices_init(EPhysics_Body *body)
{
   EPhysics_Body_Soft_Body_Slice *slice = NULL;
   btVector3 p0, p1, p2;
   void *slice_data;
   Evas_Coord w, h;
   Eina_List *l;
   Evas *evas;

   evas = evas_object_evas_get(body->evas_obj);
   evas_object_geometry_get(body->evas_obj, NULL, NULL, &w, &h);

   EINA_LIST_FOREACH(body->slices_list, l, slice_data)
     {
        slice = (EPhysics_Body_Soft_Body_Slice *) slice_data;
        slice->evas_obj = evas_object_image_filled_add(evas);
        evas_object_layer_set(slice->evas_obj,
                              evas_object_layer_get(body->evas_obj));
        evas_object_image_source_set(slice->evas_obj, body->evas_obj);
        evas_object_image_source_events_set(slice->evas_obj, EINA_TRUE);
        evas_object_resize(slice->evas_obj, w, h);
        evas_object_show(slice->evas_obj);
        evas_object_image_smooth_scale_set(slice->evas_obj, EINA_TRUE);
     }

   if (slice)
     evas_object_image_source_visible_set(slice->evas_obj, EINA_FALSE);

   _ephysics_body_soft_body_slices_apply(body);
}

static void
_ephysics_body_soft_body_slices_clean(EPhysics_Body *body)
{
   EPhysics_Body_Soft_Body_Slice *slice;
   void *slice_data;
   Eina_List *l;

   EINA_LIST_FOREACH(body->slices_list, l, slice_data)
     {
        slice = (EPhysics_Body_Soft_Body_Slice *)slice_data;
        evas_object_del(slice->evas_obj);
        slice->evas_obj = NULL;
     }
}

static btTransform
_ephysics_body_transform_get(const EPhysics_Body *body)
{
   btTransform trans;
   btVector3 center;
   btScalar radius;

   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     {
        body->rigid_body->getMotionState()->getWorldTransform(trans);
        return trans;
     }

   body->soft_body->getCollisionShape()->getBoundingSphere(center, radius);
   trans.setIdentity();
   trans.setOrigin(center);
   return trans;
}

static int
_ephysics_body_evas_stacking_sort_cb(const void *d1, const void *d2)
{
   const EPhysics_Body_Evas_Stacking *stacking1, *stacking2;

   stacking1 = (const EPhysics_Body_Evas_Stacking *)d1;
   stacking2 = (const EPhysics_Body_Evas_Stacking *)d2;

   if (!stacking1) return 1;
   if (!stacking2) return -1;

   if (stacking1->stacking < stacking2->stacking) return -1;
   if (stacking2->stacking > stacking2->stacking) return 1;

   return 0;
}

static void
_ephysics_body_evas_objects_restack_free(void *data)
{
   Eina_List *l, *stack_list = (Eina_List *)data;
   void *ldata;

   EINA_LIST_FOREACH(stack_list, l, ldata)
     free(ldata);

   eina_list_free(stack_list);
}

static EPhysics_Body_Evas_Stacking *
_ephysics_body_evas_stacking_new(Evas_Object *obj, float index)
{
   EPhysics_Body_Evas_Stacking *stacking;

   stacking = (EPhysics_Body_Evas_Stacking *)calloc(
                1, sizeof(EPhysics_Body_Evas_Stacking));

   if (!stacking)
     {
        ERR("Could not allocate ephysics soft body evas stacking data.");
        return NULL;
     }

   stacking->evas = obj;
   stacking->stacking = index;
   return stacking;
}

void
ephysics_body_evas_objects_restack(EPhysics_World *world)
{
   void *data, *slice_data, *stack_data;
   EPhysics_Body *body;
   btTransform trans;
   EPhysics_Body_Evas_Stacking *stacking;
   EPhysics_Body_Soft_Body_Slice *slice;
   Eina_List *l, *slices, *bodies, *stack_list = NULL;
   Evas_Object *prev_obj = NULL;
   Eina_Hash *hash;
   Eina_Iterator *it;
   int layer;
   Eina_Bool previously_added;

   bodies = ephysics_world_bodies_get(world);

   if (!eina_list_count(bodies))
     return;

   hash = eina_hash_int32_new(_ephysics_body_evas_objects_restack_free);

   EINA_LIST_FOREACH(bodies, l, data)
     {
        body = (EPhysics_Body *)data;
        if (body->deleted) continue;
        previously_added = EINA_FALSE;

        if (body->type == EPHYSICS_BODY_TYPE_RIGID)
          {
             if (!body->evas_obj) continue;
             trans = _ephysics_body_transform_get(body);
             stacking = _ephysics_body_evas_stacking_new(body->evas_obj,
                                                         trans.getOrigin().z());
             if (!stacking) goto error;

             layer = evas_object_layer_get(stacking->evas);
             stack_list = (Eina_List *)eina_hash_find(hash, &layer);

             if (stack_list)
               previously_added = EINA_TRUE;

             stack_list = eina_list_append(stack_list, stacking);

             if (!previously_added)
               eina_hash_add(hash, &layer, stack_list);

             continue;
          }

        if (!body->slices_list) continue;

        EINA_LIST_FOREACH(body->slices_list, slices, slice_data)
          {
             previously_added = EINA_FALSE;
             slice = (EPhysics_Body_Soft_Body_Slice *)slice_data;

             stacking = _ephysics_body_evas_stacking_new(slice->evas_obj,
                                                         slice->stacking);
             if (!stacking) goto error;

             layer = evas_object_layer_get(stacking->evas);
             stack_list = (Eina_List *)eina_hash_find(hash, &layer);

             if (stack_list)
               previously_added = EINA_TRUE;

             stack_list = eina_list_append(stack_list, stacking);

             if (!previously_added)
               eina_hash_add(hash, &layer, stack_list);
          }
     }


   it = eina_hash_iterator_data_new(hash);
   while (eina_iterator_next(it, &data))
     {
        stack_list = (Eina_List *)data;
        stack_list = eina_list_sort(stack_list, eina_list_count(stack_list),
                                    _ephysics_body_evas_stacking_sort_cb);
        prev_obj = NULL;

        EINA_LIST_FOREACH(stack_list, l, stack_data)
          {
             stacking = (EPhysics_Body_Evas_Stacking *)stack_data;

             if (prev_obj)
               evas_object_stack_below(stacking->evas, prev_obj);

             prev_obj = stacking->evas;
          }
     }

   eina_iterator_free(it);
   eina_hash_free(hash);
   return;

 error:
   ERR("Could not allocate evas stacking data memory.");
   eina_hash_free(hash);
}

static void
_ephysics_body_transform_set(EPhysics_Body *body, btTransform trans)
{
   btTransform origin;
   btTransform dest;

   if (body->type == EPHYSICS_BODY_TYPE_CLOTH)
     {
        origin = _ephysics_body_transform_get(body);
        dest.setIdentity();
        dest.setOrigin(trans.getOrigin() / origin.getOrigin());
        body->soft_body->translate(trans.getOrigin() - origin.getOrigin());
        return;
     }
   body->rigid_body->getMotionState()->setWorldTransform(trans);
}

void
ephysics_body_activate(const EPhysics_Body *body, Eina_Bool activate)
{
   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     {
        body->rigid_body->activate(activate);
        return;
     }

   body->soft_body->activate(activate);
}

static void
_ephysics_body_forces_update(EPhysics_Body *body)
{
   body->force.x = body->rigid_body->getTotalForce().getX();
   body->force.y = body->rigid_body->getTotalForce().getY();
   body->force.z = body->rigid_body->getTotalForce().getZ();
   body->force.torque_x = body->rigid_body->getTotalTorque().getX();
   body->force.torque_y = body->rigid_body->getTotalTorque().getY();
   body->force.torque_z = body->rigid_body->getTotalTorque().getZ();
   body->rigid_body->clearForces();
}

static inline void
_ephysics_body_sleeping_threshold_set(EPhysics_Body *body, double linear_threshold, double angular_threshold, double rate)
{
   body->rigid_body->setSleepingThresholds(linear_threshold / rate,
                                           angular_threshold / RAD_TO_DEG);
}

static inline void
_ephysics_body_linear_velocity_set(EPhysics_Body *body, double x, double y, double z, double rate)
{
   ephysics_body_activate(body, EINA_TRUE);
   body->rigid_body->setLinearVelocity(btVector3(x / rate, -y / rate,
                                                 z / rate));
}

static void
_ephysics_body_event_callback_del(EPhysics_Body *body, EPhysics_Body_Callback *cb)
{
   if (cb->deleted) return;

   cb->deleted = EINA_TRUE;

   if (body->walking)
     {
        body->to_delete = eina_list_append(body->to_delete, cb);
        return;
     }

   body->callbacks = eina_inlist_remove(body->callbacks, EINA_INLIST_GET(cb));
   free(cb);
}

static Eina_Bool
_ephysics_body_event_callback_call(EPhysics_Body *body, EPhysics_Callback_Body_Type type, void *event_info)
{
   Eina_Bool called = EINA_FALSE;
   EPhysics_Body_Callback *cb;
   void *clb;

   body->walking++;
   EINA_INLIST_FOREACH(body->callbacks, cb)
     {
        if ((cb->type == type) && (!cb->deleted))
          {
             cb->func(cb->data, body, event_info);
             called = EINA_TRUE;
          }
     }
   body->walking--;

   if (body->walking > 0) return called;

   EINA_LIST_FREE(body->to_delete, clb)
     {
        cb = (EPhysics_Body_Callback *) clb;
        body->callbacks = eina_inlist_remove(body->callbacks,
                                             EINA_INLIST_GET(cb));
        free(cb);
     }

   return called;
}

void
ephysics_body_active_set(EPhysics_Body *body, Eina_Bool active)
{
   if (body->active == !!active) return;
   body->active = !!active;
   if (active) return;

   _ephysics_body_event_callback_call(body, EPHYSICS_CALLBACK_BODY_STOPPED,
                                      (void *) body->evas_obj);
};

Eina_Bool
ephysics_body_filter_collision(EPhysics_Body *body0, EPhysics_Body *body1)
{
   Eina_List *l;
   void *grp;

   if ((!body0->collision_groups) || (!body1->collision_groups))
     return EINA_TRUE;

   EINA_LIST_FOREACH(body0->collision_groups, l, grp)
     {
        if (eina_list_data_find(body1->collision_groups, grp))
          return EINA_TRUE;
     }

   return EINA_FALSE;
}

EAPI Eina_Bool
ephysics_body_collision_group_add(EPhysics_Body *body, const char *group)
{
   Eina_Stringshare *group_str;

   if (!body)
     {
        ERR("Can't add body collision group, body is null.");
        return EINA_FALSE;
     }

   ephysics_world_lock_take(body->world);
   group_str = eina_stringshare_add(group);
   if (eina_list_data_find(body->collision_groups, group_str))
     {
        INF("Body already added to group: %s", group);
        eina_stringshare_del(group_str);
        ephysics_world_lock_release(body->world);
        return EINA_TRUE;
     }

   body->collision_groups = eina_list_append(body->collision_groups, group_str);
   ephysics_world_lock_release(body->world);
   return EINA_TRUE;
}

EAPI Eina_Bool
ephysics_body_collision_group_del(EPhysics_Body *body, const char *group)
{
   Eina_Stringshare *group_str;

   if (!body)
     {
        ERR("Can't remove body collision group, body is null.");
        return EINA_FALSE;
     }

   ephysics_world_lock_take(body->world);
   group_str = eina_stringshare_add(group);
   if (!eina_list_data_find(body->collision_groups, group_str))
     {
        INF("Body isn't part of group: %s", group);
        eina_stringshare_del(group_str);
        ephysics_world_lock_release(body->world);
        return EINA_TRUE;
     }

   body->collision_groups = eina_list_remove(body->collision_groups, group_str);
   eina_stringshare_del(group_str);
   eina_stringshare_del(group_str);
   ephysics_world_lock_release(body->world);
   return EINA_TRUE;
}

EAPI const Eina_List *
ephysics_body_collision_group_list_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't get the body's collision group, body is null.");
        return NULL;
     }

   return body->collision_groups;
}

static EPhysics_Body *
_ephysics_body_new(EPhysics_World *world, btScalar mass, double cm_x, double cm_y, double cm_z)
{
   EPhysics_Body *body;
   double rate;

   body = (EPhysics_Body *) calloc(1, sizeof(EPhysics_Body));
   if (!body)
     {
        ERR("Couldn't create a new body instance.");
        return NULL;
     }

   rate = ephysics_world_rate_get(world);
   body->scale = btVector3(1, 1, 1);
   body->size.w = rate;
   body->size.h = rate;
   body->size.d = rate;
   body->mass = mass;
   body->world = world;
   body->cm.x = cm_x;
   body->cm.y = cm_y;
   body->cm.z = cm_z;

   return body;
}

static EPhysics_Body *
_ephysics_body_rigid_body_add(EPhysics_World *world, btCollisionShape *collision_shape, const char *type, double cm_x, double cm_y, double cm_z)
{
   btRigidBody::btRigidBodyConstructionInfo *rigid_body_ci;
   btDefaultMotionState *motion_state;
   btRigidBody *rigid_body;
   EPhysics_Body *body;
   btScalar mass = 1;
   btVector3 inertia;

   if (!collision_shape)
     {
        ERR("Couldn't create a %s shape.", type);
        return NULL;
     }

   body = _ephysics_body_new(world, mass, cm_x, cm_y, cm_z);
   if (!body)
     {
        ERR("Couldn't create a new body instance.");
        goto err_body;
     }

   motion_state = new btDefaultMotionState();
   if (!motion_state)
     {
        ERR("Couldn't create a motion state.");
        goto err_motion_state;
     }

   inertia = btVector3(0, 0, 0);
   collision_shape->calculateLocalInertia(mass, inertia);

   rigid_body_ci = new btRigidBody::btRigidBodyConstructionInfo(
      mass, motion_state, collision_shape, inertia);
   if (!rigid_body_ci)
     {
        ERR("Couldn't create a rigid body construction info.");
        goto err_rigid_body_ci;
     }

   rigid_body = new btRigidBody(*rigid_body_ci);
   if (!rigid_body)
     {
        ERR("Couldn't create a rigid body.");
        goto err_rigid_body;
     }

   body->type = EPHYSICS_BODY_TYPE_RIGID;
   body->collision_shape = collision_shape;
   body->rigid_body = rigid_body;
   body->rigid_body->setUserPointer(body);
   body->rigid_body->setLinearFactor(btVector3(1, 1, 0));
   body->rigid_body->setAngularFactor(btVector3(0, 0, 1));

   if (!ephysics_world_body_add(body->world, body))
     {
        ERR("Couldn't add body to world's bodies list");
        goto err_world_add;
     }

   delete rigid_body_ci;

   INF("Body %p of type %s added.", body, type);
   return body;

err_world_add:
   delete rigid_body;
err_rigid_body:
   delete rigid_body_ci;
err_rigid_body_ci:
   delete motion_state;
err_motion_state:
   free(body);
err_body:
   delete collision_shape;
   return NULL;
}

static void
_ephysics_body_evas_obj_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
{
   EPhysics_Body *body = (EPhysics_Body *) data;
   _ephysics_body_soft_body_slices_clean(body);
   body->evas_obj = NULL;
   DBG("Evas object deleted. Updating body: %p", body);
}

static void
_ephysics_body_soft_body_anchors_rebuild(int node, btRigidBody *rigid_body, btSoftBody *soft_body)
{
   btTransform world_trans = rigid_body->getWorldTransform();
   btVector3 local = world_trans.inverse() * soft_body->m_nodes[node].m_x;

   for (int i = 0; i < soft_body->m_anchors.size(); i++)
     {
        if (soft_body->m_anchors[i].m_node == &soft_body->m_nodes[node])
          soft_body->m_anchors[i].m_local = local;
     }
}

static void
_ephysics_body_cloth_constraints_rebuild(EPhysics_Body *body)
{
   btRigidBody *rigid_body;
   btSoftBody *soft_body;
   btSoftBody::Node *node;
   btSoftBody::Anchor anchor;
   int anchors_size = body->soft_body->m_anchors.size();

   soft_body = body->soft_body;

   if (anchors_size)
     {
        rigid_body = soft_body->m_anchors[0].m_body;
        for (int m = 0; m < anchors_size; m++)
          {
             anchor = soft_body->m_anchors[m];
             node = anchor.m_node;
             for (int n = 0; n < soft_body->m_nodes.size(); n++)
               {
                  if (node == &soft_body->m_nodes[n])
                    _ephysics_body_soft_body_anchors_rebuild(n, rigid_body,
                                                             soft_body);
               }
          }
     }
   soft_body->generateClusters(0);
   soft_body->generateBendingConstraints(2, soft_body->m_materials[
                                                          body->material_index]);
}

static void
_ephysics_body_soft_body_constraints_rebuild(EPhysics_Body *body)
{
   btSoftBody *soft_body = body->soft_body;
   btRigidBody *rigid_body = body->rigid_body;

   if (soft_body->m_anchors.size() > 0)
     {
        for (int i = 0; i < soft_body->m_nodes.size(); i++)
          _ephysics_body_soft_body_anchors_rebuild(i, rigid_body, soft_body);
     }
   else
     {
        for (int i = 0; i < soft_body->m_nodes.size(); i++)
          soft_body->appendAnchor(i, rigid_body);
     }

   soft_body->generateClusters(0);
   soft_body->generateBendingConstraints(10, soft_body->m_materials[
                                                          body->material_index]);
}

inline static double
_ephysics_body_volume_get(const EPhysics_Body *body)
{
   btVector3 vector = body->collision_shape->getLocalScaling();
   return vector.x() * vector.y() * vector.z();
}

void
_ephysics_body_soft_body_dragging_set(EPhysics_Body *body, int triangle)
{
   btSoftBody::Face face;
   btSoftBody::Node *node;

   body->dragging_data.triangle = triangle;
   body->dragging_data.dragging = EINA_TRUE;

   face = body->soft_body->m_faces[triangle];
   for (int i = 0; i < 3; i++)
     {
        node = face.m_n[i];
        body->dragging_data.mass[i] = node->m_im;
     }
}

static void
_ephysics_body_soft_body_mass_set(EPhysics_Body *body, double mass)
{
   int valid_nodes;
   btSoftBody::Node node;
   double inverse_mass;

   if (body->type == EPHYSICS_BODY_TYPE_SOFT)
        body->soft_body->setTotalMass(mass);
   else
     {
        valid_nodes = 0;
        for (int i = 0; i < body->soft_body->m_nodes.size(); i++)
          {
             node = body->soft_body->m_nodes[i];
             if (node.m_im && !node.m_battach)
               valid_nodes++;
          }

        inverse_mass = 1 / (mass / valid_nodes);
        if (body->dragging_data.dragging)
          {
             valid_nodes++;
             inverse_mass = 1 / (mass / valid_nodes);
             for (int i = 0; i < 3; i++)
               body->dragging_data.mass[i] = inverse_mass;
          }

        for (int i = 0; i < body->soft_body->m_nodes.size(); i++)
          {
             node = body->soft_body->m_nodes[i];
             if (node.m_im && !node.m_battach)
                  node.m_im = inverse_mass;
          }
     }
}

static void
_ephysics_body_mass_set(EPhysics_Body *body, double mass)
{
   btVector3 inertia(0, 0, 0);

   if (body->density)
     mass = body->density * _ephysics_body_volume_get(body);

   if (body->soft_body)
     _ephysics_body_soft_body_mass_set(body, mass);
   else
     {
        body->collision_shape->calculateLocalInertia(mass, inertia);
        body->rigid_body->setMassProps(mass, inertia);
        body->rigid_body->updateInertiaTensor();
     }

   body->mass = mass;
   DBG("Body %p mass changed to %lf.", body, mass);
}

static void
_ephysics_body_resize(EPhysics_Body *body, Evas_Coord w, Evas_Coord h, Evas_Coord d)
{
   double rate, sx, sy, sz;

   rate = ephysics_world_rate_get(body->world);
   sx = w / rate;
   sy = h / rate;
   sz = d / rate;

   if (body->soft_body)
     {
        body->soft_body->scale(btVector3(sx, sy, sz));
        _ephysics_body_soft_body_constraints_rebuild(body);
     }
   else
     {
        body->collision_shape->setLocalScaling(btVector3(sx, sy, sz));

        if(!body->rigid_body->isStaticObject())
          _ephysics_body_mass_set(body, ephysics_body_mass_get(body));
     }

   body->size.w = w;
   body->size.h = h;
   body->size.d = d;
   body->scale = btVector3(sx, sy, sz);

   ephysics_body_activate(body, EINA_TRUE);

   DBG("Body %p scale changed to (%lf, %lf, %lf).", body, sx, sy, sz);
}

static void
_ephysics_body_move(EPhysics_Body *body, Evas_Coord x, Evas_Coord y, Evas_Coord z)
{
   double rate, mx, my, mz;
   btTransform trans;
   int wy, height;
   btVector3 body_scale;

   rate = ephysics_world_rate_get(body->world);
   ephysics_world_render_geometry_get(body->world, NULL, &wy, NULL,
                                      NULL, &height, NULL);
   height += wy;

   mx = (x + body->size.w * body->cm.x) / rate;
   my = (height - (y + body->size.h * body->cm.y)) / rate;
   mz = (z + body->size.d * body->cm.z) / rate;

   trans = _ephysics_body_transform_get(body);
   trans.setOrigin(btVector3(mx, my, mz));

   if (body->type == EPHYSICS_BODY_TYPE_CLOTH)
     _ephysics_body_transform_set(body, trans);
   else
     {
        body->rigid_body->proceedToTransform(trans);
        body->rigid_body->getMotionState()->setWorldTransform(trans);
     }

   ephysics_body_activate(body, EINA_TRUE);

   DBG("Body %p position changed to (%lf, %lf, %lf).", body, mx, my, mz);
}

static void
_ephysics_body_geometry_set(EPhysics_Body *body, Evas_Coord x, Evas_Coord y, Evas_Coord z, Evas_Coord w, Evas_Coord h, Evas_Coord d, double rate)
{
   double mx, my, mz, sx, sy, sz;
   btTransform trans;
   int wy, height;
   btVector3 body_scale;

   ephysics_world_render_geometry_get(body->world, NULL, &wy, NULL,
                                      NULL, &height, NULL);
   height += wy;

   mx = (x + w * body->cm.x) / rate;
   my = (height - (y + h * body->cm.y)) / rate;
   mz = (z + d * body->cm.z) / rate;
   sx = w / rate;
   sy = h / rate;
   sz = d / rate;

   trans = _ephysics_body_transform_get(body);
   trans.setOrigin(btVector3(mx, my, mz));
   body_scale = btVector3(sx, sy, sz);

   if (body->type == EPHYSICS_BODY_TYPE_SOFT)
     {
        body->soft_body->scale(body_scale);
        body->soft_body->getCollisionShape()->setLocalScaling(body_scale);
        body->rigid_body->proceedToTransform(trans);
        body->soft_body->transform(trans);
        _ephysics_body_soft_body_constraints_rebuild(body);
     }
   else if (body->type == EPHYSICS_BODY_TYPE_CLOTH)
     {
        body->soft_body->scale(body_scale);
        _ephysics_body_transform_set(body, trans);
        _ephysics_body_cloth_constraints_rebuild(body);
     }
   else
     {
        body->collision_shape->setLocalScaling(body_scale);
        body->rigid_body->proceedToTransform(trans);

        if (!body->rigid_body->isStaticObject())
          _ephysics_body_mass_set(body, ephysics_body_mass_get(body));
     }

   _ephysics_body_transform_set(body, trans);
   ephysics_body_activate(body, EINA_TRUE);

   body->size.w = w;
   body->size.h = h;
   body->size.d = d;
   body->scale = body_scale;

   DBG("Body %p position changed to (%lf, %lf, %lf).", body, mx, my, mz);
   DBG("Body %p scale changed to (%lf, %lf, %lf).", body, sx, sy, sz);
}

static void
_ephysics_body_evas_obj_resize_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
{
   EPhysics_Body *body = (EPhysics_Body *) data;
   int w, h;

   evas_object_geometry_get(obj, NULL, NULL, &w, &h);
   if ((w == body->size.w) && (h == body->size.h))
     return;

   DBG("Resizing body %p to w=%i, h=%i, d=%i", body, w, h, body->size.d);
   ephysics_world_lock_take(body->world);
   _ephysics_body_resize(body, w, h, body->size.d);
   ephysics_world_lock_release(body->world);
}

static void
_ephysics_body_del(EPhysics_Body *body)
{
   EPhysics_Body_Callback *cb;
   void *group;

   if (body->evas_obj)
     {
        evas_object_event_callback_del(body->evas_obj, EVAS_CALLBACK_DEL,
                                       _ephysics_body_evas_obj_del_cb);
        evas_object_event_callback_del(body->evas_obj, EVAS_CALLBACK_RESIZE,
                                       _ephysics_body_evas_obj_resize_cb);
     }

   while (body->callbacks)
     {
        cb = EINA_INLIST_CONTAINER_GET(body->callbacks,
                                       EPhysics_Body_Callback);
        body->callbacks = eina_inlist_remove(body->callbacks, body->callbacks);
        free(cb);
     }

   EINA_LIST_FREE(body->collision_groups, group)
      eina_stringshare_del((Eina_Stringshare *)group);

   free(body->points_deform);

   if (body->rigid_body)
     {
        delete body->rigid_body->getMotionState();
        delete body->collision_shape;
        delete body->rigid_body;
     }

   delete body->soft_body;

   free(body);
}

static void
_ephysics_cloth_face_objs_update(EPhysics_Body *body __UNUSED__)
{

}

static void
_ephysics_cylinder_face_objs_update(EPhysics_Body *body __UNUSED__)
{

}

static void
_ephysics_box_face_objs_update(EPhysics_Body *body)
{
}

static void
_ephysics_body_evas_object_default_update(EPhysics_Body *body)
{
   int x, y, z, w, h, wx, wy, wh, cx, cy;
   EPhysics_Camera *camera;
   btTransform trans;
   btQuaternion quat;
   Evas_Map *map;
   double rate;

   if (body->face_objs)
     {
        if (body->type == EPHYSICS_BODY_TYPE_CLOTH)
          _ephysics_cloth_face_objs_update(body);
        else if (body->type == EPHYSICS_BODY_TYPE_RIGID)
          {
             if (!(strcmp(body->collision_shape->getName(), SHAPE_CYLINDER)))
               _ephysics_cylinder_face_objs_update(body);
             else if (!(strcmp(body->collision_shape->getName(), SHAPE_BOX)))
               _ephysics_box_face_objs_update(body);
          }
     }

   if (!body->evas_obj)
     return;

   trans = _ephysics_body_transform_get(body);
   ephysics_world_render_geometry_get(body->world, &wx, &wy, NULL,
                                      NULL, &wh, NULL);
   camera = ephysics_world_camera_get(body->world);
   ephysics_camera_position_get(camera, &cx, &cy);
   cx -= wx;
   cy -= wy;

   evas_object_geometry_get(body->evas_obj, NULL, NULL, &w, &h);
   rate = ephysics_world_rate_get(body->world);
   x = (int) (trans.getOrigin().getX() * rate) - w * body->cm.x - cx;
   y = wh + wy - (int) (trans.getOrigin().getY() * rate) - h * body->cm.y - cy;
   z = (int) (trans.getOrigin().getZ() * rate);

   evas_object_move(body->evas_obj, x, y);

   if ((!w) || (!h))
     {
        DBG("Evas object with no geometry: %p, w=%i h=%i", body->evas_obj,
            w, h);
        return;
     }

   if (body->type != EPHYSICS_BODY_TYPE_RIGID)
     {
        _ephysics_body_soft_body_slices_apply(body);
        return;
     }

   map = evas_map_new(4);
   evas_map_util_points_populate_from_object(map, body->evas_obj);

   quat = trans.getRotation();
   quat.normalize();
   evas_map_util_quat_rotate(map, quat.x(), quat.y(), quat.z(), -quat.w(),
                             x + (w * body->cm.x), y + (h * body->cm.y), z);

   if (ephysics_camera_perspective_enabled_get(camera))
     {
        int px, py, z0, foc;
        ephysics_camera_perspective_get(camera, &px, &py, &z0, &foc);
        evas_map_util_3d_perspective(map, px, py, z0, foc);
     }

   if (body->back_face_culling)
     {
        if (evas_map_util_clockwise_get(map))
          {
             body->clockwise = EINA_TRUE;
             evas_object_show(body->evas_obj);
          }
        else
          {
             body->clockwise = EINA_FALSE;
             evas_map_free(map);
             evas_object_hide(body->evas_obj);
             return;
          }
     }

   if ((body->light_apply) ||
       (ephysics_world_light_all_bodies_get(body->world)))
     {
        int lr, lg, lb, ar, ag, ab;
        Evas_Coord lx, ly, lz;

        ephysics_world_point_light_position_get(body->world, &lx, &ly, &lz);
        ephysics_world_point_light_color_get(body->world, &lr, &lg, &lb);
        ephysics_world_ambient_light_color_get(body->world, &ar, &ag, &ab);
        evas_map_util_3d_lighting(map, lx, ly, lz, lr, lg, lb, ar, ag, ab);
     }

   evas_object_map_set(body->evas_obj, map);
   evas_object_map_enable_set(body->evas_obj, EINA_TRUE);
   evas_map_free(map);
}

static void
_ephysics_body_outside_render_area_check(EPhysics_Body *body)
{
   int wx, wy, wz, ww, wh, wd, bx, by, bz, bw, bh, bd;

   ephysics_world_render_geometry_get(body->world, &wx, &wy, &wz,
                                      &ww, &wh, &wd);
   ephysics_body_geometry_get(body, &bx, &by, &bz, &bw, &bh, &bd);

   // FIXME: check what should be done regarding rotated bodies
   if (((ephysics_world_bodies_outside_top_autodel_get(body->world)) &&
        (by + bh < wy)) ||
       ((ephysics_world_bodies_outside_bottom_autodel_get(body->world)) &&
        (by > wy + wh)) ||
       ((ephysics_world_bodies_outside_left_autodel_get(body->world)) &&
        (bx + bh < wx)) ||
       ((ephysics_world_bodies_outside_right_autodel_get(body->world)) &&
        (bx > wx + ww)) ||
       ((ephysics_world_bodies_outside_front_autodel_get(body->world)) &&
        (bz + bd < wz)) ||
       ((ephysics_world_bodies_outside_back_autodel_get(body->world)) &&
        (bz > wz + wd)))
     {
        DBG("Body %p out of render area", body);
        ephysics_body_del(body);
     }
}

void
ephysics_body_forces_apply(EPhysics_Body *body)
{
   double rate;

   if (!((body->force.x) || (body->force.y) || (body->force.z) ||
         (body->force.torque_x) || (body->force.torque_y) ||
         (body->force.torque_z)))
       return;

   rate = ephysics_world_rate_get(body->world);
   ephysics_body_activate(body, EINA_TRUE);
   body->rigid_body->applyCentralForce(btVector3(body->force.x / rate,
                                                 body->force.y / rate,
                                                 body->force.z / rate));
   body->rigid_body->applyTorque(btVector3(body->force.torque_x,
                                           body->force.torque_y,
                                           body->force.torque_z));
}

void
ephysics_body_recalc(EPhysics_Body *body, double rate)
{
   Evas_Coord x, y, z, w, h, d;
   double vx, vy, vz, lt, at;

   ephysics_body_geometry_get(body, &x, &y, &z, &w, &h, &d);
   ephysics_body_linear_velocity_get(body, &vx, &vy, &vz);
   ephysics_body_sleeping_threshold_get(body, &lt, &at);

   _ephysics_body_geometry_set(body, x, y, z, w, h, d, rate);
   _ephysics_body_linear_velocity_set(body, vx, vy, vz, rate);
   _ephysics_body_sleeping_threshold_set(body, lt, at, rate);
}

void
ephysics_body_evas_object_update_select(EPhysics_Body *body)
{
   Eina_Bool callback_called = EINA_FALSE;

   if (!body || body->deleted)
     return;

   callback_called = _ephysics_body_event_callback_call(
      body, EPHYSICS_CALLBACK_BODY_UPDATE, (void *) body->evas_obj);

   if (!callback_called)
     _ephysics_body_evas_object_default_update(body);

   if (ephysics_world_bodies_outside_autodel_get(body->world))
     _ephysics_body_outside_render_area_check(body);
}

EAPI void
ephysics_body_collision_position_get(const EPhysics_Body_Collision *collision, Evas_Coord *x, Evas_Coord *y, Evas_Coord *z)
{
   if (!collision)
     {
        ERR("Can't get body's collision data, collision is null.");
        return;
     }

   if (x) *x = collision->x;
   if (y) *y = collision->y;
   if (z) *z = collision->z;
}

EAPI EPhysics_Body *
ephysics_body_collision_contact_body_get(const EPhysics_Body_Collision *collision)
{
   if (!collision)
     {
        ERR("Can't get body's collision contact body, collision is null.");
        return NULL;
     }

   return collision->contact_body;
}

void
ephysics_body_contact_processed(EPhysics_Body *body, EPhysics_Body *contact_body, btVector3 position)
{
   EPhysics_Body_Collision *collision;
   EPhysics_World *world;;
   double rate;
   int wy, wh;

   if ((!body) || (!contact_body) || (body->collision_cb < 1))
     return;

   collision = (EPhysics_Body_Collision *)calloc(
      1, sizeof(EPhysics_Body_Collision));

   if (!collision)
     {
        ERR("Can't allocate collision data structure.");
        return;
     }

   world = contact_body->world;
   ephysics_world_render_geometry_get(world, NULL, &wy, NULL, NULL, &wh, NULL);
   rate = ephysics_world_rate_get(world);

   collision->contact_body = contact_body;
   collision->x = position.getX() * rate;
   collision->y = wh + wy - (position.getY() * rate);
   collision->z = position.getZ() * rate;

   _ephysics_body_event_callback_call(body, EPHYSICS_CALLBACK_BODY_COLLISION,
                                      (void *) collision);

   free(collision);
}

btRigidBody *
ephysics_body_rigid_body_get(const EPhysics_Body *body)
{
   return body->rigid_body;
}

btSoftBody *
ephysics_body_soft_body_get(const EPhysics_Body *body)
{
   return body->soft_body;
}

static void
_ephysics_body_soft_body_hardness_set(EPhysics_Body *body, double hardness)
{
   int m = body->material_index;
   btSoftBody *soft_body = body->soft_body;

   if (body->type == EPHYSICS_BODY_TYPE_CLOTH)
     soft_body->m_cfg.kAHR = 0.8;
   else
     soft_body->m_cfg.kAHR = (hardness / 1000) * 0.6;

   soft_body->m_materials[m]->m_kVST = (hardness / 1000);
   soft_body->m_materials[m]->m_kLST = (hardness / 1000);
   soft_body->m_materials[m]->m_kAST = (hardness / 1000);
   DBG("Soft body %p hardness set to %lf.", body, hardness);
}

EAPI void
ephysics_body_soft_body_hardness_set(EPhysics_Body *body, double hardness)
{
   if (!body)
     {
        ERR("Can't set soft body's hardness, body is null.");
        return;
     }

   if (!body->soft_body)
     {
        ERR("Can't set soft body's hardness, body seems not to be a soft body.");
        return;
     }

   if (hardness < 0 || hardness > 100)
     {
        ERR("Can't set soft body's hardness, it must be between 0 and 100.");
        return;
     }

   ephysics_world_lock_take(body->world);
   _ephysics_body_soft_body_hardness_set(body, hardness);
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_soft_body_dragging_set(EPhysics_Body *body, int triangle)
{
   if (!body)
     {
        ERR("Can't set soft body dragging status, body is null.");
        return;
     }

   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     {
        ERR("Can set soft body dragging status, body must not be a rigid body.");
        return;
     }

   if (triangle < 0 || triangle >= body->soft_body->m_faces.size())
     {
        ERR("Could not move soft body triangle, provided body triangle index "
            "ranges from 0 to %d", body->soft_body->m_faces.size());
        return;
     }

   ephysics_world_lock_take(body->world);
   _ephysics_body_soft_body_dragging_set(body, triangle);
   ephysics_world_lock_release(body->world);

   DBG("Body %p appended to world's dragging bodies list.", body);
}

EAPI void
ephysics_body_soft_body_dragging_unset(EPhysics_Body *body)
{
   btSoftBody::Face face;
   btSoftBody::Node *node;

   if (!body)
     {
        ERR("Can't unset soft body dragging status, body is null.");
        return;
     }

   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     {
        ERR("Can unset soft body dragging status, body must not be a rigid"
            " body.");
        return;
     }

   if (!body->dragging_data.dragging)
     {
        INF("Dragging isn't set");
        return;
     }

   ephysics_world_lock_take(body->world);
   face = body->soft_body->m_faces[body->dragging_data.triangle];
   for (int i = 0; i < 3; i++)
     {
        node = face.m_n[i];
        node->m_im = body->dragging_data.mass[i];
        body->dragging_data.mass[i] = 0;
     }

   body->dragging_data.dragging = EINA_FALSE;
   body->dragging_data.triangle = 0;
   ephysics_world_lock_release(body->world);
}

EAPI double
ephysics_body_soft_body_hardness_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't get soft body's hardness, body is null.");
        return 0;
     }

   if (!body->soft_body)
     {
        ERR("Can't get soft body's hardness, body seems not to be a soft body.");
        return 0;
     }

   return (body->soft_body->m_materials[body->material_index]->m_kVST * 100);
}

static void
_ephysics_body_soft_body_default_config(EPhysics_Body *body, btSoftBody *soft_body)
{
   body->soft_body = soft_body;
   body->soft_body->getCollisionShape()->setMargin(btScalar(0.02));
   body->soft_body->setUserPointer(body);
   body->soft_body->setTotalMass(body->mass);

   body->soft_body->m_cfg.collisions += btSoftBody::fCollision::SDF_RS;
   body->soft_body->m_cfg.collisions += btSoftBody::fCollision::VF_SS;
   _ephysics_body_soft_body_hardness_set(body, 100);
}

static EPhysics_Body *
_ephysics_body_soft_body_add(EPhysics_World *world, btCollisionShape *collision_shape, btSoftBody *soft_body)
{
   EPhysics_Body *body;

   body = _ephysics_body_rigid_body_add(world, collision_shape, "soft box", 0.5,
                                        0.5, 0.5);
   if (!body)
     {
        if (body->deleted) return NULL;
        body->deleted = EINA_TRUE;
        ephysics_world_body_del(body->world, body);
        return NULL;
     }

   body->material_index = 0;
   body->type = EPHYSICS_BODY_TYPE_SOFT;
   _ephysics_body_soft_body_default_config(body, soft_body);

   body->rigid_body->setCollisionFlags(
      btCollisionObject::CF_NO_CONTACT_RESPONSE);

   _ephysics_body_soft_body_constraints_rebuild(body);
   ephysics_world_soft_body_add(world, body);

   return body;
}

EAPI void
ephysics_body_cloth_anchor_full_add(EPhysics_Body *body1, EPhysics_Body *body2, EPhysics_Body_Cloth_Anchor_Side side)
{
   int rows;
   int columns;
   double anchor_mass;

   if (!body1 || !body2)
     {
        ERR("Could not add anchors, body1 or body2 is null");
        return;
     }

   if (body1->type != EPHYSICS_BODY_TYPE_CLOTH ||
       body2->type != EPHYSICS_BODY_TYPE_RIGID)
     {
        ERR("Cloth anchors are allowed only between cloth and rigid body.");
        return;
     }

   if ((side < 0) || (side >= EPHYSICS_BODY_CLOTH_ANCHOR_SIDE_LAST))
     {
        ERR("Could not add anchors, side is invalid.");
        return;
     }

   rows = body1->cloth_rows + 1;
   columns = body1->cloth_columns + 1;
   anchor_mass = body1->soft_body->m_nodes.size() * 0.025;

   if (side == EPHYSICS_BODY_CLOTH_ANCHOR_SIDE_RIGHT)
     {
        for (int i = 0; i < rows; i++)
          {
             body1->soft_body->setMass(i, anchor_mass);
             body1->soft_body->appendAnchor(i, body2->rigid_body);
          }
        return;
     }

   if (side == EPHYSICS_BODY_CLOTH_ANCHOR_SIDE_LEFT)
     {
        for (int i = 1; i <= rows; i++)
          {
             body1->soft_body->setMass((rows * columns) - i, anchor_mass);
             body1->soft_body->appendAnchor((rows * columns) - i,
                                            body2->rigid_body);
          }
        return;
     }

   if (side == EPHYSICS_BODY_CLOTH_ANCHOR_SIDE_BOTTOM)
     {
        for (int i = 0; i <= rows; i++)
          {
             body1->soft_body->setMass((i * rows), anchor_mass);
             body1->soft_body->appendAnchor(i * rows, body2->rigid_body);
          }
        return;
     }

   if (side == EPHYSICS_BODY_CLOTH_ANCHOR_SIDE_TOP)
     {
        for (int i = 0; i < columns; i++)
          {
             body1->soft_body->setMass((rows - 1) + rows * i, anchor_mass);
             body1->soft_body->appendAnchor((rows - 1) + rows * i,
                                           body2->rigid_body);
          }
     }
}

EAPI void
ephysics_body_cloth_anchor_add(EPhysics_Body *body1, EPhysics_Body *body2, int node)
{
   if (!body1 || !body2)
     {
        ERR("Could not add anchors, body1 or body2 is null");
        return;
     }

   if (body1->type != EPHYSICS_BODY_TYPE_CLOTH ||
       body2->type != EPHYSICS_BODY_TYPE_RIGID)
     {
        ERR("Cloth anchors are allowed only between cloth and rigid body.");
        return;
     }

   body1->soft_body->appendAnchor(node, body2->rigid_body);
}

EAPI void
ephysics_body_cloth_anchor_del(EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Could not delete anchor, body is null.");
        return;
     }

   if (body->type != EPHYSICS_BODY_TYPE_CLOTH)
     {
        ERR("Could not delete anchors, body is not a cloth.");
        return;
     }

   body->soft_body->m_anchors.resize(0);
}

static Eina_Bool
_ephysics_body_slices_add(EPhysics_Body *body, double delta, double max)
{
   EPhysics_Body_Soft_Body_Slice *slice;
   btSoftBody::tFaceArray faces;

   for (int i = 0; i < body->slices; i++)
     {
        faces = body->soft_body->m_faces;

        slice = _ephysics_body_soft_body_slice_new(body, delta, max,
                                                   body->points_deform[i]);
        if (!slice) return EINA_FALSE;

        body->slices_list = eina_list_append(body->slices_list, slice);
     }
   return EINA_TRUE;
}

EAPI void
ephysics_body_soft_body_position_iterations_set(EPhysics_Body *body, int iterations)
{
   if (!body)
     {
        ERR("Could not set the number of iterations for position solver, body "
            "is null.");
        return;
     }

   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     {
        ERR("Could not set the number of iterations for position solver, body "
            "must be a soft body or a cloth");
        return;
     }

   body->soft_body->m_cfg.piterations = iterations;
   DBG("Soft body position solver iterations set to: %d", iterations);
}

EAPI int
ephysics_body_soft_body_position_iterations_get(EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Could not get the number of iterations for position solver, body "
            "is null.");
        return 0;
     }

   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     {
        ERR("Could not get the number of iterations for position solver, body "
            "must be a soft body or a cloth");
        return 0;
     }

   return body->soft_body->m_cfg.piterations;
}

EAPI EPhysics_Body *
ephysics_body_cloth_add(EPhysics_World *world, unsigned short rows, unsigned short columns)
{
   EPhysics_Body *body;
   btSoftBodyWorldInfo *world_info;
   btSoftBody *soft_body;
   const int body_rows = (!rows) ? 15 : rows;
   const int body_columns = (!columns) ? 15 : columns;

   if (!world)
     {
        ERR("Can't add circle, world is null.");
        return NULL;
     }

   world_info = ephysics_world_info_get(world);
   soft_body = btSoftBodyHelpers::CreatePatch(*world_info,
                                              btVector3(2, 2, 0),
                                              btVector3(2, 1, 0),
                                              btVector3(1, 2, 0),
                                              btVector3(1, 1, 0),
                                              body_rows + 1, body_columns + 1,
                                              0, false);

   if (!soft_body)
     {
        ERR("Couldn't create a new soft body.");
        return NULL;
     }

   body = _ephysics_body_new(world, 1, 0.5, 0.5, 0.5);
   if (!body)
     goto no_body;

   soft_body->setPose(false, true);

   soft_body->appendMaterial();
   body->material_index = 1;
   soft_body->m_cfg.piterations = body_rows / 5;

   _ephysics_body_soft_body_default_config(body, soft_body);
   _ephysics_body_cloth_constraints_rebuild(body);

   body->slices = soft_body->m_faces.size();
   body->points_deform = (int *)malloc(body->slices * sizeof(int));
   if (!body->points_deform)
     {
        ERR("Couldn't create points of deformation.");
        goto no_deform;
     }

   for (int i = 0; i < body->slices; i++)
     body->points_deform[i] = i;

   if (!_ephysics_body_slices_add(body, -1, 1))
     {
        ERR("Couldn't create slices.");
        goto no_slices;
     }

   body->cloth_columns = body_columns;
   body->cloth_rows = body_rows;
   body->type = EPHYSICS_BODY_TYPE_CLOTH;

   ephysics_world_soft_body_add(world, body);

   return body;

no_slices:
   free(body->points_deform);
no_deform:
   free(body);
no_body:
   delete soft_body;
   return NULL;
}

static void
_ephysics_body_soft_body_single_face_transform(btSoftBody *soft_body, int face_idx, int node_idx, btTransform trans)
{
   btSoftBody::Node *node;
   ATTRIBUTE_ALIGNED16(btDbvtVolume) vol;
   const btScalar margin = soft_body->getCollisionShape()->getMargin();

   node = soft_body->m_faces[face_idx].m_n[node_idx];

   if (node->m_battach)
     return;

   node->m_x = trans * node->m_x;
   node->m_q = trans * node->m_q;
   node->m_n = trans.getBasis() * node->m_n;
   vol = btDbvtVolume::FromCR(node->m_x, margin);
   soft_body->m_ndbvt.update(node->m_leaf, vol);
}

void
ephysics_body_soft_body_dragging_apply(EPhysics_Body *body)
{
   btSoftBody::Face face;
   btSoftBody::Node *node;

   face = body->soft_body->m_faces[body->dragging_data.triangle];
   for (int i = 0; i < 3; i++)
     {
        node = face.m_n[i];
        node->m_v *= 0;
        node->m_im *= 0;
     }
}

EAPI void
ephysics_body_soft_body_triangle_move(EPhysics_Body *body, int idx, Evas_Coord x, Evas_Coord y, Evas_Coord z)
{
   btScalar xx, yy, zz;
   Evas_Coord wh;
   double rate;
   btVector3 new_pos;
   btTransform diff;
   btSoftBody::Face face;
   btSoftBody::Node *node;

   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     {
        ERR("Could not move soft body triangle, body must be soft or cloth.");
        return;
     }

   if (idx < 0 || idx >= body->soft_body->m_faces.size())
     {
        ERR("Could not move soft body triangle, provided body triangle index "
            "ranges from 0 to %d", body->soft_body->m_faces.size());
        return;
     }

   rate = ephysics_world_rate_get(body->world);
   ephysics_world_render_geometry_get(body->world, NULL, NULL, NULL, NULL, &wh,
                                      NULL);

   xx = x / rate;
   yy = (wh -  y) / rate;
   zz = z / rate;

   new_pos = btVector3(xx, yy, zz);
   ephysics_world_lock_take(body->world);

   face = body->soft_body->m_faces[idx];
   for (int i = 0; i < 3; i++)
     {
        node = face.m_n[i];
        diff.setIdentity();
        diff.setOrigin(new_pos - node->m_x);
        _ephysics_body_soft_body_single_face_transform(body->soft_body, idx, i,
                                                       diff);

        if (!i) continue;

        diff.setOrigin(diff.getOrigin() * 0.1);
        for (int m = 0; m < body->soft_body->m_faces.size(); m++)
          {
             if (m == idx) continue;
             _ephysics_body_soft_body_single_face_transform(body->soft_body, m,
                                                            i, diff);
          }
     }

   body->soft_body->updateClusters();
   body->soft_body->updateBounds();
   body->soft_body->updateNormals();
   body->soft_body->updatePose();
   ephysics_world_lock_release(body->world);
}

EAPI int
ephysics_body_soft_body_triangle_index_get(EPhysics_Body *body, Evas_Coord x, Evas_Coord y)
{
   int w, h, r, c, index = -1;

   if (!body->evas_obj)
     {
        ERR("No evas object associated to body");
        return -1;
     }

   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     {
        ERR("Can't get node index, operation not permited to rigid bodies");
        return -1;
     }

   if (body->type == EPHYSICS_BODY_TYPE_SOFT)
     {
        ERR("Can't get node index, not implemented for soft bodies yet.");
        return -1;
     }

   evas_object_geometry_get(body->evas_obj, NULL, NULL, &w, &h);
   r = y * body->cloth_rows / h;
   c = (w - x) * body->cloth_columns / w;

   index = 2 * r + c * body->cloth_rows * 2;

   return index;
}

EAPI EPhysics_Body *
ephysics_body_soft_circle_add(EPhysics_World *world)
{
   EPhysics_Body *body;
   btCollisionShape *shape;
   btSoftBodyWorldInfo *world_info;
   btSoftBody *soft_body;
   int points[19] = {16, 58, 44, 79, 97, 35, 6, 27, 45, 1, 38, 18, 21, 10, 26,
                     7, 86, 37, 55};

   if (!world)
     {
        ERR("Can't add circle, world is null.");
        return NULL;
     }

   ephysics_world_lock_take(world);
   shape = new btCylinderShapeZ(btVector3(0.5, 0.5, 0.5));

   if (!shape)
     {
        ERR("Couldn't create a new cylinder shape.");
        goto no_collision_shape;
     }

   world_info = ephysics_world_info_get(world);
   soft_body = btSoftBodyHelpers::CreateFromTriMesh(*world_info,
                        cylinder_vertices, &cylinder_indices[0][0],
                        CYLINDER_NUM_TRIANGLES);
   if (!soft_body)
     {
        ERR("Couldn't create a new soft body.");
        goto no_soft_body;
     }

   body = _ephysics_body_soft_body_add(world, shape, soft_body);
   if (!body)
     goto no_body;

   body->slices = 19;
   body->points_deform = (int *)malloc(body->slices * sizeof(int));
   if (!body->points_deform)
     {
        ERR("Couldn't create points of deformation.");
        goto no_deform;
     }

   for (int i = 0; i < body->slices; i++)
     body->points_deform[i] = points[i];

   if (!_ephysics_body_slices_add(body, 0.55, 1.1))
     {
        ERR("Couldn't create slices.");
        goto no_slices;
     }

   ephysics_world_lock_release(world);
   return body;

no_slices:
   free(body->points_deform);
no_deform:
   ephysics_world_body_del(world, body);
no_body:
   delete soft_body;
no_soft_body:
   delete shape;
no_collision_shape:
   ephysics_world_lock_release(world);
   return NULL;
}

EAPI EPhysics_Body *
ephysics_body_circle_add(EPhysics_World *world)
{
   btCollisionShape *collision_shape;
   EPhysics_Body *body;

   if (!world)
     {
        ERR("Can't add circle, world is null.");
        return NULL;
     }

   collision_shape = new btCylinderShapeZ(btVector3(0.5, 0.5, 0.5));
   if (!collision_shape)
     {
        ERR("Couldn't create a new cylinder shape.");
        return NULL;
     }

   ephysics_world_lock_take(world);
   body = _ephysics_body_rigid_body_add(world, collision_shape, "circle", 0.5,
                                        0.5, 0.5);
   ephysics_world_lock_release(world);
   return body;
}

EAPI EPhysics_Body *
ephysics_body_soft_box_add(EPhysics_World *world)
{
   EPhysics_Body *body;
   btCollisionShape *shape;
   btSoftBodyWorldInfo *world_info;
   btSoftBody *soft_body;
   int points[16] = {14, 85, 88, 28, 41, 55, 10, 24, 93, 79, 56, 86, 91, 8,
                     27, 1};


   if (!world)
     {
        ERR("Can't add circle, world is null.");
        return NULL;
     }

   ephysics_world_lock_take(world);
   shape = new btBoxShape(btVector3(0.25, 0.25, 0.25));
   if (!shape)
     {
        ERR("Couldn't create a new box shape.");
        goto no_collision_shape;
     }

   world_info = ephysics_world_info_get(world);
   soft_body = btSoftBodyHelpers::CreateFromTriMesh(*world_info,
                                            cube_vertices, &cube_indices[0][0],
                                            CUBE_NUM_TRIANGLES);
   if (!soft_body)
     {
        ERR("Couldn't create a new soft body.");
        goto no_soft_body;
     }

   body = _ephysics_body_soft_body_add(world, shape, soft_body);
   if (!body)
     goto no_body;

   body->slices = 16;
   body->points_deform = (int *)malloc(body->slices * sizeof(int));
   if (!body->points_deform)
     {
        ERR("Couldn't create points of deformation.");
        goto no_deform;
     }

   for (int i = 0; i < body->slices; i++)
     body->points_deform[i] = points[i];

   if (!_ephysics_body_slices_add(body, 0.55, 1.1))
     {
        ERR("Couldn't create slices.");
        goto no_slices;
     }

   ephysics_world_lock_release(world);
   return body;

no_slices:
   free(body->points_deform);
no_deform:
   ephysics_world_body_del(world, body);
no_body:
   delete soft_body;
no_soft_body:
   delete shape;
no_collision_shape:
   ephysics_world_lock_release(world);
   return NULL;
}

EAPI EPhysics_Body *
ephysics_body_box_add(EPhysics_World *world)
{
   btCollisionShape *collision_shape;
   EPhysics_Body *body;

   if (!world)
     {
        ERR("Can't add box, world is null.");
        return NULL;
     }

   collision_shape = new btBoxShape(btVector3(0.5, 0.5, 0.5));

   ephysics_world_lock_take(world);
   body = _ephysics_body_rigid_body_add(world, collision_shape, "box", 0.5,
                                        0.5, 0.5);
   ephysics_world_lock_release(world);
   return body;
}

EAPI EPhysics_Body *
ephysics_body_shape_add(EPhysics_World *world, EPhysics_Shape *shape)
{
   double max_x, max_y, max_z, min_x, min_y, min_z, cm_x, cm_y, cm_z,
          range_x, range_y, range_z;
   btConvexHullShape *full_shape, *simplified_shape;
   btAlignedObjectArray<btVector3> vertexes, planes;
   const Eina_Inlist *points;
   EPhysics_Point *point;
   EPhysics_Body *body;
   int array_size, i;
   btShapeHull *hull;
   btVector3 point3d;
   btScalar margin;

   if (!world)
     {
        ERR("Can't add shape, world is null.");
        return NULL;
     }

   if (!shape)
     {
        ERR("Can't add shape, shape is null.");
        return NULL;
     }

   points = ephysics_shape_points_get(shape);
   if (eina_inlist_count(points) < 3)
     {
        ERR("At least 3 points are required to add a shape");
        return NULL;
     }

   full_shape = new btConvexHullShape();
   if (!full_shape)
     {
        ERR("Couldn't create a generic convex shape.");
        return NULL;
     }

   point = EINA_INLIST_CONTAINER_GET(points, EPhysics_Point);
   max_x = min_x = point->x;
   max_y = min_y = point->y;
   max_z = min_z = point->z;
   cm_x = cm_y = cm_z = 0;

   /* FIXME : only vertices should be used to calculate the center of mass */
   EINA_INLIST_FOREACH(points, point)
     {
        if (point->x > max_x) max_x = point->x;
        if (point->x < min_x) min_x = point->x;
        if (point->y > max_y) max_y = point->y;
        if (point->y < min_y) min_y = point->y;
        if (point->z > max_z) max_z = point->z;
        if (point->z < min_z) min_z = point->z;

        cm_x += point->x;
        cm_y += point->y;
        cm_z += point->z;
     }

   cm_x /= eina_inlist_count(points);
   cm_y /= eina_inlist_count(points);
   cm_z /= eina_inlist_count(points);
   range_x = max_x - min_x;
   range_y = max_y - min_y;
   range_z = max_z - min_z;

   EINA_INLIST_FOREACH(points, point)
     {
        double x, y, z;

        x = (point->x - cm_x) / range_x;
        y = - (point->y - cm_y) / range_y;
        z = (point->z - cm_z) / range_z;

        point3d = btVector3(x, y, z);
        vertexes.push_back(point3d);
     }

   /* Shrink convex shape to consider margin. Otherwise it would have a gap */
   btGeometryUtil::getPlaneEquationsFromVertices(vertexes, planes);
   array_size = planes.size();
   for (i = 0; i < array_size; ++i)
     planes[i][3] += full_shape->getMargin();

   vertexes.clear();
   btGeometryUtil::getVerticesFromPlaneEquations(planes, vertexes);

   array_size = vertexes.size();
   for (i = 0; i < array_size; ++i)
     full_shape->addPoint(vertexes[i]);

   hull = new btShapeHull(full_shape);
   if (!hull)
     {
        delete full_shape;
        ERR("Couldn't create a shape hull.");
        return NULL;
     }

   margin = full_shape->getMargin();
   hull->buildHull(margin);
   simplified_shape = new btConvexHullShape(&(hull->getVertexPointer()->getX()),
                                            hull->numVertices());
   delete hull;
   delete full_shape;
   if (!simplified_shape)
     {
        ERR("Couldn't create a simplified shape.");
        return NULL;
     }

   ephysics_world_lock_take(world);
   body = _ephysics_body_rigid_body_add(world,
                                        (btCollisionShape *)simplified_shape,
                                        "generic", (cm_x - min_x) / range_x,
                                        1 - (cm_y - min_y) / range_y,
                                        (cm_z - min_z) / range_z);
   ephysics_world_lock_release(world);
   return body;
}

void
ephysics_body_world_boundaries_resize(EPhysics_World *world)
{
   Evas_Coord x, y, z, w, h, d;
   EPhysics_Body *bound;

   ephysics_world_render_geometry_get(world, &x, &y, &z, &w, &h, &d);

   bound = ephysics_world_boundary_get(world, EPHYSICS_WORLD_BOUNDARY_BOTTOM);
   if (bound)
     ephysics_body_geometry_set(bound, x, y + h, z, w, 10, d);

   bound = ephysics_world_boundary_get(world, EPHYSICS_WORLD_BOUNDARY_RIGHT);
   if (bound)
     ephysics_body_geometry_set(bound, x + w, y, z, 10, h, d);

   bound = ephysics_world_boundary_get(world, EPHYSICS_WORLD_BOUNDARY_LEFT);
   if (bound)
     ephysics_body_geometry_set(bound,  x - 10, y, z, 10, h, d);

   bound = ephysics_world_boundary_get(world, EPHYSICS_WORLD_BOUNDARY_TOP);
   if (bound)
     ephysics_body_geometry_set(bound, x, y - 10, z, w, 10, d);

   bound = ephysics_world_boundary_get(world, EPHYSICS_WORLD_BOUNDARY_FRONT);
   if (bound)
     ephysics_body_geometry_set(bound, x, y, z - 10, w, h, 10);

   bound = ephysics_world_boundary_get(world, EPHYSICS_WORLD_BOUNDARY_BACK);
   if (bound)
     ephysics_body_geometry_set(bound, x, y, z + d, w, h, 10);
}

static EPhysics_Body *
_ephysics_body_boundary_add(EPhysics_World *world, EPhysics_World_Boundary boundary, Evas_Coord x, Evas_Coord y, Evas_Coord z, Evas_Coord w, Evas_Coord h, Evas_Coord d)
{
   EPhysics_Body *body;

   if (!world)
     {
        ERR("Can't add boundary, world is null.");
        return NULL;
     }

   body = ephysics_world_boundary_get(world, boundary);
   if (body)
     return body;

   body = ephysics_body_box_add(world);
   if (!body)
     return NULL;

   ephysics_body_mass_set(body, 0);
   ephysics_world_boundary_set(world, boundary, body);
   ephysics_body_geometry_set(body, x, y, z, w, h, d);

   return body;
}

EAPI EPhysics_Body *
ephysics_body_top_boundary_add(EPhysics_World *world)
{
   Evas_Coord x, y, z, w, d;
   EPhysics_Body *body;

   ephysics_world_render_geometry_get(world, &x, &y, &z, &w, NULL, &d);
   body =  _ephysics_body_boundary_add(world, EPHYSICS_WORLD_BOUNDARY_TOP,
                                       x, y - 10, z, w, 10, d);
   return body;
}

EAPI EPhysics_Body *
ephysics_body_bottom_boundary_add(EPhysics_World *world)
{
   Evas_Coord x, y, z, w, h, d;
   EPhysics_Body *body;

   ephysics_world_render_geometry_get(world, &x, &y, &z, &w, &h, &d);
   body = _ephysics_body_boundary_add(world, EPHYSICS_WORLD_BOUNDARY_BOTTOM,
                                      x, y + h, z, w, 10, d);
   return body;
}

EAPI EPhysics_Body *
ephysics_body_left_boundary_add(EPhysics_World *world)
{
   Evas_Coord x, y, z, h, d;
   EPhysics_Body *body;

   ephysics_world_render_geometry_get(world, &x, &y, &z, NULL, &h, &d);
   body = _ephysics_body_boundary_add(world, EPHYSICS_WORLD_BOUNDARY_LEFT,
                                      x - 10, y, z, 10, h, d);
   return body;
}

EAPI EPhysics_Body *
ephysics_body_right_boundary_add(EPhysics_World *world)
{
   Evas_Coord x, y, z, w, h, d;
   EPhysics_Body *body;

   ephysics_world_render_geometry_get(world, &x, &y, &z, &w, &h, &d);
   body = _ephysics_body_boundary_add(world, EPHYSICS_WORLD_BOUNDARY_RIGHT,
                                      x + w, y, z, 10, h, d);
   return body;
}

EAPI EPhysics_Body *
ephysics_body_front_boundary_add(EPhysics_World *world)
{
   Evas_Coord x, y, z, w, h;
   EPhysics_Body *body;

   ephysics_world_render_geometry_get(world, &x, &y, &z, &w, &h, NULL);
   body = _ephysics_body_boundary_add(world, EPHYSICS_WORLD_BOUNDARY_FRONT,
                                      x, y, z - 10, w, h, 10);
   return body;
}

EAPI EPhysics_Body *
ephysics_body_back_boundary_add(EPhysics_World *world)
{
   Evas_Coord x, y, z, w, h, d;
   EPhysics_Body *body;

   ephysics_world_render_geometry_get(world, &x, &y, &z, &w, &h, &d);
   body = _ephysics_body_boundary_add(world, EPHYSICS_WORLD_BOUNDARY_BACK,
                                      x, y, z + d, w, h, 10);
   return body;
}

void
ephysics_orphan_body_del(EPhysics_Body *body)
{
   _ephysics_body_event_callback_call(body, EPHYSICS_CALLBACK_BODY_DEL,
                                      (void *) body->evas_obj);
   _ephysics_body_del(body);
   INF("Body %p deleted.", body);
}

EAPI void
ephysics_body_del(EPhysics_Body *body)
{
   EPhysics_World *world;

   if (!body)
     {
        ERR("Can't delete body, it wasn't provided.");
        return;
     }

   if (body->deleted) return;

   world = body->world;
   ephysics_world_lock_take(world);
   body->deleted = EINA_TRUE;
   ephysics_world_body_del(world, body);
   ephysics_world_lock_release(world);
}

EAPI void
ephysics_body_evas_object_set(EPhysics_Body *body, Evas_Object *evas_obj, Eina_Bool use_obj_pos)
{
   int obj_x, obj_y, obj_w, obj_h, bz, bd;
   double rate;

   if (!body)
     {
        ERR("Can't set evas object to body, the last wasn't provided.");
        return;
     }

   if (!evas_obj)
     {
        ERR("Can't set evas object to body, the first wasn't provided.");
        return;
     }

   if (body->evas_obj)
     {
        evas_object_map_enable_set(body->evas_obj, EINA_FALSE);
        evas_object_event_callback_del(body->evas_obj, EVAS_CALLBACK_DEL,
                                       _ephysics_body_evas_obj_del_cb);
        evas_object_event_callback_del(body->evas_obj, EVAS_CALLBACK_RESIZE,
                                       _ephysics_body_evas_obj_resize_cb);
        if (body->slices_list)
          _ephysics_body_soft_body_slices_clean(body);
     }

   body->evas_obj = evas_obj;
   evas_object_event_callback_add(evas_obj, EVAS_CALLBACK_DEL,
                                  _ephysics_body_evas_obj_del_cb, body);

   if (body->soft_body)
     _ephysics_body_soft_body_slices_init(body);

   if (!use_obj_pos)
     return;

   rate = ephysics_world_rate_get(body->world);
   evas_object_geometry_get(body->evas_obj, &obj_x, &obj_y, &obj_w, &obj_h);
   ephysics_body_geometry_get(body, NULL, NULL, &bz, NULL, NULL, &bd);

   ephysics_world_lock_take(body->world);
   _ephysics_body_geometry_set(body, obj_x, obj_y, bz, obj_w, obj_h, bd, rate);
   ephysics_world_lock_release(body->world);
   evas_object_event_callback_add(body->evas_obj, EVAS_CALLBACK_RESIZE,
                                  _ephysics_body_evas_obj_resize_cb, body);
}

EAPI Evas_Object *
ephysics_body_evas_object_unset(EPhysics_Body *body)
{
   Evas_Object *obj;

   if (!body)
     {
        ERR("Can't unset evas object from body, it wasn't provided.");
        return NULL;
     }

   obj = body->evas_obj;
   body->evas_obj = NULL;

   if (obj)
     {
        evas_object_event_callback_del(obj, EVAS_CALLBACK_DEL,
                                       _ephysics_body_evas_obj_del_cb);
        evas_object_event_callback_del(obj, EVAS_CALLBACK_RESIZE,
                                       _ephysics_body_evas_obj_resize_cb);
        evas_object_map_enable_set(obj, EINA_FALSE);
     }

   if (body->slices_list)
     _ephysics_body_soft_body_slices_clean(body);

   return obj;
}

EAPI Evas_Object *
ephysics_body_evas_object_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't get evas object from body, it wasn't provided.");
        return NULL;
     }

   return body->evas_obj;
}

EAPI void
ephysics_body_geometry_set(EPhysics_Body *body, Evas_Coord x, Evas_Coord y, Evas_Coord z, Evas_Coord w, Evas_Coord h, Evas_Coord d)
{
   if (!body)
     {
        ERR("Can't set body geometry, body is null.");
        return;
     }

   if ((w <= 0) || (h <= 0) || (d <= 0))
     {
        ERR("Width, height and depth must to be a non-null, positive value.");
        return;
     }

   ephysics_world_lock_take(body->world);
   _ephysics_body_geometry_set(body, x, y, z, w, h, d,
                               ephysics_world_rate_get(body->world));
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_resize(EPhysics_Body *body, Evas_Coord w, Evas_Coord h, Evas_Coord d)
{
   if (!body)
     {
        ERR("Can't set body size, body is null.");
        return;
     }

   if ((w <= 0) || (h <= 0) || (d <= 0))
     {
        ERR("Width, height and depth must to be a non-null, positive value.");
        return;
     }

   ephysics_world_lock_take(body->world);
   _ephysics_body_resize(body, w, h, d);
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_move(EPhysics_Body *body, Evas_Coord x, Evas_Coord y, Evas_Coord z)
{
   if (!body)
     {
        ERR("Can't set body position, body is null.");
        return;
     }

   ephysics_world_lock_take(body->world);
   _ephysics_body_move(body, x, y, z);
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_geometry_get(const EPhysics_Body *body, Evas_Coord *x, Evas_Coord *y, Evas_Coord *z, Evas_Coord *w, Evas_Coord *h, Evas_Coord *d)
{
   btTransform trans;
   btVector3 scale;
   double rate;
   int wy, height;

   if (!body)
     {
        ERR("Can't get body position, body is null.");
        return;
     }

   trans = _ephysics_body_transform_get(body);
   scale = body->scale;

   rate = ephysics_world_rate_get(body->world);
   ephysics_world_render_geometry_get(body->world, NULL, &wy, NULL,
                                      NULL, &height, NULL);
   height += wy;

   if (x) *x = round((trans.getOrigin().getX() - scale.x() / 2) * rate);
   if (y) *y = height - round((trans.getOrigin().getY() + scale.y() / 2)
                              * rate);
   if (z) *z = round((trans.getOrigin().getZ() - scale.z() / 2) * rate);
   if (w) *w = body->size.w;
   if (h) *h = body->size.h;
   if (d) *d = body->size.d;
}

EAPI void
ephysics_body_mass_set(EPhysics_Body *body, double mass)
{
   if (!body)
     {
        ERR("Can't set body mass, body is null.");
        return;
     }

   if (mass < 0)
     {
        ERR("Can't set body's mass, it must to be non-negative.");
        return;
     }

   ephysics_world_lock_take(body->world);
   body->material = EPHYSICS_BODY_MATERIAL_CUSTOM;
   body->density = 0;
   _ephysics_body_mass_set(body, mass);
   ephysics_world_lock_release(body->world);
}

EAPI double
ephysics_body_mass_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't get body mass, body is null.");
        return 0;
     }

   return body->mass;
}

EAPI void
ephysics_body_linear_velocity_set(EPhysics_Body *body, double x, double y, double z)
{
   if (!body)
     {
        ERR("Can't set body linear velocity, body is null.");
        return;
     }

   _ephysics_body_linear_velocity_set(body, x, y, z,
                                      ephysics_world_rate_get(body->world));
   DBG("Linear velocity of body %p set to (%lf, %lf, %lf).", body, x, y, z);
}

EAPI void
ephysics_body_linear_velocity_get(const EPhysics_Body *body, double *x, double *y, double *z)
{
   double rate;

   if (!body)
     {
        ERR("Can't get linear velocity, body is null.");
        return;
     }

   rate = ephysics_world_rate_get(body->world);
   if (x) *x = body->rigid_body->getLinearVelocity().getX() * rate;
   if (y) *y = -body->rigid_body->getLinearVelocity().getY() * rate;
   if (z) *z = body->rigid_body->getLinearVelocity().getZ() * rate;
}

EAPI void
ephysics_body_angular_velocity_set(EPhysics_Body *body, double x, double y, double z)
{
   if (!body)
     {
        ERR("Can't set angular velocity, body is null.");
        return;
     }

   ephysics_world_lock_take(body->world);
   body->rigid_body->setAngularVelocity(btVector3(-x / RAD_TO_DEG,
                                                  -y / RAD_TO_DEG,
                                                  -z/RAD_TO_DEG));
   DBG("Angular velocity of body %p set to (%lf, %lf, %lf).", body, x, y, z);
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_angular_velocity_get(const EPhysics_Body *body, double *x, double *y, double *z)
{
   if (!body)
     {
        ERR("Can't get angular velocity, body is null.");
        return;
     }

   if (x) *x = -body->rigid_body->getAngularVelocity().getX() * RAD_TO_DEG;
   if (y) *y = -body->rigid_body->getAngularVelocity().getY() * RAD_TO_DEG;
   if (z) *z = -body->rigid_body->getAngularVelocity().getZ() * RAD_TO_DEG;
}

EAPI void
ephysics_body_sleeping_threshold_set(EPhysics_Body *body, double linear_threshold, double angular_threshold)
{
   if (!body)
     {
        ERR("Can't set sleeping thresholds, body is null.");
        return;
     }

   ephysics_world_lock_take(body->world);
   _ephysics_body_sleeping_threshold_set(body, linear_threshold,
                                         angular_threshold,
                                         ephysics_world_rate_get(body->world));
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_sleeping_threshold_get(const EPhysics_Body *body, double *linear_threshold, double *angular_threshold)
{
   double rate;

   if (!body)
     {
        ERR("Can't get linear sleeping threshold, body is null.");
        return;
     }

   rate = ephysics_world_rate_get(body->world);
   if (linear_threshold)
     *linear_threshold = body->rigid_body->getLinearSleepingThreshold() * rate;
   if (angular_threshold)
     *angular_threshold = body->rigid_body->getAngularSleepingThreshold() *
        RAD_TO_DEG;
}

EAPI void
ephysics_body_stop(EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't stop a null body.");
        return;
     }

   ephysics_world_lock_take(body->world);
   body->rigid_body->setLinearVelocity(btVector3(0, 0, 0));
   body->rigid_body->setAngularVelocity(btVector3(0, 0, 0));
   ephysics_world_lock_release(body->world);

   DBG("Body %p stopped", body);
}

EAPI void
ephysics_body_damping_set(EPhysics_Body *body, double linear_damping, double angular_damping)
{
   if (!body)
     {
        ERR("Can't set body damping, body is null.");
        return;
     }

   ephysics_world_lock_take(body->world);
   body->rigid_body->setDamping(btScalar(linear_damping),
                                btScalar(angular_damping));
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_damping_get(const EPhysics_Body *body, double *linear_damping, double *angular_damping)
{
   if (!body)
     {
        ERR("Can't get damping, body is null.");
        return;
     }

   if (linear_damping) *linear_damping = body->rigid_body->getLinearDamping();
   if (angular_damping) *angular_damping =
     body->rigid_body->getAngularDamping();
}

EAPI void
ephysics_body_evas_object_update(EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Couldn't update a null body.");
        return;
     }

   _ephysics_body_evas_object_default_update(body);
}

EAPI void
ephysics_body_event_callback_add(EPhysics_Body *body, EPhysics_Callback_Body_Type type, EPhysics_Body_Event_Cb func, const void *data)
{
   EPhysics_Body_Callback *cb;

   if (!body)
     {
        ERR("Can't set body event callback, body is null.");
        return;
     }

   if (!func)
     {
        ERR("Can't set body event callback, function is null.");
        return;
     }

   if ((type < 0) || (type >= EPHYSICS_CALLBACK_BODY_LAST))
     {
        ERR("Can't set body event callback, callback type is wrong.");
        return;
     }

   cb = (EPhysics_Body_Callback *)calloc(1, sizeof(EPhysics_Body_Callback));
   if (!cb)
     {
        ERR("Can't set body event callback, can't create cb instance.");
        return;
     }

   cb->func = func;
   cb->type = type;
   cb->data = (void *)data;

   body->callbacks = eina_inlist_append(body->callbacks, EINA_INLIST_GET(cb));
   if (type == EPHYSICS_CALLBACK_BODY_COLLISION)
       body->collision_cb++;
}

EAPI void *
ephysics_body_event_callback_del(EPhysics_Body *body, EPhysics_Callback_Body_Type type, EPhysics_Body_Event_Cb func)
{
   EPhysics_Body_Callback *cb;
   void *cb_data = NULL;

   if (!body)
     {
        ERR("Can't delete body event callback, body is null.");
        return NULL;
     }

   EINA_INLIST_FOREACH(body->callbacks, cb)
     {
        if ((cb->type != type) || (cb->func != func))
          continue;

        cb_data = cb->data;
        _ephysics_body_event_callback_del(body, cb);
        if (type == EPHYSICS_CALLBACK_BODY_COLLISION)
            body->collision_cb--;
        break;
     }

   return cb_data;
}

EAPI void *
ephysics_body_event_callback_del_full(EPhysics_Body *body, EPhysics_Callback_Body_Type type, EPhysics_Body_Event_Cb func, void *data)
{
   EPhysics_Body_Callback *cb;
   void *cb_data = NULL;

   if (!body)
     {
        ERR("Can't delete body event callback, body is null.");
        return NULL;
     }

   EINA_INLIST_FOREACH(body->callbacks, cb)
     {
        if ((cb->type != type) || (cb->func != func) || (cb->data != data))
          continue;

        cb_data = cb->data;
        _ephysics_body_event_callback_del(body, cb);
        break;
     }

   return cb_data;
}

static void
_ephysics_body_restitution_set(EPhysics_Body *body, double restitution)
{
   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     {
        body->rigid_body->setRestitution(btScalar(restitution));
        return;
     }

   body->soft_body->setRestitution(btScalar(restitution));
   DBG("Body %p restitution set to %lf", body, restitution);
}

EAPI void
ephysics_body_restitution_set(EPhysics_Body *body, double restitution)
{
   if (!body)
     {
        ERR("Can't set body restitution, body is null.");
        return;
     }

   ephysics_world_lock_take(body->world);
   body->material = EPHYSICS_BODY_MATERIAL_CUSTOM;
   _ephysics_body_restitution_set(body, restitution);
   ephysics_world_lock_release(body->world);
}

EAPI double
ephysics_body_restitution_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't get body restitution, body is null.");
        return 0;
     }

   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     return body->rigid_body->getRestitution();

   return body->soft_body->getRestitution();
}

static void
_ephysics_body_friction_set(EPhysics_Body *body, double friction)
{
   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     {
        body->rigid_body->setFriction(btScalar(friction));
        return;
     }

   body->soft_body->setFriction(btScalar(friction));
   DBG("Body %p friction set to %lf", body, friction);
}

EAPI void
ephysics_body_friction_set(EPhysics_Body *body, double friction)
{
   if (!body)
     {
        ERR("Can't set body friction, body is null.");
        return;
     }

   ephysics_world_lock_take(body->world);
   body->material = EPHYSICS_BODY_MATERIAL_CUSTOM;
   _ephysics_body_friction_set(body, friction);
   ephysics_world_lock_release(body->world);
}

EAPI double
ephysics_body_friction_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't get body friction, body is null.");
        return 0;
     }

   if (body->type == EPHYSICS_BODY_TYPE_RIGID)
     return body->rigid_body->getFriction();

   return body->soft_body->getFriction();
}

EAPI EPhysics_World *
ephysics_body_world_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't get the world a null body belongs to.");
        return NULL;
     }

   return body->world;
}

static void
_ephysics_body_soft_body_central_impulse_apply(EPhysics_Body *body, btVector3 impulse)
{
   btSoftBody::Face *face;

   for (int m = 0; m < body->soft_body->m_faces.size(); m++)
     {
        face = &body->soft_body->m_faces[m];
        for (int n = 0; n < 3; n++)
             face->m_n[n]->m_v += impulse * face->m_n[n]->m_im;
     }
}

EAPI void
ephysics_body_central_impulse_apply(EPhysics_Body *body, double x, double y, double z)
{
   double rate;
   btVector3 impulse;

   if (!body)
     {
        ERR("Can't apply impulse to a null body.");
        return;
     }

   rate = ephysics_world_rate_get(body->world);

   ephysics_world_lock_take(body->world);
   ephysics_body_activate(body, EINA_TRUE);

   impulse = btVector3(x / rate, - y / rate, z / rate);

   if (body->type == EPHYSICS_BODY_TYPE_CLOTH)
     _ephysics_body_soft_body_central_impulse_apply(body, impulse);
   else
     body->rigid_body->applyCentralImpulse(impulse);

   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_impulse_apply(EPhysics_Body *body, double x, double y, double z, Evas_Coord pos_x, Evas_Coord pos_y, Evas_Coord pos_z)
{
   double rate;

   if (!body)
     {
        ERR("Can't apply impulse to a null body.");
        return;
     }

   rate = ephysics_world_rate_get(body->world);

   ephysics_world_lock_take(body->world);
   ephysics_body_activate(body, EINA_TRUE);
   body->rigid_body->applyImpulse(btVector3(x / rate, - y / rate, z / rate),
                                  btVector3((double) pos_x / rate,
                                            (double) pos_y / rate,
                                            (double) pos_z / rate));
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_linear_movement_enable_set(EPhysics_Body *body, Eina_Bool enable_x, Eina_Bool enable_y, Eina_Bool enable_z)
{
   if (!body)
     {
        ERR("Can't set linear factor on a null body.");
        return;
     }

   ephysics_world_lock_take(body->world);
   body->rigid_body->setLinearFactor(btVector3(!!enable_x, !!enable_y,
                                               !!enable_z));
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_linear_movement_enable_get(const EPhysics_Body *body, Eina_Bool *enable_x, Eina_Bool *enable_y, Eina_Bool *enable_z)
{
   if (!body)
     {
        ERR("Can't check if linear factor is enabled, body is null.");
        return;
     }

   if (enable_x) *enable_x = !!body->rigid_body->getLinearFactor().x();
   if (enable_y) *enable_y = !!body->rigid_body->getLinearFactor().y();
   if (enable_z) *enable_z = !!body->rigid_body->getLinearFactor().z();
}

EAPI void
ephysics_body_torque_impulse_apply(EPhysics_Body *body, double pitch, double yaw, double roll)
{
   if (!body)
     {
        ERR("Can't apply torque impulse to a null body.");
        return;
     }

   ephysics_world_lock_take(body->world);
   ephysics_body_activate(body, EINA_TRUE);
   body->rigid_body->applyTorqueImpulse(btVector3(-pitch, -yaw, -roll));
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_angular_movement_enable_set(EPhysics_Body *body, Eina_Bool enable_x, Eina_Bool enable_y, Eina_Bool enable_z)
{
   if (!body)
     {
        ERR("Can't set rotation on a null body.");
        return;
     }

   ephysics_world_lock_take(body->world);
   body->rigid_body->setAngularFactor(btVector3(!!enable_x, !!enable_y,
                                                !!enable_z));
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_angular_movement_enable_get(const EPhysics_Body *body, Eina_Bool *enable_x, Eina_Bool *enable_y, Eina_Bool *enable_z)
{
   if (!body)
     {
        ERR("Can't check if rotation is enabled, body is null.");
        return;
     }

   if (enable_x) *enable_x = !!body->rigid_body->getAngularFactor().x();
   if (enable_y) *enable_y = !!body->rigid_body->getAngularFactor().y();
   if (enable_z) *enable_z = !!body->rigid_body->getAngularFactor().z();
}

EAPI void
ephysics_body_rotation_get(const EPhysics_Body *body, double *rot_x, double *rot_y, double *rot_z)
{
   btTransform trans;

   if (!body)
     {
        ERR("Can't get rotation, body is null.");
        return;
     }

   trans = _ephysics_body_transform_get(body);

   if (rot_x) *rot_x = - trans.getRotation().getAngle() * RAD_TO_DEG *
     trans.getRotation().getAxis().getX();
   if (rot_y) *rot_y = - trans.getRotation().getAngle() * RAD_TO_DEG *
     trans.getRotation().getAxis().getY();
   if (rot_z) *rot_z = - trans.getRotation().getAngle() * RAD_TO_DEG *
     trans.getRotation().getAxis().getZ();
}

EAPI void
ephysics_body_rotation_set(EPhysics_Body *body, double rot_x, double rot_y, double rot_z)
{
   btTransform trans;
   btQuaternion quat;

   if (!body)
     {
        ERR("Can't set rotation, body is null.");
        return;
     }

   ephysics_world_lock_take(body->world);
   ephysics_body_activate(body, EINA_TRUE);

   quat.setEuler(-rot_x / RAD_TO_DEG, -rot_y / RAD_TO_DEG, -rot_z / RAD_TO_DEG);

   if (body->soft_body)
     body->soft_body->rotate(quat);
   else
     {
        trans = _ephysics_body_transform_get(body);
        trans.setRotation(quat);
        body->rigid_body->proceedToTransform(trans);
        body->rigid_body->getMotionState()->setWorldTransform(trans);
     }

   DBG("Body %p rotation set to (%lf, %lf, %lf)", body, rot_x, rot_y, rot_z);
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_rotation_quaternion_get(const EPhysics_Body *body, double *x, double *y, double *z, double *w)
{
   btTransform trans;
   btQuaternion quat;

   if (!body)
     {
        ERR("Can't get rotation, body is null.");
        return;
     }

   trans = _ephysics_body_transform_get(body);
   quat = trans.getRotation();
   quat.normalize();

   if (x) *x = quat.x();
   if (y) *y = quat.y();
   if (z) *z = quat.z();
   if (w) *w = -quat.w();
}

EAPI void
ephysics_body_data_set(EPhysics_Body *body, void *data)
{
   if (!body)
     {
        ERR("Can't set data, body is null.");
        return;
     }

   body->data = data;
}

EAPI void *
ephysics_body_data_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't get data, body is null.");
        return NULL;
     }

   return body->data;
}

EAPI void
ephysics_body_central_force_apply(EPhysics_Body *body, double x, double y, double z)
{
   double rate;

   if (!body)
     {
        ERR("Can't apply force to a null body.");
        return;
     }

   ephysics_world_lock_take(body->world);
   rate = ephysics_world_rate_get(body->world);
   ephysics_body_forces_apply(body);
   body->rigid_body->applyCentralForce(btVector3(x / rate, - y / rate,
                                                 z / rate));
   _ephysics_body_forces_update(body);
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_force_apply(EPhysics_Body *body, double x, double y, double z, Evas_Coord pos_x, Evas_Coord pos_y, Evas_Coord pos_z)
{
   double rate;

   if (!body)
     {
        ERR("Can't apply force to a null body.");
        return;
     }

   rate = ephysics_world_rate_get(body->world);
   ephysics_world_lock_take(body->world);
   ephysics_body_forces_apply(body);
   body->rigid_body->applyForce(btVector3(x / rate, - y / rate, z / rate),
                                btVector3((double) pos_x / rate,
                                          (double) pos_y / rate,
                                          (double) pos_z / rate));
   _ephysics_body_forces_update(body);
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_torque_apply(EPhysics_Body *body, double torque_x, double torque_y, double torque_z)
{
   if (!body)
     {
        ERR("Can't apply force to a null body.");
        return;
     }

   ephysics_world_lock_take(body->world);
   ephysics_body_forces_apply(body);
   body->rigid_body->applyTorque(btVector3(-torque_x, -torque_y, -torque_z));
   _ephysics_body_forces_update(body);
   ephysics_world_lock_release(body->world);
}

EAPI void
ephysics_body_forces_get(const EPhysics_Body *body, double *x, double *y, double *z)
{
   double rate, gx, gy, gz;

   if (!body)
     {
        ERR("Can't get forces from a null body.");
        return;
     }

   rate = ephysics_world_rate_get(body->world);
   ephysics_world_gravity_get(body->world, &gx, &gy, &gz);

   if (x) *x = body->force.x * rate + gx;
   if (y) *y = -body->force.y * rate + gy;
   if (z) *z = body->force.z * rate + gz;
}

EAPI void
ephysics_body_torques_get(const EPhysics_Body *body, double *x, double *y, double *z)
{
   if (!body)
     {
        ERR("Can't get torques from a null body.");
        return;
     }

   if (x) *x = -body->force.torque_x;
   if (y) *y = -body->force.torque_y;
   if (z) *z = -body->force.torque_z;
}

EAPI void
ephysics_body_forces_clear(EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't clear forces of a null body.");
        return;
     }

   body->force.x = 0;
   body->force.y = 0;
   body->force.z = 0;
   body->force.torque_x = 0;
   body->force.torque_y = 0;
   body->force.torque_z = 0;
}

EAPI void
ephysics_body_center_mass_get(const EPhysics_Body *body, double *x, double *y, double *z)
{
   if (!body)
     {
        ERR("Can't get center of mass from a null body.");
        return;
     }

   if (x) *x = body->cm.x;
   if (y) *y = body->cm.y;
   if (z) *z = body->cm.z;
}

EAPI void
ephysics_body_density_set(EPhysics_Body *body, double density)
{
   if (!body)
     {
        ERR("Can't set the density of a null body's material.");
        return;
     }

   body->material = EPHYSICS_BODY_MATERIAL_CUSTOM;
   body->density = density;
   ephysics_world_lock_take(body->world);
   _ephysics_body_mass_set(body, 0);
   ephysics_world_lock_release(body->world);
}

EAPI double
ephysics_body_density_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't get the density of a null body's material.");
        return 0;
     }

   return body->density;
}

EAPI void
ephysics_body_material_set(EPhysics_Body *body, EPhysics_Body_Material material)
{
   if (!body)
     {
        ERR("Can't set body's material.");
        return;
     }

   if (material >= EPHYSICS_BODY_MATERIAL_LAST)
     {
        ERR("Invalid material.");
        return;
     }

   if (material != ephysics_material_props[material].material)
     {
        ERR("Material properties weren't found.");
        return;
     }

   if (material == EPHYSICS_BODY_MATERIAL_CUSTOM)
     {
        body->material = material;
        return;
     }

   ephysics_world_lock_take(body->world);
   body->density = ephysics_material_props[material].density;
   _ephysics_body_mass_set(body, 0);
   _ephysics_body_friction_set(body,
                               ephysics_material_props[material].friction);
   _ephysics_body_restitution_set(
      body, ephysics_material_props[material].restitution);
   body->material = material;
   ephysics_world_lock_release(body->world);
}

EAPI EPhysics_Body_Material
ephysics_body_material_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Can't get body's material.");
        return EPHYSICS_BODY_MATERIAL_LAST;
     }

   return body->material;
}

EAPI void
ephysics_body_light_set(EPhysics_Body *body, Eina_Bool enable)
{
   if (!body)
     {
        ERR("No body, no light.");
        return;
     }

   body->light_apply = !!enable;
}

EAPI Eina_Bool
ephysics_body_light_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("No body, no light.");
        return EINA_FALSE;
     }

   return body->light_apply;
}

EAPI double
ephysics_body_volume_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("No body, no volume.");
        return -1;
     }
   return _ephysics_body_volume_get(body);
}

EAPI void
ephysics_body_back_face_culling_set(EPhysics_Body *body, Eina_Bool enable)
{
   if (!body)
     {
        ERR("Body is NULL.");
        return;
     }
   body->back_face_culling = !!enable;
}

EAPI Eina_Bool
ephysics_body_back_face_culling_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Body is NULL.");
        return EINA_FALSE;
     }
   return body->back_face_culling;
}

EAPI Eina_Bool
ephysics_body_clockwise_get(const EPhysics_Body *body)
{
   if (!body)
     {
        ERR("Body is NULL.");
        return EINA_FALSE;
     }
   return body->clockwise;
}

static void
_ephysics_body_face_obj_del_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
{
   EPhysics_Body *body = (EPhysics_Body *) data;
   EPhysics_Body_Face_Obj *face_obj;
   Eina_List *l;
   void *ldata;

   EINA_LIST_FOREACH(body->face_objs, l, ldata)
     {
        face_obj = (EPhysics_Body_Face_Obj *)ldata;
        if (face_obj->obj == obj)
          {
             body->face_objs = eina_list_remove(body->face_objs, face_obj);
             free(face_obj);
             return;
          }
     }
}

static void
_ephysics_body_face_obj_unset(Evas_Object *obj, Evas_Object_Event_Cb resize_func)
{
   evas_object_map_enable_set(obj, EINA_FALSE);
   evas_object_event_callback_del(obj, EVAS_CALLBACK_DEL,
                                  _ephysics_body_face_obj_del_cb);
   evas_object_event_callback_del(obj, EVAS_CALLBACK_RESIZE, resize_func);
}

static void
_ephysics_body_face_evas_object_add(EPhysics_Body *body, EPhysics_Body_Face face, Evas_Object *evas_obj, Evas_Object_Event_Cb resize_func)
{
   EPhysics_Body_Face_Obj *face_obj;
   Eina_List *l;
   void *ldata;

   EINA_LIST_FOREACH(body->face_objs, l, ldata)
     {
        face_obj = (EPhysics_Body_Face_Obj *)ldata;
        if (face_obj->face == face)
          {
             _ephysics_body_face_obj_unset(face_obj->obj, resize_func);
             face_obj->obj = evas_obj;
             return;
          }
     }

   face_obj = (EPhysics_Body_Face_Obj *)calloc(1,
                                               sizeof(EPhysics_Body_Face_Obj));
   if (!face_obj)
     {
        ERR("Failed to create face object");
        return;
     }

   face_obj->face = face;
   face_obj->obj = evas_obj;
   body->face_objs = eina_list_append(body->face_objs, face_obj);
}

static void
_ephysics_body_box_face_obj_resize_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
{
   EPhysics_Body_Face face = EPHYSICS_BODY_FACE_LAST;
   EPhysics_Body *body = (EPhysics_Body *) data;
   EPhysics_Body_Face_Obj *face_obj;
   int w, h, bw, bh, bd;
   Eina_List *l;
   void *ldata;

   evas_object_geometry_get(obj, NULL, NULL, &w, &h);
   EINA_LIST_FOREACH(body->face_objs, l, ldata)
     {
        face_obj = (EPhysics_Body_Face_Obj *)ldata;
        if (face_obj->obj == obj)
          {
             face = face_obj->face;
             break;
          }
     }

   switch(face)
     {
      case EPHYSICS_BODY_BOX_FACE_FRONT:
      case EPHYSICS_BODY_BOX_FACE_BACK:
      case EPHYSICS_BODY_BOX_FACE_MIDDLE_FRONT:
      case EPHYSICS_BODY_BOX_FACE_MIDDLE_BACK:
         if ((w == body->size.w) && (h == body->size.h))
           return;
         bw = w;
         bh = h;
         bd = body->size.d;
         break;
      case EPHYSICS_BODY_BOX_FACE_RIGHT:
      case EPHYSICS_BODY_BOX_FACE_LEFT:
         if ((w == body->size.d) && (h == body->size.h))
           return;
         bw = body->size.w;
         bh = h;
         bd = w;
      case EPHYSICS_BODY_BOX_FACE_TOP:
      case EPHYSICS_BODY_BOX_FACE_BOTTOM:
         if ((w == body->size.w) && (h == body->size.d))
           return;
         bw = w;
         bh = body->size.h;
         bd = h;
      default:
         return;
     }

   DBG("Resizing body %p to w=%i, h=%i, d=%i", body, bw, bh, bd);
   ephysics_world_lock_take(body->world);
   _ephysics_body_resize(body, bw, bh, bd);
   ephysics_world_lock_release(body->world);
}

static void
_ephysics_body_box_face_evas_object_set(EPhysics_Body *body, EPhysics_Body_Face face, Evas_Object *evas_obj, Eina_Bool use_obj_pos)
{
   int obj_x, obj_y, obj_w, obj_h, bx, by, bz, bw, bh, bd;
   double rate;

   if ((face < EPHYSICS_BODY_BOX_FACE_MIDDLE_FRONT) ||
       (face > EPHYSICS_BODY_BOX_FACE_BOTTOM))
     {
        ERR("Can't set evas object to body, face is invalid.");
        return;
     }

   if (body->soft_body)
     {
        ERR("Not implemented for soft bodies yet.");
        return;
     }

   _ephysics_body_face_evas_object_add(body, face, evas_obj,
                                       _ephysics_body_box_face_obj_resize_cb);
   evas_object_event_callback_add(evas_obj, EVAS_CALLBACK_DEL,
                                  _ephysics_body_face_obj_del_cb, body);

   if (!use_obj_pos)
     return;

   rate = ephysics_world_rate_get(body->world);
   evas_object_geometry_get(evas_obj, &obj_x, &obj_y, &obj_w, &obj_h);
   ephysics_body_geometry_get(body, &bx, &by, &bz, &bw, &bh, &bd);

   ephysics_world_lock_take(body->world);

   switch(face)
     {
      case EPHYSICS_BODY_BOX_FACE_FRONT:
      case EPHYSICS_BODY_BOX_FACE_BACK:
      case EPHYSICS_BODY_BOX_FACE_MIDDLE_FRONT:
      case EPHYSICS_BODY_BOX_FACE_MIDDLE_BACK:
         _ephysics_body_geometry_set(body, obj_x, obj_y, bz,
                                     obj_w, obj_h, bd, rate);
         break;
      case EPHYSICS_BODY_BOX_FACE_RIGHT:
      case EPHYSICS_BODY_BOX_FACE_LEFT:
         _ephysics_body_geometry_set(body, bx, by, bz,
                                     bw, obj_h, obj_w, rate);
      case EPHYSICS_BODY_BOX_FACE_TOP:
      case EPHYSICS_BODY_BOX_FACE_BOTTOM:
         _ephysics_body_geometry_set(body, bx, by, bz,
                                     obj_w, bh, obj_h, rate);
      default:
         break;
     }

   ephysics_world_lock_release(body->world);
   evas_object_event_callback_add(evas_obj, EVAS_CALLBACK_RESIZE,
                                  _ephysics_body_box_face_obj_resize_cb,
                                  body);
}

static Evas_Object *
_ephysics_body_box_face_evas_object_get(const EPhysics_Body *body, EPhysics_Body_Face face)
{
   EPhysics_Body_Face_Obj *face_obj;
   Eina_List *l;
   void *ldata;

   if ((face < EPHYSICS_BODY_BOX_FACE_MIDDLE_FRONT) ||
       (face > EPHYSICS_BODY_BOX_FACE_BOTTOM))
     {
        ERR("Can't get evas object from body, face is invalid.");
        return NULL;
     }

   EINA_LIST_FOREACH(body->face_objs, l, ldata)
     {
        face_obj = (EPhysics_Body_Face_Obj *)ldata;
        if (face_obj->face == face)
          return face_obj->obj;
     }

   ERR("Couldn't find an object associated to face %i.", face);
   return NULL;
}

static Evas_Object *
_ephysics_body_box_face_evas_object_unset(EPhysics_Body *body, EPhysics_Body_Face face)
{
   EPhysics_Body_Face_Obj *face_obj;
   Eina_List *l;
   void *ldata;

   if ((face < EPHYSICS_BODY_BOX_FACE_MIDDLE_FRONT) ||
       (face > EPHYSICS_BODY_BOX_FACE_BOTTOM))
     {
        ERR("Can't unset evas object from body, face is invalid.");
        return NULL;
     }

   EINA_LIST_FOREACH(body->face_objs, l, ldata)
     {
        face_obj = (EPhysics_Body_Face_Obj *)ldata;
        if (face_obj->face == face)
          {
             Evas_Object *obj = face_obj->obj;
             _ephysics_body_face_obj_unset(
                obj, _ephysics_body_box_face_obj_resize_cb);
             body->face_objs = eina_list_remove(body->face_objs, face_obj);
             free(face_obj);
             return obj;
          }
     }

   ERR("Couldn't find an object associated to face %i.", face);
   return NULL;
}

static void
_ephysics_body_cylinder_face_obj_resize_cb(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
{
   EPhysics_Body_Face face = EPHYSICS_BODY_FACE_LAST;
   EPhysics_Body *body = (EPhysics_Body *) data;
   EPhysics_Body_Face_Obj *face_obj;
   int w, h, bw, bh, bd;
   Eina_List *l;
   void *ldata;

   evas_object_geometry_get(obj, NULL, NULL, &w, &h);
   EINA_LIST_FOREACH(body->face_objs, l, ldata)
     {
        face_obj = (EPhysics_Body_Face_Obj *)ldata;
        if (face_obj->obj == obj)
          {
             face = face_obj->face;
             break;
          }
     }

   switch(face)
     {
      case EPHYSICS_BODY_CYLINDER_FACE_FRONT:
      case EPHYSICS_BODY_CYLINDER_FACE_BACK:
      case EPHYSICS_BODY_CYLINDER_FACE_MIDDLE_FRONT:
      case EPHYSICS_BODY_CYLINDER_FACE_MIDDLE_BACK:
         if ((w == body->size.w) && (h == body->size.h))
           return;
         bw = w;
         bh = h;
         bd = body->size.d;
         break;
      case EPHYSICS_BODY_CYLINDER_FACE_CURVED:
         if ((h == body->size.d))
           return;
         bw = body->size.w;
         bh = body->size.h;
         bd = h;
      default:
         return;
     }

   DBG("Resizing body %p to w=%i, h=%i, d=%i", body, bw, bh, bd);
   ephysics_world_lock_take(body->world);
   _ephysics_body_resize(body, bw, bh, bd);
   ephysics_world_lock_release(body->world);
}

static void
_ephysics_body_cylinder_face_evas_object_set(EPhysics_Body *body, EPhysics_Body_Face face, Evas_Object *evas_obj, Eina_Bool use_obj_pos)
{
   int obj_x, obj_y, obj_w, obj_h, bx, by, bz, bw, bh, bd;
   double rate;

   if ((face < EPHYSICS_BODY_CYLINDER_FACE_MIDDLE_FRONT) ||
       (face > EPHYSICS_BODY_CYLINDER_FACE_CURVED))
     {
        ERR("Can't set evas object to body, face is invalid.");
        return;
     }

   if (body->soft_body)
     {
        ERR("Not implemented for soft bodies yet.");
        return;
     }

   _ephysics_body_face_evas_object_add(
      body, face, evas_obj, _ephysics_body_cylinder_face_obj_resize_cb);
   evas_object_event_callback_add(evas_obj, EVAS_CALLBACK_DEL,
                                  _ephysics_body_face_obj_del_cb, body);

   if (!use_obj_pos)
     return;

   rate = ephysics_world_rate_get(body->world);
   evas_object_geometry_get(evas_obj, &obj_x, &obj_y, &obj_w, &obj_h);
   ephysics_body_geometry_get(body, &bx, &by, &bz, &bw, &bh, &bd);

   ephysics_world_lock_take(body->world);

   switch(face)
     {
      case EPHYSICS_BODY_CYLINDER_FACE_FRONT:
      case EPHYSICS_BODY_CYLINDER_FACE_BACK:
      case EPHYSICS_BODY_CYLINDER_FACE_MIDDLE_FRONT:
      case EPHYSICS_BODY_CYLINDER_FACE_MIDDLE_BACK:
         _ephysics_body_geometry_set(body, obj_x, obj_y, bz,
                                     obj_w, obj_h, bd, rate);
         break;
      case EPHYSICS_BODY_CYLINDER_FACE_CURVED:
         _ephysics_body_geometry_set(body, bx, by, bz,
                                     bw, bh, obj_h, rate);
      default:
         break;
     }

   ephysics_world_lock_release(body->world);
   evas_object_event_callback_add(evas_obj, EVAS_CALLBACK_RESIZE,
                                  _ephysics_body_cylinder_face_obj_resize_cb,
                                  body);
}

static Evas_Object *
_ephysics_body_cylinder_face_evas_object_get(const EPhysics_Body *body, EPhysics_Body_Face face)
{
   EPhysics_Body_Face_Obj *face_obj;
   Eina_List *l;
   void *ldata;

   if ((face < EPHYSICS_BODY_CYLINDER_FACE_MIDDLE_FRONT) ||
       (face > EPHYSICS_BODY_CYLINDER_FACE_CURVED))
     {
        ERR("Can't get evas object from body, face is invalid.");
        return NULL;
     }

   EINA_LIST_FOREACH(body->face_objs, l, ldata)
     {
        face_obj = (EPhysics_Body_Face_Obj *)ldata;
        if (face_obj->face == face)
          return face_obj->obj;
     }

   ERR("Couldn't find an object associated to face %i.", face);
   return NULL;
}

static Evas_Object *
_ephysics_body_cylinder_face_evas_object_unset(EPhysics_Body *body, EPhysics_Body_Face face)
{
   EPhysics_Body_Face_Obj *face_obj;
   Eina_List *l;
   void *ldata;

   if ((face < EPHYSICS_BODY_CYLINDER_FACE_MIDDLE_FRONT) ||
       (face > EPHYSICS_BODY_CYLINDER_FACE_CURVED))
     {
        ERR("Can't unset evas object from body, face is invalid.");
        return NULL;
     }

   EINA_LIST_FOREACH(body->face_objs, l, ldata)
     {
        face_obj = (EPhysics_Body_Face_Obj *)ldata;
        if (face_obj->face == face)
          {
             Evas_Object *obj = face_obj->obj;
             _ephysics_body_face_obj_unset(
                obj, _ephysics_body_cylinder_face_obj_resize_cb);
             body->face_objs = eina_list_remove(body->face_objs, face_obj);
             free(face_obj);
             return obj;
          }
     }

   ERR("Couldn't find an object associated to face %i.", face);
   return NULL;
}

static void
_ephysics_body_cloth_face_evas_object_set(EPhysics_Body *body, EPhysics_Body_Face face, Evas_Object *evas_obj, Eina_Bool use_obj_pos)
{
   int obj_x, obj_y, obj_w, obj_h, bz, bd;
   double rate;

   if ((face < EPHYSICS_BODY_CLOTH_FACE_FRONT) ||
       (face > EPHYSICS_BODY_CLOTH_FACE_BACK))
     {
        ERR("Can't set evas object to body, face is invalid.");
        return;
     }

   _ephysics_body_face_evas_object_add(body, face, evas_obj,
                                       _ephysics_body_evas_obj_resize_cb);
   evas_object_event_callback_add(evas_obj, EVAS_CALLBACK_DEL,
                                  _ephysics_body_face_obj_del_cb, body);

   if (!use_obj_pos)
     return;

   rate = ephysics_world_rate_get(body->world);
   evas_object_geometry_get(evas_obj, &obj_x, &obj_y, &obj_w, &obj_h);

   ephysics_world_lock_take(body->world);
   ephysics_body_geometry_get(body, NULL, NULL, &bz, NULL, NULL, &bd);
   _ephysics_body_geometry_set(body, obj_x, obj_y, bz, obj_w, obj_h, bd, rate);
   ephysics_world_lock_release(body->world);
   evas_object_event_callback_add(evas_obj, EVAS_CALLBACK_RESIZE,
                                  _ephysics_body_evas_obj_resize_cb,
                                  body);
}

static Evas_Object *
_ephysics_body_cloth_face_evas_object_get(const EPhysics_Body *body, EPhysics_Body_Face face)
{
   EPhysics_Body_Face_Obj *face_obj;
   Eina_List *l;
   void *ldata;

   if ((face < EPHYSICS_BODY_CLOTH_FACE_FRONT) ||
       (face > EPHYSICS_BODY_CLOTH_FACE_BACK))
     {
        ERR("Can't get evas object from body, face is invalid.");
        return NULL;
     }

   EINA_LIST_FOREACH(body->face_objs, l, ldata)
     {
        face_obj = (EPhysics_Body_Face_Obj *)ldata;
        if (face_obj->face == face)
          return face_obj->obj;
     }

   ERR("Couldn't find an object associated to face %i.", face);
   return NULL;
}

static Evas_Object *
_ephysics_body_cloth_face_evas_object_unset(EPhysics_Body *body, EPhysics_Body_Face face)
{
   EPhysics_Body_Face_Obj *face_obj;
   Eina_List *l;
   void *ldata;

   if ((face < EPHYSICS_BODY_CLOTH_FACE_FRONT) ||
       (face > EPHYSICS_BODY_CLOTH_FACE_BACK))
     {
        ERR("Can't unset evas object from body, face is invalid.");
        return NULL;
     }

   EINA_LIST_FOREACH(body->face_objs, l, ldata)
     {
        face_obj = (EPhysics_Body_Face_Obj *)ldata;
        if (face_obj->face == face)
          {
             Evas_Object *obj = face_obj->obj;
             _ephysics_body_face_obj_unset(
                obj, _ephysics_body_evas_obj_resize_cb);
             body->face_objs = eina_list_remove(body->face_objs, face_obj);
             free(face_obj);
             return obj;
          }
     }

   ERR("Couldn't find an object associated to face %i.", face);
   return NULL;
}

EAPI void
ephysics_body_face_evas_object_set(EPhysics_Body *body, EPhysics_Body_Face face, Evas_Object *evas_obj, Eina_Bool use_obj_pos)
{
   if (!body)
     {
        ERR("Can't set evas object to body, the last wasn't provided.");
        return;
     }

   if (!evas_obj)
     {
        ERR("Can't set evas object to body, the first wasn't provided.");
        return;
     }

   if (body->type == EPHYSICS_BODY_TYPE_CLOTH)
     return _ephysics_body_cloth_face_evas_object_set(body, face, evas_obj,
                                                      use_obj_pos);
   if (strcmp(body->collision_shape->getName(), SHAPE_CYLINDER))
     return _ephysics_body_cylinder_face_evas_object_set(body, face, evas_obj,
                                                         use_obj_pos);
   if (strcmp(body->collision_shape->getName(), SHAPE_BOX))
     return _ephysics_body_box_face_evas_object_set(body, face, evas_obj,
                                                    use_obj_pos);

   ERR("Can't handle body %p type.", body);
}

EAPI Evas_Object *
ephysics_body_face_evas_object_get(const EPhysics_Body *body, EPhysics_Body_Face face)
{
   if (!body)
     {
        ERR("Can't get evas object from body, it wasn't provided.");
        return NULL;
     }

   if (body->type == EPHYSICS_BODY_TYPE_CLOTH)
     return _ephysics_body_cloth_face_evas_object_get(body, face);
   if (strcmp(body->collision_shape->getName(), SHAPE_CYLINDER))
     return _ephysics_body_cylinder_face_evas_object_get(body, face);
   if (strcmp(body->collision_shape->getName(), SHAPE_BOX))
     return _ephysics_body_box_face_evas_object_get(body, face);

   ERR("Can't handle body %p type.", body);
   return NULL;
}

EAPI Evas_Object *
ephysics_body_face_evas_object_unset(EPhysics_Body *body, EPhysics_Body_Face face)
{
   if (!body)
     {
        ERR("Can't unset evas object from body, it wasn't provided.");
        return NULL;
     }

   if (body->type == EPHYSICS_BODY_TYPE_CLOTH)
     return _ephysics_body_cloth_face_evas_object_unset(body, face);
   if (strcmp(body->collision_shape->getName(), SHAPE_CYLINDER))
     return _ephysics_body_cylinder_face_evas_object_unset(body, face);
   if (strcmp(body->collision_shape->getName(), SHAPE_BOX))
     return _ephysics_body_box_face_evas_object_unset(body, face);

   ERR("Can't handle body %p type.", body);
   return NULL;
}

#ifdef  __cplusplus
}
#endif