xref: /dports/devel/efl/efl-1.25.1/src/lib/ephysics/ephysics_world.cpp

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

#include <Ecore.h>
#include <Evas.h>

#include "ephysics_private.h"

#ifdef  __cplusplus
extern "C" {
#endif

#define DEFAULT_GRAVITY btVector3(0, -9.8, 0)

typedef struct _Simulation_Msg Simulation_Msg;

struct _Simulation_Msg {
     EPhysics_Body *body_0;
     EPhysics_Body *body_1;
     btVector3 pos_a;
     btVector3 pos_b;
     Eina_Bool tick:1;
};

typedef struct _EPhysics_World_Callback EPhysics_World_Callback;

struct _EPhysics_World_Callback {
     EINA_INLIST;
     void (*func) (void *data, EPhysics_World *world, void *event_info);
     void *data;
     EPhysics_Callback_World_Type type;
     Eina_Bool deleted:1;
};

struct _EPhysics_World {
     EINA_INLIST;

     struct {
          Evas_Coord x;
          Evas_Coord y;
          Evas_Coord z;
          Evas_Coord w;
          Evas_Coord h;
          Evas_Coord d;
     } geometry;

     btBroadphaseInterface *broadphase;
     btDefaultCollisionConfiguration *collision;
     btCollisionDispatcher *dispatcher;
     btSequentialImpulseConstraintSolver *solver;
     btSoftRigidDynamicsWorld *dynamics_world;
     btSoftBodyWorldInfo *world_info;
     btSoftBodySolver *soft_solver;
     btOverlapFilterCallback *filter_cb;

     EPhysics_Body *boundaries[6];
     EPhysics_Camera *camera;
     Eina_Inlist *callbacks;
     Eina_Inlist *bodies;
     Eina_List *to_delete;
     Eina_List *cb_to_delete;
     Eina_List *constraints;
     Ecore_Thread *simulation_th;
     Ecore_Thread *cur_th;
     int max_sub_steps;
     int cb_walking;
     int soft_body_ref;
     int pending_ticks;
     double last_update;
     double rate;
     double fixed_time_step;
     double max_sleeping_time;
     Eina_Lock mutex;
     Eina_Condition condition;

     struct {
          Evas_Coord lx;
          Evas_Coord ly;
          Evas_Coord lz;
          int lr;
          int lg;
          int lb;
          int ar;
          int ag;
          int ab;
          Eina_Bool all_bodies:1;
     } light;

     Eina_Bool running:1;
     Eina_Bool ticked:1;
     Eina_Bool active:1;
     Eina_Bool deleted:1;
     Eina_Bool outside_autodel:1;
     Eina_Bool outside_top:1;
     Eina_Bool outside_bottom:1;
     Eina_Bool outside_left:1;
     Eina_Bool outside_right:1;
     Eina_Bool outside_front:1;
     Eina_Bool outside_back:1;
     Eina_Bool pending_simulation:1;
     Eina_Bool stacking:1;
     Eina_Bool force_update:1;
};

static int _ephysics_world_init_count = 0;
static int _worlds_running = 0;
static Eina_Inlist *_worlds = NULL;
static Eina_List *_worlds_to_delete = NULL;
static Ecore_Animator *_anim_simulate = NULL;
static int _worlds_walking = 0;

void
ephysics_world_force_update_set(EPhysics_World *world, Eina_Bool force_update)
{
   world->force_update = force_update;
}

btSoftBodyWorldInfo *
ephysics_world_info_get(const EPhysics_World *world)
{
   return world->world_info;
}

struct _ephysics_world_ovelap_filter_cb : public btOverlapFilterCallback
{
   virtual bool needBroadphaseCollision(btBroadphaseProxy* proxy0,
                                        btBroadphaseProxy* proxy1) const
   {
      btCollisionObject *coll0 = (btCollisionObject *)proxy0->m_clientObject;
      btCollisionObject *coll1 = (btCollisionObject *)proxy1->m_clientObject;

      EPhysics_Body *body0 = (EPhysics_Body *)coll0->getUserPointer();
      EPhysics_Body *body1 = (EPhysics_Body *)coll1->getUserPointer();

      if ((!body0 || !body1) || (ephysics_body_filter_collision(body0, body1)))
        return EINA_TRUE;

      return EINA_FALSE;
   }
};

static inline void
_ephysics_world_gravity_set(EPhysics_World *world, double gx, double gy, double gz, double rate)
{
   btVector3 gravity;

   gravity = btVector3(gx / rate, -gy / rate, gz / rate);
   world->dynamics_world->setGravity(gravity);
   world->world_info->m_gravity = gravity;
}

static void
_ephysics_world_th_cancel(EPhysics_World *world)
{
   _worlds = eina_inlist_remove(_worlds, EINA_INLIST_GET(world));
   if (!ecore_thread_cancel(world->simulation_th))
     eina_condition_signal(&world->condition);
}

static void
_ephysics_world_event_callback_call(EPhysics_World *world, EPhysics_Callback_World_Type type, void *event_info)
{
   EPhysics_World_Callback *cb;
   void *clb;

   world->cb_walking++;
   EINA_INLIST_FOREACH(world->callbacks, cb)
     {
        if ((cb->type == type) && (!cb->deleted))
          cb->func(cb->data, world, event_info);
     }
   world->cb_walking--;

   if (world->cb_walking > 0) return;

   EINA_LIST_FREE(world->cb_to_delete, clb)
     {
        cb = (EPhysics_World_Callback *)clb;
        world->callbacks = eina_inlist_remove(world->callbacks,
                                              EINA_INLIST_GET(cb));
        free(cb);
     }
}

static void
_ephysics_world_event_callback_del(EPhysics_World *world, EPhysics_World_Callback *cb)
{
   if (cb->deleted) return;

   cb->deleted = EINA_TRUE;

   if (world->cb_walking)
     {
        world->cb_to_delete = eina_list_append(world->cb_to_delete, cb);
        return;
     }

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

static void
_ephysics_world_tick(btDynamicsWorld *dynamics_world)
{
   Eina_Bool world_active, camera_moved, tx, ty;
   btCollisionObjectArray objects;
   btCollisionObject *collision;
   EPhysics_World *world;
   EPhysics_Body *body;
   btRigidBody *rigid_body;

   world = (EPhysics_World *) dynamics_world->getWorldUserInfo();

   world_active = EINA_FALSE;

   ephysics_camera_tracked_body_get(world->camera, &body, &tx, &ty);
   if ((body) && (tx || ty))
     {
        rigid_body = ephysics_body_rigid_body_get(body);
        if ((rigid_body) && (rigid_body->isActive()))
          ephysics_camera_target_moved(world->camera, body);
     }

   camera_moved = ephysics_camera_moved_get(world->camera);

   objects = dynamics_world->getCollisionObjectArray();
   for (int i = 0; i < objects.size(); i++)
     {
        collision = objects[i];

        if (!collision)
          continue;

        body = (EPhysics_Body *) collision->getUserPointer();
        if (collision->isActive())
          {
             ephysics_body_active_set(body, EINA_TRUE);
             ephysics_body_evas_object_update_select(body);
             world_active = EINA_TRUE;
          }
        else
          {
             ephysics_body_active_set(body, EINA_FALSE);
             if (camera_moved || world->force_update)
               ephysics_body_evas_object_update_select(body);
          }
     }

   if (world->stacking)
     ephysics_body_evas_objects_restack(world);

   world->force_update = EINA_FALSE;
   if (camera_moved)
     {
        ephysics_camera_moved_set(world->camera, EINA_FALSE);
        _ephysics_world_event_callback_call(
           world, EPHYSICS_CALLBACK_WORLD_CAMERA_MOVED, world->camera);
     }

   if (world->active == world_active) goto body_del;
   world->active = world_active;
   if (world_active) goto body_del;

   _ephysics_world_event_callback_call(world, EPHYSICS_CALLBACK_WORLD_STOPPED,
                                       NULL);

body_del:
   if (world_active)
     _ephysics_world_event_callback_call(world, EPHYSICS_CALLBACK_WORLD_UPDATE,
                                         NULL);
   world->pending_ticks--;
   if (!world->pending_ticks)
     {
        void *bd;
        EINA_LIST_FREE(world->to_delete, bd)
           ephysics_world_body_del(world, (EPhysics_Body*)bd);
     }

   if ((world->pending_simulation) && (!world->pending_ticks))
     {
        world->pending_simulation = EINA_FALSE;
        eina_condition_signal(&world->condition);
     }
}

static void
_ephysics_world_tick_dispatch(EPhysics_World *world)
{
   Simulation_Msg *msg;

   if (!world->ticked)
     return;

   world->ticked = EINA_FALSE;
   world->pending_ticks++;

   msg = (Simulation_Msg *) calloc(1, sizeof(Simulation_Msg));
   msg->tick = EINA_TRUE;
   ecore_thread_feedback(world->cur_th, msg);
}

static void
_ephysics_world_tick_cb(btDynamicsWorld *dynamics_world, btScalar timeStep EINA_UNUSED)
{
   EPhysics_World *world;
   world = (EPhysics_World *) dynamics_world->getWorldUserInfo();
   world->ticked = EINA_TRUE;
}

static void
_ephysics_world_body_del(EPhysics_World *world, EPhysics_Body *body)
{
   btSoftBody *soft_body;

   if (ephysics_body_rigid_body_get(body))
     world->dynamics_world->removeRigidBody(ephysics_body_rigid_body_get(body));

   soft_body = ephysics_body_soft_body_get(body);
   if (soft_body)
     {
        world->dynamics_world->removeSoftBody(soft_body);
        --world->soft_body_ref;
     }

   world->bodies = eina_inlist_remove(world->bodies, EINA_INLIST_GET(body));
   ephysics_orphan_body_del(body);
}

static void
_ephysics_world_boundary_del(EPhysics_World *world, EPhysics_Body *body)
{
   int i;

   for (i = 0; i < EPHYSICS_WORLD_BOUNDARY_LAST; i++)
     {
        if (world->boundaries[i] == body)
          {
             world->boundaries[i] = NULL;
             return;
          }
     }
}

Eina_Bool
ephysics_world_body_del(EPhysics_World *world, EPhysics_Body *body)
{
   EPhysics_Body *bd;

   if (body->boundary)
     _ephysics_world_boundary_del(world, body);

   if (world->pending_ticks)
     {
        world->to_delete = eina_list_append(world->to_delete, body);
        return EINA_FALSE;
     }

   _ephysics_world_body_del(world, body);

   /* Activate all the bodies after a body is deleted.
      Otherwise it can lead to scenarios when a body 1, below body 2 is deleted
      and body 2 will stay freezed in the air. Gravity won't start to
      act over it until it's activated again. */
   EINA_INLIST_FOREACH(world->bodies, bd)
     ephysics_body_activate(bd, EINA_TRUE);

   return EINA_TRUE;
}

static void
_ephysics_world_free(EPhysics_World *world)
{
   EPhysics_World_Callback *cb;
   EPhysics_Body *body;
   void *constraint;

   while (world->callbacks)
     {
        cb = EINA_INLIST_CONTAINER_GET(world->callbacks,
                                       EPhysics_World_Callback);
        world->callbacks = eina_inlist_remove(world->callbacks,
                                              world->callbacks);
        free(cb);
     }

   while (world->bodies)
     {
        body = EINA_INLIST_CONTAINER_GET(world->bodies, EPhysics_Body);
        _ephysics_world_body_del(world, body);
     }

   EINA_LIST_FREE(world->constraints, constraint)
      ephysics_constraint_del((EPhysics_Constraint *)constraint);

   ephysics_camera_del(world->camera);

   delete world->filter_cb;
   delete world->dynamics_world;
   delete world->solver;
   delete world->broadphase;
   delete world->dispatcher;
   delete world->collision;
   delete world->soft_solver;
   delete world->world_info;

   eina_condition_free(&world->condition);
   eina_lock_free(&world->mutex);

   INF("World %p deleted.", world);
   free(world);
   ephysics_dom_count_dec();
}

static Eina_Bool
_simulate_worlds(void *data EINA_UNUSED)
{
   EPhysics_World *world;
   void *wrld;

   ephysics_init();
   _worlds_walking++;
   EINA_INLIST_FOREACH(_worlds, world)
     {
        if (!world->running)
          continue;

        if (world->pending_ticks)
          {
             world->pending_simulation = EINA_TRUE;
             continue;
          }

        world->pending_simulation = EINA_FALSE;

        eina_condition_signal(&world->condition);
     }
   _worlds_walking--;

   if (_worlds_walking > 0)
     {
        ephysics_shutdown();
        return EINA_TRUE;
     }

   EINA_LIST_FREE(_worlds_to_delete, wrld)
      _ephysics_world_th_cancel((EPhysics_World *)wrld);

   ephysics_shutdown();

   return EINA_TRUE;
}

static bool
_ephysics_world_contact_processed_cb(btManifoldPoint &cp, void *b0, void *b1)
{
   btRigidBody *rigid_body_0, *rigid_body_1;
   EPhysics_Body *body_0, *body_1;
   EPhysics_World *world;
   Simulation_Msg *msg;

   rigid_body_0 = (btRigidBody *) b0;
   rigid_body_1 = (btRigidBody *) b1;

   body_0 = (EPhysics_Body *) rigid_body_0->getUserPointer();
   body_1 = (EPhysics_Body *) rigid_body_1->getUserPointer();

   world = ephysics_body_world_get(body_0);

   msg = (Simulation_Msg *) calloc(1, sizeof(Simulation_Msg));
   msg->body_0 = body_0;
   msg->body_1 = body_1;
   msg->pos_a = cp.getPositionWorldOnA();
   msg->pos_b = cp.getPositionWorldOnB();
   ecore_thread_feedback(world->cur_th, msg);

   return EINA_TRUE;
}

Eina_Bool
ephysics_world_body_add(EPhysics_World *world, EPhysics_Body *body)
{
   if (!eina_inlist_find(world->bodies, EINA_INLIST_GET(body)))
       world->bodies = eina_inlist_append(world->bodies, EINA_INLIST_GET(body));

   if (eina_error_get())
     {
        ERR("Couldn't add body to bodies list.");
        return EINA_FALSE;
     }

   world->dynamics_world->addRigidBody(ephysics_body_rigid_body_get(body));
   return EINA_TRUE;
}

Eina_Bool
ephysics_world_soft_body_add(EPhysics_World *world, EPhysics_Body *body)
{
   if (!eina_inlist_find(world->bodies, EINA_INLIST_GET(body)))
       world->bodies = eina_inlist_append(world->bodies, EINA_INLIST_GET(body));

   if (eina_error_get())
     {
        ERR("Couldn't add body to bodies list.");
        return EINA_FALSE;
     }

   ++world->soft_body_ref;
   world->dynamics_world->addSoftBody(ephysics_body_soft_body_get(body));
   return EINA_TRUE;
}

Eina_List *
ephysics_world_constraints_get(EPhysics_World *world)
{
   return world->constraints;
}

void
ephysics_world_constraint_add(EPhysics_World *world, EPhysics_Constraint *constraint, btGeneric6DofConstraint *bt_constraint)
{
   world->dynamics_world->addConstraint(bt_constraint, true);
   world->constraints = eina_list_append(world->constraints, constraint);
}

void
ephysics_world_constraint_del(EPhysics_World *world, EPhysics_Constraint *constraint, btGeneric6DofConstraint *bt_constraint)
{
   world->dynamics_world->removeConstraint(bt_constraint);
   world->constraints = eina_list_remove(world->constraints, constraint);
}

int
ephysics_world_init(void)
{
   if (++_ephysics_world_init_count != 1)
     return _ephysics_world_init_count;

   gContactProcessedCallback = _ephysics_world_contact_processed_cb;

   INF("EPhysics World initialized.");

   return _ephysics_world_init_count;
}

int
ephysics_world_shutdown(void)
{
   if (--_ephysics_world_init_count != 0)
     return _ephysics_world_init_count;

   if (_anim_simulate)
     {
        ecore_animator_del(_anim_simulate);
        _anim_simulate = NULL;
     }

   while (_worlds)
     {
        EPhysics_World *world = EINA_INLIST_CONTAINER_GET(
           _worlds, EPhysics_World);
        ephysics_world_del(world);
     }

   _worlds_running = 0;

   INF("EPhysics World shutdown.");

   return _ephysics_world_init_count;
}

void
ephysics_world_boundary_set(EPhysics_World *world, EPhysics_World_Boundary boundary, EPhysics_Body *body)
{
   world->boundaries[boundary] = body;
}

EPhysics_Body *
ephysics_world_boundary_get(const EPhysics_World *world, EPhysics_World_Boundary boundary)
{
   return world->boundaries[boundary];
}

static void
_th_simulate(void *data, Ecore_Thread *th)
{
   EPhysics_World *world = (EPhysics_World *) data;

   while (1)
     {
        double time_now, delta;
        EPhysics_Body *body;

        eina_condition_wait(&world->condition);
        if (ecore_thread_check(th))
          {
             INF("Thread canceled by main loop thread");
             eina_lock_release(&world->mutex);
             return;
          }

        world->pending_ticks++;
        world->cur_th = th;

        EINA_INLIST_FOREACH(world->bodies, body)
          {
             ephysics_body_forces_apply(body);
             if (body->dragging_data.dragging)
               ephysics_body_soft_body_dragging_apply(body);

             if (body->bending_constraints)
               ephysics_body_soft_body_bending_constraints_generate(body);
          }

        time_now = ecore_time_get();
        delta = time_now - world->last_update;
        world->last_update = time_now;

        gDeactivationTime = world->max_sleeping_time;

        if (world->soft_body_ref)
          {
             world->dynamics_world->stepSimulation(delta, world->max_sub_steps,
                                                world->fixed_time_step);
             world->world_info->m_sparsesdf.GarbageCollect();
          }
        else
          ((btDiscreteDynamicsWorld *)world->dynamics_world)->stepSimulation(
             delta, world->max_sub_steps, world->fixed_time_step);

        _ephysics_world_tick_dispatch(world);
        world->pending_ticks--;
        eina_lock_release(&world->mutex);
     }
}

static void
_th_msg_cb(void *data, Ecore_Thread *th EINA_UNUSED, void *msg_data)
{
   EPhysics_World *world = (EPhysics_World *) data;
   Simulation_Msg *msg = (Simulation_Msg *) msg_data;

   if (msg->tick)
     _ephysics_world_tick(world->dynamics_world);
   else
     {
        ephysics_body_contact_processed(msg->body_0, msg->body_1, msg->pos_a);
        ephysics_body_contact_processed(msg->body_1, msg->body_0, msg->pos_b);
     }
   free(msg);
}

static void
_th_end_cb(void *data, Ecore_Thread *th)
{
   EPhysics_World *world = (EPhysics_World *) data;
   INF("World %p simulation thread %p end", world, th);
   world->simulation_th = NULL;
   _ephysics_world_free(world);
}

static void
_th_cancel_cb(void *data, Ecore_Thread *th)
{
   EPhysics_World *world = (EPhysics_World *) data;
   INF("World %p simulation thread %p canceled", world, th);
   world->simulation_th = NULL;
   _ephysics_world_free(world);
}

EAPI EPhysics_World *
ephysics_world_new(void)
{
   EPhysics_World *world;

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

   world->camera = ephysics_camera_add(world);
   if (!world->camera)
     {
        ERR("Couldn't create a camera for this world.");
        goto no_camera;
     }

   world->broadphase = new btDbvtBroadphase();
   if (!world->broadphase)
     {
        ERR("Couldn't set broadphase.");
        goto no_broadphase;
     }

   world->collision = new btSoftBodyRigidBodyCollisionConfiguration();
   if (!world->collision)
     {
        ERR("Couldn't configure collision.");
        goto no_collision;
     }

   world->dispatcher = new btCollisionDispatcher(world->collision);
   if (!world->dispatcher)
     {
        ERR("Couldn't create dispatcher.");
        goto no_dispatcher;
     }

   world->solver = new btSequentialImpulseConstraintSolver;
   if (!world->solver)
     {
        ERR("Couldn't create solver.");
        goto no_solver;
     }

   world->soft_solver = new btDefaultSoftBodySolver();
   if (!world->soft_solver)
     {
        ERR("Couldn't create soft body solver.");
        goto no_soft_solver;
     }

   world->dynamics_world = new btSoftRigidDynamicsWorld(
      world->dispatcher, world->broadphase, world->solver,
      world->collision, world->soft_solver);
   if (!world->dynamics_world)
     {
        ERR("Couldn't create dynamic world.");
        goto no_world;
     }

   world->world_info = new btSoftBodyWorldInfo();
   if (!world->world_info)
     {
        ERR("Couldn't create soft body world info.");
        goto no_world_info;
     }

   world->world_info->m_gravity = DEFAULT_GRAVITY;
   world->world_info->m_broadphase = world->broadphase;
   world->world_info->m_dispatcher = world->dispatcher;
   world->world_info->m_sparsesdf.Initialize();

   _worlds = eina_inlist_append(_worlds, EINA_INLIST_GET(world));
   if (eina_error_get())
     {
        ERR("Couldn't add world to worlds list.");
        goto no_list;
     }
   world->simulation_th = ecore_thread_feedback_run(
      _th_simulate, _th_msg_cb, _th_end_cb, _th_cancel_cb, world, EINA_TRUE);
   if (!world->simulation_th)
     {
        ERR("Failed to create simulation thread.");
        goto no_thread;
     }
   eina_lock_new(&world->mutex);
   eina_condition_new(&world->condition, &world->mutex);

   world->dynamics_world->getSolverInfo().m_solverMode ^=
      EPHYSICS_WORLD_SOLVER_SIMD;
   world->dynamics_world->setGravity(DEFAULT_GRAVITY);

   world->filter_cb = new _ephysics_world_ovelap_filter_cb();
   if (!world->filter_cb)
     INF("Couldn't initialize the collision filter.");
   else
     world->dynamics_world->getPairCache()->setOverlapFilterCallback(
        world->filter_cb);

   world->light.lr = 255;
   world->light.lg = 255;
   world->light.lb = 255;
   world->light.lz = -200;

   world->stacking = EINA_TRUE;
   world->rate = 30;
   world->max_sub_steps = 3;
   world->fixed_time_step = 1/60.f;
   world->dynamics_world->setInternalTickCallback(_ephysics_world_tick_cb,
                                                  (void *) world);

   world->max_sleeping_time = 2.0;
   world->running = EINA_TRUE;
   world->last_update = ecore_time_get();
   _worlds_running++;
   if (!_anim_simulate)
     _anim_simulate = ecore_animator_add(_simulate_worlds, NULL);

   ephysics_dom_count_inc();
   INF("World %p added.", world);
   return world;

no_thread:
   _worlds = eina_inlist_remove(_worlds, EINA_INLIST_GET(world));
no_list:
   delete world->world_info;
no_world_info:
   delete world->dynamics_world;
no_world:
   delete world->soft_solver;
no_soft_solver:
   delete world->solver;
no_solver:
   delete world->dispatcher;
no_dispatcher:
   delete world->collision;
no_collision:
   delete world->broadphase;
no_broadphase:
   ephysics_camera_del(world->camera);
no_camera:
   free(world);
   return NULL;
}

EAPI Eina_Bool
ephysics_world_serialize(EPhysics_World *world, const char *path)
{
   btDefaultSerializer *serializer;
   FILE *file;

   if (!world)
     {
        WRN("Could not serialize, world not provided.");
        return EINA_FALSE;
      }

   eina_lock_take(&world->mutex);

   file = fopen(path, "wb");
   if (!file)
     {
        WRN("Could not serialize, could not open file: %s", path);
        eina_lock_release(&world->mutex);
        return EINA_FALSE;
     }

   serializer = new btDefaultSerializer();
   world->dynamics_world->serialize(serializer);

   if (!fwrite(serializer->getBufferPointer(),
              serializer->getCurrentBufferSize(), 1, file))
     {
        WRN("Problems on writing to: %s.", path);
        fclose(file);
        delete serializer;
        eina_lock_release(&world->mutex);
        return EINA_FALSE;
     }

   fclose(file);
   delete serializer;

   INF("Serialization of world %p written to file: %s.", world, path);

   eina_lock_release(&world->mutex);
   return EINA_TRUE;
}

static void
_ephysics_world_running_set(EPhysics_World *world, Eina_Bool running)
{
   if ((!!running) == world->running) return;

   world->running = !!running;

   if (world->running)
     {
        world->last_update = ecore_time_get();
        _worlds_running++;
        INF("World unpaused.");
     }
   else
     {
        _worlds_running--;
        INF("World paused.");
     }

   if (!_worlds_running)
     {
        if (_anim_simulate)
          {
             ecore_animator_del(_anim_simulate);
             _anim_simulate = NULL;
          }
        return;
     }

   if (_anim_simulate)
     return;

   _anim_simulate = ecore_animator_add(_simulate_worlds, NULL);
}

EAPI void
ephysics_world_del(EPhysics_World *world)
{
   if (!world)
     {
        ERR("Can't delete world, it wasn't provided.");
        return;
     }

   if (world->deleted) return;

   eina_lock_take(&world->mutex);

   world->deleted = EINA_TRUE;
   _ephysics_world_event_callback_call(world, EPHYSICS_CALLBACK_WORLD_DEL,
                                       NULL);
   _ephysics_world_running_set(world, EINA_FALSE);

   if (_worlds_walking > 0)
     {
        _worlds_to_delete = eina_list_append(_worlds_to_delete, world);
        INF("World %p marked to delete.", world);
        eina_lock_release(&world->mutex);
        return;
     }

   eina_lock_release(&world->mutex);
   _ephysics_world_th_cancel(world);
}

EAPI void
ephysics_world_running_set(EPhysics_World *world, Eina_Bool running)
{
   if (!world)
     {
        ERR("Can't (un)pause world, it wasn't provided.");
        return;
     }

   eina_lock_take(&world->mutex);
   _ephysics_world_running_set(world, running);
   eina_lock_release(&world->mutex);
}

EAPI Eina_Bool
ephysics_world_running_get(const EPhysics_World *world)
{
   if (!world)
     {
	ERR("No world, no running status for you.");
	return EINA_FALSE;
     }

   return world->running;
}

EAPI void
ephysics_world_max_sleeping_time_set(EPhysics_World *world, double sleeping_time)
{
   if (!world)
     {
	ERR("Can't set the world's max sleeping time, world is null.");
	return;
     }

   eina_lock_take(&world->mutex);
   world->max_sleeping_time = sleeping_time;
   eina_lock_release(&world->mutex);
}

EAPI double
ephysics_world_max_sleeping_time_get(const EPhysics_World *world)
{
   if (!world)
     {
	ERR("Can't get the world's max sleeping time, world is null.");
	return 0;
     }

   return world->max_sleeping_time;
}

EAPI void
ephysics_world_gravity_set(EPhysics_World *world, double gx, double gy, double gz)
{
   EPhysics_Body *bd;

   if (!world)
     {
        ERR("Can't set gravity, no world provided.");
        return;
     }

   eina_lock_take(&world->mutex);
   EINA_INLIST_FOREACH(world->bodies, bd)
      ephysics_body_activate(bd, EINA_TRUE);
   _ephysics_world_gravity_set(world, gx, gy, gz, world->rate);
   DBG("World %p gravity set to X:%lf, Y:%lf, Z: %lf.", world, gx, gy, gz);
   eina_lock_release(&world->mutex);
}

EAPI void
ephysics_world_constraint_solver_iterations_set(EPhysics_World *world, int iterations)
{
   if (!world)
     {
        ERR("Can't set constraint solver iterations, world is null.");
        return;
     }

   eina_lock_take(&world->mutex);
   world->dynamics_world->getSolverInfo().m_numIterations = iterations;
   eina_lock_release(&world->mutex);
}

EAPI int
ephysics_world_constraint_solver_iterations_get(const EPhysics_World *world)
{
   if (!world)
     {
        ERR("Can't get constraint solver iterations, world is null.");
        return 0;
     }

   return world->dynamics_world->getSolverInfo().m_numIterations;
}

EAPI void
ephysics_world_constraint_solver_mode_enable_set(EPhysics_World *world, EPhysics_World_Solver_Mode solver_mode, Eina_Bool enable)
{
   int current_solver_mode;
    if (!world)
     {
        ERR("Can't enable/disable constraint solver mode, world is null.");
        return;
     }

   eina_lock_take(&world->mutex);
   current_solver_mode = world->dynamics_world->getSolverInfo().m_solverMode;
   if ((enable && !(current_solver_mode & solver_mode)) ||
       (!enable && (current_solver_mode & solver_mode)))
     world->dynamics_world->getSolverInfo().m_solverMode ^= solver_mode;
   eina_lock_release(&world->mutex);
}

EAPI Eina_Bool
ephysics_world_constraint_solver_mode_enable_get(const EPhysics_World *world, EPhysics_World_Solver_Mode solver_mode)
{
     if (!world)
     {
        ERR("Can't get constraint solver mode status, world is null.");
        return EINA_FALSE;
     }

     return world->dynamics_world->getSolverInfo().m_solverMode & solver_mode;
}

EAPI void
ephysics_world_gravity_get(const EPhysics_World *world, double *gx, double *gy, double *gz)
{
   btVector3 vector;

   if (!world)
     {
	ERR("No world, can't get gravity.");
	return;
     }

   vector = world->dynamics_world->getGravity();

   if (gx) *gx = vector.x() * world->rate;
   if (gy) *gy = -vector.y() * world->rate;
   if (gz) *gz = vector.z() * world->rate;
}

EAPI void
ephysics_world_rate_set(EPhysics_World *world, double rate)
{
   EPhysics_Body *body;
   double gx, gy, gz;
   void *constraint;
   Eina_List *l;

   if (!world)
     {
	ERR("No world, can't set rate.");
	return;
     }

   if (rate <= 0)
     {
	ERR("Rate should be a positive value. Keeping the old value: %lf.",
            world->rate);
        return;
     }

   eina_lock_take(&world->mutex);
   /* Force to recalculate sizes, velocities and accelerations with new rate */
   ephysics_world_gravity_get(world, &gx, &gy, &gz);
   _ephysics_world_gravity_set(world, gx, gy, gz, rate);

   EINA_INLIST_FOREACH(world->bodies, body)
      ephysics_body_recalc(body, rate);

   EINA_LIST_FOREACH(world->constraints, l, constraint)
        ephysics_constraint_recalc((EPhysics_Constraint *)constraint, rate);

   world->rate = rate;
   eina_lock_release(&world->mutex);
}

EAPI double
ephysics_world_rate_get(const EPhysics_World *world)
{
   if (!world)
     {
	ERR("No world, can't get rate.");
	return 0;
     }

   return world->rate;
}

EAPI EPhysics_Camera *
ephysics_world_camera_get(const EPhysics_World *world)
{
   if (!world)
     {
	ERR("No world, no camera for you.");
	return NULL;
     }

   return world->camera;
}

EAPI void
ephysics_world_event_callback_add(EPhysics_World *world, EPhysics_Callback_World_Type type, EPhysics_World_Event_Cb func, const void *data)
{
   EPhysics_World_Callback *cb;

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

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

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

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

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

   world->callbacks = eina_inlist_append(world->callbacks, EINA_INLIST_GET(cb));
}

EAPI void *
ephysics_world_event_callback_del(EPhysics_World *world, EPhysics_Callback_World_Type type, EPhysics_World_Event_Cb func)
{
   EPhysics_World_Callback *cb;
   void *cb_data = NULL;

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

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

        cb_data = cb->data;
        _ephysics_world_event_callback_del(world, cb);
        break;
     }

   return cb_data;
}

EAPI void *
ephysics_world_event_callback_del_full(EPhysics_World *world, EPhysics_Callback_World_Type type, EPhysics_World_Event_Cb func, void *data)
{
   EPhysics_World_Callback *cb;
   void *cb_data = NULL;

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

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

        cb_data = cb->data;
        _ephysics_world_event_callback_del(world, cb);
        break;
     }

   return cb_data;
}

