[Change] Abstract dynamic body stuff ready for ODE removal.

src/dynamic_body.cpp

@@ -13,6 +13,27 @@ DynamicBody::DynamicBody(void) : ModelBody() {
   dBodySetMass(m_body, &m_mass);
 }
 
+void DynamicBody::SetForce(const vector3d f) {
+  dBodySetForce(m_body, f.x, f.y, f.z);
+}
+
+void DynamicBody::AddForce(const vector3d f) {
+  dBodyAddForce(m_body, f.x, f.y, f.z);
+}
+
+void DynamicBody::AddForceAtPos(const vector3d force, const vector3d pos) {
+  dBodyAddForceAtPos(m_body, force.x, force.y, force.z,
+      pos.x, pos.y, pos.z);
+}
+
+void DynamicBody::AddRelForce(const vector3d f) {
+  dBodyAddRelForce(m_body, f.x, f.y, f.z);
+}
+
+void DynamicBody::AddRelTorque(const vector3d t) {
+  dBodyAddRelTorque(m_body, t.x, t.y, t.z);
+}
+
 void DynamicBody::Save(void) {
   using namespace Serializer::Write;
   ModelBody::Save();
@@ -27,6 +48,15 @@ void DynamicBody::Load(void) {
   SetVelocity(rd_vector3d());
 }
 
+void DynamicBody::SetTorque(const vector3d t) {
+  dBodySetTorque(m_body, t.x, t.y, t.z);
+}
+
+void DynamicBody::SetMass(double mass) {
+  dMassAdjust(&m_mass, mass);
+  dBodySetMass(m_body, &m_mass);
+}
+
 void DynamicBody::SetPosition(vector3d p) {
   dBodySetPosition(m_body, p.x, p.y, p.z);
   ModelBody::SetPosition(p);

src/dynamic_body.h

@@ -20,17 +20,28 @@ public:
   virtual bool OnCollision(Body* b, Uint32 flags) { return true; }
   vector3d GetAngularMomentum(void);
   void SetMassDistributionFromCollMesh(const CollMesh* m);
+  void DisableBodyOnly(void) { dBodyDisable(m_body); }
+  bool IsEnabled(void) { return dBodyIsEnabled(m_body); }
   virtual void Disable(void);
   virtual void Enable(void);
   virtual double GetMass(void) const { return m_mass.mass; }
   virtual void TimeStepUpdate(const float timeStep);
 
+  void SetMass(double);
+  void AddForceAtPos(const vector3d force, const vector3d pos);
+  void AddForce(const vector3d);
+  void SetForce(const vector3d);
+  void SetTorque(const vector3d);
+  /* body-relative forces. */
+  void AddRelForce(const vector3d);
+  void AddRelTorque(const vector3d);
+
   dBodyID m_body;
-  dMass   m_mass;
 
 protected:
   virtual void Save(void);
   virtual void Load(void);
 
 private:
+  dMass m_mass;
 };

src/main.cpp

@@ -133,7 +133,7 @@ void L3D::SetTimeAccel(float s) {
   /* We don't want player spinning like crazy when hitting time accel. */
   if(s > 10) {
     player->SetAngVelocity(vector3d(0,0,0));
-    dBodySetTorque(player->m_body, 0, 0, 0);
+    player->SetTorque(vector3d(0,0,0));
     player->SetAngThrusterState(0, 0.0f);
     player->SetAngThrusterState(1, 0.0f);
     player->SetAngThrusterState(2, 0.0f);

src/player.cpp

@@ -170,8 +170,8 @@ void Player::DrawHUD(const Frame* cam_frame) {
 
   /* Direction indicator. */
   const float sz = HUD_CROSSHAIR_SIZE;
-  const dReal* vel = dBodyGetLinearVel(m_body);
+  const vector3d vel = GetVelocity();
-  vector3d loc_v = cam_frame->GetOrientation().InverseOf() * vector3d(vel[0], vel[1], vel[2]);
+  vector3d loc_v = cam_frame->GetOrientation().InverseOf() * vel;
   if(loc_v.z < 0) {
     GLdouble pos[3];
     if(Gui::Screen::Project(loc_v[0], loc_v[1], loc_v[2], modelMatrix, projMatrix,

src/ship.cpp

@@ -113,8 +113,7 @@ Ship::Ship(ShipType::Type shipType) : DynamicBody() {
 
 void Ship::UpdateMass(void) {
   CalcStats();
-  dMassAdjust(&m_mass, m_stats.total_mass*1000);
+  SetMass(m_stats.total_mass*1000);
-  dBodySetMass(m_body, &m_mass);
 }
 
 bool Ship::OnCollision(Body* b, Uint32 flags) {
@@ -140,8 +139,7 @@ bool Ship::OnCollision(Body* b, Uint32 flags) {
 
 vector3d Ship::CalcRotDamping(void) {
   /* Rotation damping. */
-  const dReal* _av = dBodyGetAngularVel(m_body);
+  vector3d angVel = GetAngVelocity();
-  vector3d angVel(_av[0], _av[1], _av[2]);
   matrix4x4d rot;
   GetRotMatrix(rot);
   angVel = rot.InverseOf() * angVel;
@@ -198,10 +196,13 @@ void Ship::Blastoff(void) {
   Enable();
   const double planetRadius = 0.1 + GetFrame()->m_astroBody->GetRadius();
   vector3d up = vector3d::Normalize(GetPosition());
-  dBodySetLinearVel(m_body, 0, 0, 0);
+  SetVelocity(vector3d(0,0,0));
-  dBodySetAngularVel(m_body, 0, 0, 0);
+  SetAngVelocity(vector3d(0,0,0));
-  dBodySetForce(m_body, 0, 0, 0);
+
-  dBodySetTorque(m_body, 0, 0, 0);
+  SetVelocity(vector3d(0,0,0));
+  SetAngVelocity(vector3d(0,0,0));
+  SetForce(vector3d(0,0,0));
+  SetTorque(vector3d(0,0,0));
 
   Aabb aabb;
   GetAabb(aabb);
@@ -214,8 +215,7 @@ void Ship::TestLanded(void) {
   m_testLanded = false;
   if(m_launchLockTimeout != 0) return;
   if(GetFrame()->m_astroBody) {
-    const dReal* vel = dBodyGetLinearVel(m_body);
+    double speed = GetVelocity().Length();
-    double speed = vector3d(vel[0], vel[1], vel[2]).Length();
     const double planetRadius = GetFrame()->m_astroBody->GetRadius();
 
     if(speed < MAX_LANDING_SPEED) {
@@ -246,16 +246,16 @@ void Ship::TestLanded(void) {
         rot = rot.InverseOf();
         SetRotMatrix(rot);
 
-        dBodySetLinearVel(m_body, 0,0,0);
+        SetVelocity(vector3d(0,0,0));
-        dBodySetAngularVel(m_body,0,0,0);
+        SetAngVelocity(vector3d(0,0,0));
-        dBodySetForce(m_body,0,0,0);
+        SetForce(vector3d(0,0,0));
-        dBodySetTorque(m_body,0,0,0);
+        SetTorque(vector3d(0,0,0));
 
         /*
          * We don't use DynamicBody::Disable because that also disables
          * the geom, and that must still get collisions.
          */
-        dBodyDisable(m_body);
+        DisableBodyOnly();
         ClearThrusterState();
         m_flightState = LANDED;
       }
@@ -284,18 +284,18 @@ void Ship::TimeStepUpdate(const float timeStep) {
     switch(i) {
     case ShipType::THRUSTER_REAR:
     case ShipType::THRUSTER_FRONT:
-      dBodyAddRelForce(m_body, 0, 0, force); break;
+      AddRelForce(vector3d(0,0,force)); break;
     case ShipType::THRUSTER_TOP:
     case ShipType::THRUSTER_BOTTOM:
-      dBodyAddRelForce(m_body, 0, force, 0); break;
+      AddRelForce(vector3d(0, force, 0)); break;
     case ShipType::THRUSTER_LEFT:
     case ShipType::THRUSTER_RIGHT:
-      dBodyAddRelForce(m_body, force, 0, 0); break;
+      AddRelForce(vector3d(force, 0, 0)); break;
     }
   }
-  dBodyAddRelTorque(m_body, stype.angThrust*m_angThrusters[0],
+  AddRelTorque(vector3d(stype.angThrust*m_angThrusters[0],
                             stype.angThrust*m_angThrusters[1],
-                            stype.angThrust*m_angThrusters[2]);
+                            stype.angThrust*m_angThrusters[2]));
 
   /* LASERZ!! */
   for(int i = 0; i < ShipType::GUNMOUNT_MAX; i++) {
@@ -424,7 +424,7 @@ static void render_coll_mesh(const CollMesh* m) {
 }
 
 void Ship::Render(const Frame* camFrame) {
-  if((!dBodyIsEnabled(m_body)) && !m_flightState) return;
+  if((!IsEnabled()) && !m_flightState) return;
   const ShipType& stype = GetShipType();
   params.angthrust[0] = m_angThrusters[0];
   params.angthrust[1] = m_angThrusters[1];

src/space.cpp

@@ -289,13 +289,8 @@ static bool _OnCollision(dGeomID g1, dGeomID g2, Object* o1, Object* o2,
       DynamicBody* rb = (DynamicBody*)o1;
       dVector3 start, dir;
       dGeomRayGet(g2, start, dir);
-      dBodyAddForceAtPos(rb->m_body,
+      rb->AddForceAtPos(vector3d(dir[0], dir[1], dir[2])*100,
-                         100*dir[0],
+          vector3d(contacts[0].geom.pos[0], contacts[0].geom.pos[1], contacts[0].geom.pos[2]));
-                         100*dir[1],
-                         100*dir[2],
-                         contacts[0].geom.pos[0],
-                         contacts[0].geom.pos[1],
-                         contacts[0].geom.pos[2]);
     }
     return false;
   } else {
@@ -464,7 +459,7 @@ void Space::ApplyGravity(void) {
     const double force = G*m1m2 / (r*r);
     b1b2.Normalize();
     b1b2 = b1b2 * force;
-    dBodyAddForce(L3D::player->m_body, b1b2.x, b1b2.y, b1b2.z);
+    L3D::player->AddForce(b1b2);
   }
 }
 

src/space_station.cpp

@@ -182,8 +182,8 @@ bool SpaceStation::OnCollision(Body* b, Uint32 flags) {
     /* Hitting docking area of a station. */
     if(b->IsType(Object::SHIP)) {
       Ship* s = static_cast<Ship*>(b);
-      const dReal* vel = dBodyGetLinearVel(s->m_body);
+ 
-      double speed = vector3d(vel[0], vel[1], vel[2]).Length();
+      double speed = s->GetVelocity().Length();     
 
       /* Must be oriented sensibly and have wheels down. */
       if(IsGroundStation()) {