Asserts, and reformat code

panda/src/ode/odeJoint.cxx

@@ -37,6 +37,7 @@ OdeJoint::
 
 void OdeJoint::
 destroy() {
+  nassertv(_id);
   dJointDestroy(_id);
 }
 
@@ -50,6 +51,7 @@ destroy() {
 ////////////////////////////////////////////////////////////////////
 void OdeJoint::
 attach_bodies(const OdeBody &body1, const OdeBody &body2) {
+  nassertv(_id);
   nassertv(body1.get_id() != 0 && body2.get_id() != 0);
   dJointAttach(_id, body1.get_id(), body2.get_id());
 }
@@ -65,6 +67,7 @@ attach_bodies(const OdeBody &body1, const OdeBody &body2) {
 ////////////////////////////////////////////////////////////////////
 void OdeJoint::
 attach_body(const OdeBody &body, int index) {
+  nassertv(_id);
   nassertv(body.get_id() != 0);
   nassertv(index == 0 || index == 1);
   if (index == 0) {
@@ -76,6 +79,7 @@ attach_body(const OdeBody &body, int index) {
 
 void OdeJoint::
 detach() {
+  nassertv(_id);
   dJointAttach(_id, 0, 0);
 }
 

panda/src/ode/odeSpace.cxx

@@ -50,46 +50,55 @@ OdeSpace::
 
 void OdeSpace::
 destroy() {
+  nassertv(_id);
   dSpaceDestroy(_id);
 }
 
 int OdeSpace::
 query(const OdeGeom& geom) const {
+  nassertr(_id, 0);
   return dSpaceQuery(_id, geom.get_id());
 }
 
 int OdeSpace::
 query(const OdeSpace& space) const {
+  nassertr(_id, 0);
   return dSpaceQuery(_id, (dGeomID)space.get_id());
 }
 
 void OdeSpace::
 add(OdeSpace& space) {
+  nassertv(_id);
   dSpaceAdd(_id, (dGeomID)space.get_id());
 }
 
 void OdeSpace::
 remove(OdeSpace& space) {
+  nassertv(_id);
   dSpaceRemove(_id, (dGeomID)space.get_id());
 }
 
 void OdeSpace::
 add(OdeGeom& geom) {
+  nassertv(_id);
   dSpaceAdd(_id, geom.get_id());
 }
 
 void OdeSpace::
 remove(OdeGeom& geom) {
+  nassertv(_id);
   dSpaceRemove(_id, geom.get_id());
 }
 
 void OdeSpace::
 clean() {
+  nassertv(_id);
   dSpaceClean(_id);
 }
 
 OdeGeom  OdeSpace::
 get_geom(int i) {
+  nassertr(_id, OdeGeom(0));
   return OdeGeom(dSpaceGetGeom(_id, i));
 }
 
@@ -107,170 +116,160 @@ operator bool () const {
 }
 
 void OdeSpace::
-set_auto_collide_world(OdeWorld &world)
-{
-    my_world = &world;
+set_auto_collide_world(OdeWorld &world) {
+  my_world = &world;
 }
 
 void OdeSpace::
-set_auto_collide_joint_group(OdeJointGroup &joint_group)
-{
-    _collide_joint_group = joint_group.get_id();
+set_auto_collide_joint_group(OdeJointGroup &joint_group) {
+  _collide_joint_group = joint_group.get_id();
 }
 
 int OdeSpace::
-auto_collide()
-{
-    if (my_world == NULL) {
-      odespace_cat.error() << "No collide world has been set!\n";
-      return 0;
-    } else {
-      OdeSpace::contactCount = 0;
-      _collide_space = this;
-      _collide_world = my_world;
-      dSpaceCollide(_id, this, &auto_callback);
-      return OdeSpace::contactCount;
-    }
+auto_collide() {
+  if (my_world == NULL) {
+    odespace_cat.error() << "No collide world has been set!\n";
+    return 0;
+  } else {
+    nassertr(_id, 0);
+    OdeSpace::contactCount = 0;
+    _collide_space = this;
+    _collide_world = my_world;
+    dSpaceCollide(_id, this, &auto_callback);
+    return OdeSpace::contactCount;
+  }
 }
 
 double OdeSpace:: 
-get_contact_data(int data_index)
+get_contact_data(int data_index) {
 // get the contact data it looks like so [x1,y1,z1,x2,y2,z2... x64,y64,z64]
 // use the return in from autoCollide to determine how much of the data is
 // valid. The data would be more straight forward but the callbacks have to be
 // static.
-{
-    return OdeSpace::contact_data[data_index];
+  return OdeSpace::contact_data[data_index];
 }
 
 int OdeSpace:: 
-get_contact_id(int data_index, int first)
+get_contact_id(int data_index, int first) {
 // get the contact data it looks like so [x1,y1,z1,x2,y2,z2... x64,y64,z64]
 // use the return in from autoCollide to determine how much of the data is
 // valid. The data would be more straight forward but the callbacks have to be
 // static.
-{
-    if (first == 0)
-    {
-        return OdeSpace::contact_ids[(data_index * 2) + 0];
-    }
-    else
-    {
-        return OdeSpace::contact_ids[(data_index * 2) + 1];
-    }
+  if (first == 0) {
+    return OdeSpace::contact_ids[(data_index * 2) + 0];
+  } else {
+    return OdeSpace::contact_ids[(data_index * 2) + 1];
+  }
 }
 
 void OdeSpace::
-auto_callback(void *data, dGeomID o1, dGeomID o2)
+auto_callback(void *data, dGeomID o1, dGeomID o2) {
 // uses data stored on the world to resolve collisions so you don't have to use near_callbacks in python
-{
-    int i;
-    static int autoCallbackCounter = 0;
-    dBodyID b1 = dGeomGetBody(o1);
-    dBodyID b2 = dGeomGetBody(o2);
-
-    dContact contact[OdeSpace::MAX_CONTACTS];
-        
-    int surface1 = _collide_space->get_surface_type(o1);
-    int surface2 = _collide_space->get_surface_type(o2);
-    
-    nassertv(_collide_world != NULL);
-    sSurfaceParams collide_params;
-    collide_params = _collide_world->get_surface(surface1, surface2);
+  int i;
+  static int autoCallbackCounter = 0;
+  dBodyID b1 = dGeomGetBody(o1);
+  dBodyID b2 = dGeomGetBody(o2);
+
+  dContact contact[OdeSpace::MAX_CONTACTS];
+      
+  int surface1 = _collide_space->get_surface_type(o1);
+  int surface2 = _collide_space->get_surface_type(o2);
+  
+  nassertv(_collide_world != NULL);
+  sSurfaceParams collide_params;
+  collide_params = _collide_world->get_surface(surface1, surface2);
+  
+  for (i=0; i < OdeSpace::MAX_CONTACTS; i++) {
+    contact[i].surface.mode = collide_params.colparams.mode; 
+    contact[i].surface.mu = collide_params.colparams.mu; 
+    contact[i].surface.mu2 = collide_params.colparams.mu2; 
+    contact[i].surface.bounce = collide_params.colparams.bounce; 
+    contact[i].surface.bounce_vel = collide_params.colparams.bounce_vel; 
+    contact[i].surface.soft_cfm = collide_params.colparams.soft_cfm; 
+  }
+  
+  static int numc = 0;
+  numc = dCollide(o1, o2, OdeSpace::MAX_CONTACTS, &contact[0].geom, sizeof(dContact));
+
+  if (numc) {
+    if (odespace_cat.is_debug() && (autoCallbackCounter%30 == 0)) {
+      odespace_cat.debug() << autoCallbackCounter <<" collision between geoms " << o1 << " and " << o2 << "\n";
+      odespace_cat.debug() << "collision between body " << b1 << " and " << b2 << "\n";
+      odespace_cat.debug() << "surface1= "<< surface1 << " surface2=" << surface2 << "\n";
+    }
+    autoCallbackCounter += 1;
+
+    PT(OdeCollisionEntry) entry;
+    if (!_collide_space->_collision_event.empty()) {
+      entry = new OdeCollisionEntry;
+      entry->_geom1 = o1;
+      entry->_geom2 = o2;
+      entry->_body1 = b1;
+      entry->_body2 = b2;
+      entry->_num_points = numc;
+      entry->_points = new LPoint3f[numc];
+    }
     
-    for (i=0; i < OdeSpace::MAX_CONTACTS; i++)
-    {
-        contact[i].surface.mode = collide_params.colparams.mode; 
-        contact[i].surface.mu = collide_params.colparams.mu; 
-        contact[i].surface.mu2 = collide_params.colparams.mu2; 
-        contact[i].surface.bounce = collide_params.colparams.bounce; 
-        contact[i].surface.bounce_vel = collide_params.colparams.bounce_vel; 
-        contact[i].surface.soft_cfm = collide_params.colparams.soft_cfm; 
+    for(i=0; i < numc; i++) {
+      dJointID c = dJointCreateContact(_collide_world->get_id(), _collide_joint_group, contact + i);
+      if ((_collide_space->get_collide_id(o1) >= 0) && (_collide_space->get_collide_id(o2) >= 0)) {
+        dJointAttach(c, b1, b2);
+      }
+      if (!_collide_space->_collision_event.empty()) {
+        entry->_points[i][0] = contact[i].geom.pos[0];
+        entry->_points[i][1] = contact[i].geom.pos[1];
+        entry->_points[i][2] = contact[i].geom.pos[2];
+      }
+      // this creates contact position data for python. It is useful for debugging only 64 points are stored
+      if(contactCount < 64) {
+        OdeSpace::contact_data[0 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[0];
+        OdeSpace::contact_data[1 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[1];
+        OdeSpace::contact_data[2 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[2];
+        OdeSpace::contact_ids[0 + (OdeSpace::contactCount * 2)] = _collide_space->get_collide_id(o1);
+        OdeSpace::contact_ids[1 + (OdeSpace::contactCount * 2)] = _collide_space->get_collide_id(o2);
+        OdeSpace::contactCount += 1;
+      }
     }
+    _collide_world->set_dampen_on_bodies(b1, b2, collide_params.dampen);
     
-    static int numc = 0;
-    numc = dCollide(o1, o2, OdeSpace::MAX_CONTACTS, &contact[0].geom, sizeof(dContact));
-
-    if (numc)
-    {
-        if (odespace_cat.is_debug() && (autoCallbackCounter%30 == 0)) {
-            odespace_cat.debug() << autoCallbackCounter <<" collision between geoms " << o1 << " and " << o2 << "\n";
-            odespace_cat.debug() << "collision between body " << b1 << " and " << b2 << "\n";
-            odespace_cat.debug() << "surface1= "<< surface1 << " surface2=" << surface2 << "\n";
-        }
-        autoCallbackCounter += 1;
-
-        PT(OdeCollisionEntry) entry;
-        if (!_collide_space->_collision_event.empty()) {
-          entry = new OdeCollisionEntry;
-          entry->_geom1 = o1;
-          entry->_geom2 = o2;
-          entry->_body1 = b1;
-          entry->_body2 = b2;
-          entry->_num_points = numc;
-          entry->_points = new LPoint3f[numc];
-        }
-        
-        for(i=0; i < numc; i++)
-        {
-            dJointID c = dJointCreateContact(_collide_world->get_id(), _collide_joint_group, contact + i);
-            if ((_collide_space->get_collide_id(o1) >= 0) && (_collide_space->get_collide_id(o2) >= 0))
-            {
-                dJointAttach(c, b1, b2);
-            }
-            if (!_collide_space->_collision_event.empty()) {
-              entry->_points[i][0] = contact[i].geom.pos[0];
-              entry->_points[i][1] = contact[i].geom.pos[1];
-              entry->_points[i][2] = contact[i].geom.pos[2];
-            }
-            // this creates contact position data for python. It is useful for debugging only 64 points are stored
-            if(contactCount < 64)
-            {
-                OdeSpace::contact_data[0 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[0];
-                OdeSpace::contact_data[1 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[1];
-                OdeSpace::contact_data[2 + (OdeSpace::contactCount * 3)] = contact[i].geom.pos[2];
-                OdeSpace::contact_ids[0 + (OdeSpace::contactCount * 2)] = _collide_space->get_collide_id(o1);
-                OdeSpace::contact_ids[1 + (OdeSpace::contactCount * 2)] = _collide_space->get_collide_id(o2);
-                OdeSpace::contactCount += 1;
-            }
-        }
-        _collide_world->set_dampen_on_bodies(b1, b2, collide_params.dampen);
-        
-        if (!_collide_space->_collision_event.empty()) {
-          throw_event(_collide_space->_collision_event, EventParameter(entry));
-        }
+    if (!_collide_space->_collision_event.empty()) {
+      throw_event(_collide_space->_collision_event, EventParameter(entry));
     }
-
+  }
 }
 
 #ifdef HAVE_PYTHON
 int OdeSpace::
 collide(PyObject* arg, PyObject* callback) {
-    nassertr(callback != NULL, -1);
-    if (!PyCallable_Check(callback)) {
-        PyErr_Format(PyExc_TypeError, "'%s' object is not callable", callback->ob_type->tp_name);
-        return -1;
-    } else {
-        OdeSpace::_python_callback = (PyObject*) callback;
-        Py_XINCREF(OdeSpace::_python_callback);
-        dSpaceCollide(_id, (void*) arg, &near_callback);
-        Py_XDECREF(OdeSpace::_python_callback);
-        return 0;
-    }
+  nassertr(callback != NULL, -1);
+  if (!PyCallable_Check(callback)) {
+    PyErr_Format(PyExc_TypeError, "'%s' object is not callable", callback->ob_type->tp_name);
+    return -1;
+  } else if (_id == NULL) {
+    // Well, while we're in the mood of python exceptions, let's make this one too.
+    PyErr_Format(PyExc_TypeError, "OdeSpace is not valid!");
+    return -1;
+  } else {
+    OdeSpace::_python_callback = (PyObject*) callback;
+    Py_XINCREF(OdeSpace::_python_callback);
+    dSpaceCollide(_id, (void*) arg, &near_callback);
+    Py_XDECREF(OdeSpace::_python_callback);
+    return 0;
+  }
 }
 
 void OdeSpace::
 near_callback(void *data, dGeomID o1, dGeomID o2) {
-    odespace_cat.spam() << "near_callback called, data: " << data << ", dGeomID1: " << o1 << ", dGeomID2: " << o2 << "\n";
-    OdeGeom g1 (o1);
-    OdeGeom g2 (o2);
-    PyObject* p1 = DTool_CreatePyInstanceTyped(&g1, Dtool_OdeGeom, true, false, g1.get_type_index());
-    PyObject* p2 = DTool_CreatePyInstanceTyped(&g2, Dtool_OdeGeom, true, false, g2.get_type_index());
-    PyObject* result = PyEval_CallFunction(_python_callback, "OOO", (PyObject*) data, p1, p2);
-    if (!result) {
-        odespace_cat.error() << "An error occurred while calling python function!\n";
-        PyErr_Print();
-    }
+  odespace_cat.spam() << "near_callback called, data: " << data << ", dGeomID1: " << o1 << ", dGeomID2: " << o2 << "\n";
+  OdeGeom g1 (o1);
+  OdeGeom g2 (o2);
+  PyObject* p1 = DTool_CreatePyInstanceTyped(&g1, Dtool_OdeGeom, true, false, g1.get_type_index());
+  PyObject* p2 = DTool_CreatePyInstanceTyped(&g2, Dtool_OdeGeom, true, false, g2.get_type_index());
+  PyObject* result = PyEval_CallFunction(_python_callback, "OOO", (PyObject*) data, p1, p2);
+  if (!result) {
+    odespace_cat.error() << "An error occurred while calling python function!\n";
+    PyErr_Print();
+  }
 }
 #endif
 
@@ -308,8 +307,7 @@ set_surface_type(OdeGeom& geom,  int surfaceType){
 }
 
 int OdeSpace::
-get_surface_type(dGeomID id)
-{
+get_surface_type(dGeomID id) {
   GeomSurfaceMap::iterator iter = _geom_surface_map.find(id);
   if (iter != _geom_surface_map.end()) {
     // odespace_cat.debug() << "get_default_surface_type the geomId =" << id <<" surfaceType=" << iter->second << "\n";
@@ -320,14 +318,14 @@ get_surface_type(dGeomID id)
 }
 
 int OdeSpace::
-get_surface_type(OdeGeom& geom){
+get_surface_type(OdeGeom& geom) {
   dGeomID id = geom.get_id();
   return get_surface_type(id);
 }
 
 
 int OdeSpace::
-set_collide_id( int collide_id, dGeomID id){
+set_collide_id( int collide_id, dGeomID id) {
   _geom_collide_id_map[id]= collide_id;
 
   //odespace_cat.debug() << "set_collide_id " << id << " " << _geom_collide_id_map[id] <<"\n";
@@ -345,24 +343,20 @@ set_collide_id( int collide_id, dGeomID id){
 }
 
 int OdeSpace::
-set_collide_id( OdeGeom& geom, int collide_id)
-{
-    dGeomID id = geom.get_id();
-    return set_collide_id(collide_id, id);
+set_collide_id( OdeGeom& geom, int collide_id) {
+  dGeomID id = geom.get_id();
+  return set_collide_id(collide_id, id);
 }
 
 int OdeSpace::
-get_collide_id(OdeGeom& geom)
-{
-    dGeomID id = geom.get_id();
-    return get_collide_id(id);
+get_collide_id(OdeGeom& geom) {
+  dGeomID id = geom.get_id();
+  return get_collide_id(id);
 }
 
 
 int OdeSpace::
-get_collide_id(dGeomID id)
-{
-
+get_collide_id(dGeomID id) {
 /*
   GeomCollideIdMap::iterator iter2 = _geom_collide_id_map.begin();
   while (iter2 != _geom_collide_id_map.end()) {

panda/src/ode/odeWorld.cxx

@@ -39,162 +39,139 @@ OdeWorld::
 
 void OdeWorld::
 destroy() {
-  if(_num_surfaces > 0)
-  {
-      delete _surface_table;
+  if(_num_surfaces > 0) {
+    delete _surface_table;
   }
+  nassertv(_id);
   dWorldDestroy(_id);
 }
 
 /*
 void OdeWorld:: 
-assign_surface_body(OdeBody& body, int surface)
-{
-    // odeworld_cat.debug() << "assign_surface_body body.Id =" << body.get_id() << " surface=" << surface << "\n";
-    _body_dampen_map[body.get_id()].surfaceType = surface;
-    _body_dampen_map[body.get_id()].dampen = 0.0f;
+assign_surface_body(OdeBody& body, int surface) {
+  // odeworld_cat.debug() << "assign_surface_body body.Id =" << body.get_id() << " surface=" << surface << "\n";
+  _body_dampen_map[body.get_id()].surfaceType = surface;
+  _body_dampen_map[body.get_id()].dampen = 0.0f;
 }
 */
 
 void OdeWorld:: 
-add_body_dampening(OdeBody& body, int surface)
-{
-    _body_dampen_map[body.get_id()].dampen = 0.0f;
+add_body_dampening(OdeBody& body, int surface) {
+  _body_dampen_map[body.get_id()].dampen = 0.0f;
 }
 
 
 void OdeWorld::
-init_surface_table(PN_uint8 num_surfaces)
-{
-    _surface_table = new sSurfaceParams[num_surfaces * num_surfaces];
-    //_dampen_table = new sSurfaceParams[num_surfaces * num_surfaces];
-    _num_surfaces = num_surfaces;
+init_surface_table(PN_uint8 num_surfaces) {
+  _surface_table = new sSurfaceParams[num_surfaces * num_surfaces];
+  //_dampen_table = new sSurfaceParams[num_surfaces * num_surfaces];
+  _num_surfaces = num_surfaces;
 }
 
 void OdeWorld::
-set_surface(int pos1, int pos2, sSurfaceParams& entry)
-{
-    odeworld_cat.debug() << " pos1 " << pos1 << " pos2 " << pos2 << " num surfaces " << (int)_num_surfaces << " endline\n";
-    if((_num_surfaces <= pos1) || (_num_surfaces <= pos2))
-    {
-        odeworld_cat.error() << "surface position exceeds size of surface table, set num_surface in initSurfaceTable higher." << "\n";
-        return;
-    }
-    int true_pos = (pos1 * _num_surfaces) + pos2;
-    _surface_table[true_pos].colparams.mode = entry.colparams.mode;
-    _surface_table[true_pos].colparams.mu = entry.colparams.mu;
-    _surface_table[true_pos].colparams.mu2 = entry.colparams.mu2;
-    _surface_table[true_pos].colparams.bounce = entry.colparams.bounce;
-    _surface_table[true_pos].colparams.bounce_vel = entry.colparams.bounce_vel;
-    _surface_table[true_pos].colparams.soft_cfm = entry.colparams.soft_cfm;
-    _surface_table[true_pos].colparams.motion1 = entry.colparams.motion1;
-    _surface_table[true_pos].colparams.motion2 = entry.colparams.motion2;
-    _surface_table[true_pos].colparams.slip1 = entry.colparams.slip1;
-    _surface_table[true_pos].colparams.slip2 = entry.colparams.slip2;
-    _surface_table[true_pos].dampen = entry.dampen;
+set_surface(int pos1, int pos2, sSurfaceParams& entry) {
+  odeworld_cat.debug() << " pos1 " << pos1 << " pos2 " << pos2 << " num surfaces " << (int)_num_surfaces << " endline\n";
+  if((_num_surfaces <= pos1) || (_num_surfaces <= pos2)) {
+    odeworld_cat.error() << "surface position exceeds size of surface table, set num_surface in initSurfaceTable higher." << "\n";
+    return;
+  }
+  int true_pos = (pos1 * _num_surfaces) + pos2;
+  _surface_table[true_pos].colparams.mode = entry.colparams.mode;
+  _surface_table[true_pos].colparams.mu = entry.colparams.mu;
+  _surface_table[true_pos].colparams.mu2 = entry.colparams.mu2;
+  _surface_table[true_pos].colparams.bounce = entry.colparams.bounce;
+  _surface_table[true_pos].colparams.bounce_vel = entry.colparams.bounce_vel;
+  _surface_table[true_pos].colparams.soft_cfm = entry.colparams.soft_cfm;
+  _surface_table[true_pos].colparams.motion1 = entry.colparams.motion1;
+  _surface_table[true_pos].colparams.motion2 = entry.colparams.motion2;
+  _surface_table[true_pos].colparams.slip1 = entry.colparams.slip1;
+  _surface_table[true_pos].colparams.slip2 = entry.colparams.slip2;
+  _surface_table[true_pos].dampen = entry.dampen;
 }
 
 
 sSurfaceParams& OdeWorld::
-get_surface(PN_uint8 surface1, PN_uint8 surface2)
-{
-    int true_pos = 0;
-    if(surface1 >= surface2)
-    {
-        true_pos = (surface1 * _num_surfaces) + surface2;
-    }
-    else
-    {
-        true_pos = (surface2 * _num_surfaces) + surface1;
-    }
-    if((_num_surfaces <= surface1) || (_num_surfaces <= surface2))
-    {
-        odeworld_cat.error() << "surface position exceeds size of surface table, set num_surface in initSurfaceTable higher." << "\n";
-        //nassertr_always((_num_surfaces > surface1 && _num_surfaces > surface2), _surface_table[true_pos]);
-    }
-    return _surface_table[true_pos];
+get_surface(PN_uint8 surface1, PN_uint8 surface2) {
+  int true_pos = 0;
+  if(surface1 >= surface2) {
+    true_pos = (surface1 * _num_surfaces) + surface2;
+  } else {
+    true_pos = (surface2 * _num_surfaces) + surface1;
+  }
+  if((_num_surfaces <= surface1) || (_num_surfaces <= surface2)) {
+    odeworld_cat.error() << "surface position exceeds size of surface table, set num_surface in initSurfaceTable higher." << "\n";
+    //nassertr_always((_num_surfaces > surface1 && _num_surfaces > surface2), _surface_table[true_pos]);
+  }
+  return _surface_table[true_pos];
 }
 
 void OdeWorld:: 
-set_surface_entry(  PN_uint8 pos1, PN_uint8 pos2, 
-                    dReal mu,
-                    dReal bounce, 
-                    dReal bounce_vel, 
-                    dReal soft_erp, 
-                    dReal soft_cfm,
-                    dReal slip,
-                    dReal dampen)
-{
-    //todo: add mode
-    sSurfaceParams new_params;
-    int someMode = 0;
-    if (bounce > 0.0001)
-    {
-        someMode |= dContactBounce;
-    }
-    if (soft_erp > 0.0001)
-    {
-        someMode |= dContactSoftERP;
-    }
-    if (soft_cfm > 0.0001)
-    {
-        someMode |= dContactSoftCFM;
-    }
-    if (slip > 0.0001)
-    {
-        someMode = someMode | dContactSlip1 | dContactSlip2;
-    }
-    new_params.colparams.mode = dContactBounce | dContactSoftCFM | dContactApprox1;// | dContactSoftERP;
-    new_params.colparams.mu = mu;
-    new_params.colparams.mu2 = mu;
-    new_params.colparams.bounce = bounce;
-    new_params.colparams.bounce_vel = bounce_vel;
-    new_params.colparams.soft_erp = soft_erp;
-    new_params.colparams.soft_cfm = soft_cfm;
-    new_params.colparams.slip1 = slip;
-    new_params.colparams.slip2 = slip;
-    new_params.colparams.motion1 = 0.0;
-    new_params.colparams.motion2 = 0.0;
-    new_params.dampen = dampen;
-    //todo: a bit of wasted space here
+set_surface_entry(PN_uint8 pos1, PN_uint8 pos2, 
+                  dReal mu,
+                  dReal bounce, 
+                  dReal bounce_vel, 
+                  dReal soft_erp, 
+                  dReal soft_cfm,
+                  dReal slip,
+                  dReal dampen) {
+  //todo: add mode
+  sSurfaceParams new_params;
+  int someMode = 0;
+  if (bounce > 0.0001) {
+    someMode |= dContactBounce;
+  }
+  if (soft_erp > 0.0001) {
+    someMode |= dContactSoftERP;
+  }
+  if (soft_cfm > 0.0001) {
+    someMode |= dContactSoftCFM;
+  }
+  if (slip > 0.0001) {
+    someMode = someMode | dContactSlip1 | dContactSlip2;
+  }
+  new_params.colparams.mode = dContactBounce | dContactSoftCFM | dContactApprox1;// | dContactSoftERP;
+  new_params.colparams.mu = mu;
+  new_params.colparams.mu2 = mu;
+  new_params.colparams.bounce = bounce;
+  new_params.colparams.bounce_vel = bounce_vel;
+  new_params.colparams.soft_erp = soft_erp;
+  new_params.colparams.soft_cfm = soft_cfm;
+  new_params.colparams.slip1 = slip;
+  new_params.colparams.slip2 = slip;
+  new_params.colparams.motion1 = 0.0;
+  new_params.colparams.motion2 = 0.0;
+  new_params.dampen = dampen;
+  //todo: a bit of wasted space here
+  set_surface(pos1, pos2, new_params);
+  
+  if(pos1 >= pos2) {
     set_surface(pos1, pos2, new_params);
-   
-    if(pos1 >= pos2)
-    {
-        set_surface(pos1, pos2, new_params);
-    }
-    else
-    {
-        set_surface(pos2, pos1, new_params);
-    }
+  } else {
+    set_surface(pos2, pos1, new_params);
+  }
 }
 
 
 
 void OdeWorld::
-set_dampen_on_bodies(dBodyID id1, dBodyID id2,dReal damp)
-{
-    if(_body_dampen_map[id1].dampen < damp)
-    {
-        _body_dampen_map[id1].dampen = damp;
-    }
-    if(_body_dampen_map[id2].dampen < damp)
-    {
-        _body_dampen_map[id2].dampen = damp;
-    }
+set_dampen_on_bodies(dBodyID id1, dBodyID id2,dReal damp) {
+  if(_body_dampen_map[id1].dampen < damp) {
+    _body_dampen_map[id1].dampen = damp;
+  }
+  if(_body_dampen_map[id2].dampen < damp) {
+    _body_dampen_map[id2].dampen = damp;
+  }
 }
 
 float OdeWorld:: 
-apply_dampening(float dt, OdeBody& body)
-{
-    dBodyID bodyId = body.get_id();
-    dReal damp = _body_dampen_map[bodyId].dampen;
-    float dampening = 1.00 - (damp * dt);
-    body.set_angular_vel(body.get_angular_vel() * dampening);
-    body.set_linear_vel(body.get_linear_vel() * dampening);
-    _body_dampen_map[bodyId].dampen = 0.0;
-    return dampening;
-    
+apply_dampening(float dt, OdeBody& body) {
+  dBodyID bodyId = body.get_id();
+  dReal damp = _body_dampen_map[bodyId].dampen;
+  float dampening = 1.00 - (damp * dt);
+  body.set_angular_vel(body.get_angular_vel() * dampening);
+  body.set_linear_vel(body.get_linear_vel() * dampening);
+  _body_dampen_map[bodyId].dampen = 0.0;
+  return dampening;
 }
 
 OdeWorld::