EAPI Eina_List *
ephysics_world_bodies_get(const EPhysics_World *world)
{
   Eina_List *list = NULL;
   EPhysics_Body *body;

   if (!world)
     {
        ERR("Couldn't get the bodies list, no world provided.");
        return NULL;
     }

   EINA_INLIST_FOREACH(world->bodies, body)
      list = eina_list_append(list, body);

   return list;
}

EAPI void
ephysics_world_render_geometry_set(EPhysics_World *world, Evas_Coord x, Evas_Coord y, Evas_Coord z, Evas_Coord w, Evas_Coord h, Evas_Coord d)
{
   if (!world)
     {
        ERR("Can't set geometry, world wasn't provided.");
        return;
     }

   if ((w <= 0) || (h <= 0) || (d <= 0))
     {
        ERR("Invalid width or height sizes. They must to be positive values.");
        return;
     }

   world->geometry.x = x;
   world->geometry.y = y;
   world->geometry.z = z;
   world->geometry.w = w;
   world->geometry.h = h;
   world->geometry.d = d;

   INF("World %p render geometry set: x=%i y=%i z=%i w=%i h=%i d=%i",
       world, x, y, z, w, h, d);

   ephysics_camera_perspective_set(world->camera, x + w / 2, y + h / 2,
                                   z + d / 2, 10 * (z + d));

   ephysics_body_world_boundaries_resize(world);
   ephysics_camera_position_set(world->camera, x, y);
}

EAPI void
ephysics_world_render_geometry_get(const EPhysics_World *world, Evas_Coord *x, Evas_Coord *y, Evas_Coord *z, Evas_Coord *w, Evas_Coord *h, Evas_Coord *d)
{
   if (!world)
     {
        ERR("Can't get geometry, world is null.");
        return;
     }

   if (x) *x = world->geometry.x;
   if (y) *y = world->geometry.y;
   if (z) *z = world->geometry.z;
   if (w) *w = world->geometry.w;
   if (h) *h = world->geometry.h;
   if (d) *d = world->geometry.d;
}

EAPI void
ephysics_world_linear_slop_set(EPhysics_World *world, double linear_slop)
{
   if (!world)
     {
        ERR("Can't set linear slop, world is null.");
        return;
     }

   eina_lock_take(&world->mutex);
   world->dynamics_world->getSolverInfo().m_linearSlop = btScalar(linear_slop);
   eina_lock_release(&world->mutex);
}

EAPI double
ephysics_world_linear_slop_get(const EPhysics_World *world)
{
   if (!world)
     {
        ERR("Can't get linear slop, world is null.");
        return 0;
     }

   return world->dynamics_world->getSolverInfo().m_linearSlop;
}

EAPI void
ephysics_world_bodies_outside_top_autodel_set(EPhysics_World *world, Eina_Bool autodel)
{
   if (!world)
     {
        ERR("Can't set autodelete mode, world is null.");
        return;
     }

   world->outside_top = !!autodel;
   world->outside_autodel = world->outside_top || world->outside_bottom ||
      world->outside_left || world->outside_right ||
      world->outside_front || world->outside_back;
}

EAPI Eina_Bool
ephysics_world_bodies_outside_top_autodel_get(const EPhysics_World *world)
{
   if (!world)
     {
        ERR("Can't get autodelete mode, world is null.");
        return EINA_FALSE;
     }

   return world->outside_top;
}

EAPI void
ephysics_world_bodies_outside_bottom_autodel_set(EPhysics_World *world, Eina_Bool autodel)
{
   if (!world)
     {
        ERR("Can't set autodelete mode, world is null.");
        return;
     }

   world->outside_bottom = !!autodel;
   world->outside_autodel = world->outside_top || world->outside_bottom ||
      world->outside_left || world->outside_right ||
      world->outside_front || world->outside_back;
}

EAPI Eina_Bool
ephysics_world_bodies_outside_bottom_autodel_get(const EPhysics_World *world)
{
   if (!world)
     {
        ERR("Can't get autodelete mode, world is null.");
        return EINA_FALSE;
     }

   return world->outside_bottom;
}

EAPI void
ephysics_world_bodies_outside_left_autodel_set(EPhysics_World *world, Eina_Bool autodel)
{
   if (!world)
     {
        ERR("Can't set autodelete mode, world is null.");
        return;
     }

   world->outside_left = !!autodel;
   world->outside_autodel = world->outside_top || world->outside_bottom ||
      world->outside_left || world->outside_right ||
      world->outside_front || world->outside_back;
}

EAPI Eina_Bool
ephysics_world_bodies_outside_left_autodel_get(const EPhysics_World *world)
{
   if (!world)
     {
        ERR("Can't get autodelete mode, world is null.");
        return EINA_FALSE;
     }

   return world->outside_left;
}

EAPI void
ephysics_world_bodies_outside_right_autodel_set(EPhysics_World *world, Eina_Bool autodel)
{
   if (!world)
     {
        ERR("Can't set autodelete mode, world is null.");
        return;
     }

   world->outside_right = !!autodel;
   world->outside_autodel = world->outside_top || world->outside_bottom ||
      world->outside_left || world->outside_right ||
      world->outside_front || world->outside_back;
}

EAPI Eina_Bool
ephysics_world_bodies_outside_right_autodel_get(const EPhysics_World *world)
{
   if (!world)
     {
        ERR("Can't get autodelete mode, world is null.");
        return EINA_FALSE;
     }

   return world->outside_right;
}

EAPI void
ephysics_world_bodies_outside_front_autodel_set(EPhysics_World *world, Eina_Bool autodel)
{
   if (!world)
     {
        ERR("Can't set autodelete mode, world is null.");
        return;
     }

   world->outside_front = !!autodel;
   world->outside_autodel = world->outside_top || world->outside_bottom ||
      world->outside_left || world->outside_right ||
      world->outside_front || world->outside_back;
}

EAPI Eina_Bool
ephysics_world_bodies_outside_front_autodel_get(const EPhysics_World *world)
{
   if (!world)
     {
        ERR("Can't get autodelete mode, world is null.");
        return EINA_FALSE;
     }

   return world->outside_front;
}

EAPI void
ephysics_world_bodies_outside_back_autodel_set(EPhysics_World *world, Eina_Bool autodel)
{
   if (!world)
     {
        ERR("Can't set autodelete mode, world is null.");
        return;
     }

   world->outside_back = !!autodel;
   world->outside_autodel = world->outside_top || world->outside_bottom ||
      world->outside_left || world->outside_right ||
      world->outside_front || world->outside_back;
}

EAPI Eina_Bool
ephysics_world_bodies_outside_back_autodel_get(const EPhysics_World *world)
{
   if (!world)
     {
        ERR("Can't get autodelete mode, world is null.");
        return EINA_FALSE;
     }

   return world->outside_back;
}

EAPI Eina_Bool
ephysics_world_bodies_outside_autodel_get(const EPhysics_World *world)
{
   if (!world)
     {
        ERR("Can't get autodelete mode, world is null.");
        return EINA_FALSE;
     }

   return world->outside_autodel;
}

EAPI void
ephysics_world_simulation_set(EPhysics_World *world, double fixed_time_step, int max_sub_steps)
{
   if (!world)
     {
        ERR("Can't set simulation, no world provided.");
        return;
     }

   if (max_sub_steps < 1)
     {
        ERR("At least one sub step for simulation is required.");
        return;
     }

   if (ecore_animator_frametime_get() >= max_sub_steps * fixed_time_step)
     {
        ERR("Assure frametime < max sub steps * fixed time step.");
        return;
     }

   eina_lock_take(&world->mutex);
   world->max_sub_steps = max_sub_steps;
   world->fixed_time_step = fixed_time_step;

   DBG("World %p simulation set to fixed time step: %lf, max substeps:%i.",
       world, fixed_time_step, max_sub_steps);
   eina_lock_release(&world->mutex);
}

EAPI void
ephysics_world_simulation_get(const EPhysics_World *world, double *fixed_time_step, int *max_sub_steps)
{
   if (!world)
     {
	ERR("No world, can't get simulation configuration.");
	return;
     }

   if (fixed_time_step) *fixed_time_step = world->fixed_time_step;
   if (max_sub_steps) *max_sub_steps = world->max_sub_steps;
}

void
ephysics_world_lock_take(EPhysics_World *world)
{
   eina_lock_take(&world->mutex);
}

void
ephysics_world_lock_release(EPhysics_World *world)
{
   eina_lock_release(&world->mutex);
}

EAPI void
ephysics_world_point_light_position_set(EPhysics_World *world, Evas_Coord lx, Evas_Coord ly, Evas_Coord lz)
{
   if (!world)
     {
	ERR("No world, can't set light properties.");
	return;
     }

   world->light.lx = lx;
   world->light.ly = ly;
   world->light.lz = lz;
   world->force_update = EINA_TRUE;
}

EAPI void
ephysics_world_point_light_color_set(EPhysics_World *world, int lr, int lg, int lb)
{
   if (!world)
     {
	ERR("No world, can't set light properties.");
	return;
     }

   world->light.lr = lr;
   world->light.lg = lg;
   world->light.lb = lb;
   world->force_update = EINA_TRUE;
}

EAPI void
ephysics_world_ambient_light_color_set(EPhysics_World *world, int ar, int ag, int ab)
{
   if (!world)
     {
	ERR("No world, can't set light properties.");
	return;
     }

   world->light.ar = ar;
   world->light.ag = ag;
   world->light.ab = ab;
   world->force_update = EINA_TRUE;
}

EAPI void
ephysics_world_ambient_light_color_get(const EPhysics_World *world, int *ar, int *ag, int *ab)
{
   if (!world)
     {
	ERR("No world, can't get light properties.");
	return;
     }

   if (ar) *ar = world->light.ar;
   if (ag) *ag = world->light.ag;
   if (ab) *ab = world->light.ab;
}

EAPI void
ephysics_world_point_light_color_get(const EPhysics_World *world, int *lr, int *lg, int *lb)
{
   if (!world)
     {
	ERR("No world, can't get light properties.");
	return;
     }

   if (lr) *lr = world->light.lr;
   if (lg) *lg = world->light.lg;
   if (lb) *lb = world->light.lb;
}

EAPI void
ephysics_world_point_light_position_get(const EPhysics_World *world, Evas_Coord *lx, Evas_Coord *ly, Evas_Coord *lz)
{
   if (!world)
     {
	ERR("No world, can't get light properties.");
	return;
     }

   if (lx) *lx = world->light.lx;
   if (ly) *ly = world->light.ly;
   if (lz) *lz = world->light.lz;
}

EAPI void
ephysics_world_light_all_bodies_set(EPhysics_World *world, Eina_Bool enable)
{
   if (!world)
     {
	ERR("No world, can't set light property.");
	return;
     }

   world->light.all_bodies = !!enable;
   world->force_update = EINA_TRUE;
}

EAPI Eina_Bool
ephysics_world_light_all_bodies_get(const EPhysics_World *world)
{
   if (!world)
     {
	ERR("No world, can't get light property.");
	return EINA_FALSE;
     }

   return world->light.all_bodies;
}

EAPI void
ephysics_world_stack_enable_set(EPhysics_World *world, Eina_Bool enabled)
{
   if (!world)
     {
        ERR("Can't enable / disable stacking, world wasn't provided.");
        return;
     }
   world->stacking = !!enabled;
}

EAPI Eina_Bool
ephysics_world_stack_enable_get(const EPhysics_World *world)
{
   if (!world)
     {
	ERR("No world, no stacking status for you.");
	return EINA_FALSE;
     }

   return world->stacking;
}

#ifdef  __cplusplus
}
#endif