Commits

Steven Peters committed 83a0545

Minor fixes to elminate compilation warnings.

Comments (0)

Files changed (16)

gazebo/physics/rtql8/RTQL8BallJoint.cc

 
 
 //////////////////////////////////////////////////
-void RTQL8BallJoint::SetAnchor(int /*_index*/, const math::Vector3 &_anchor)
+void RTQL8BallJoint::SetAnchor(int /*_index*/, const math::Vector3 &/*_anchor*/)
 {
   //dJointSetBallAnchor(jointId, _anchor.x, _anchor.y, _anchor.z);
 }
 
 //////////////////////////////////////////////////
-void RTQL8BallJoint::SetDamping(int /*_index*/, double _damping)
+void RTQL8BallJoint::SetDamping(int /*_index*/, double /*_damping*/)
 {
   //dJointSetDamping(this->jointId, _damping);
 }

gazebo/physics/rtql8/RTQL8BoxShape.hh

       public: virtual ~RTQL8BoxShape() {}
 
       // Documentation inherited.
-      public: virtual void SetSize(const math::Vector3 &_size)
+      public: virtual void SetSize(const math::Vector3 & /*_size*/)
       {
-//         BoxShape::SetSize(_size);
+//      BoxShape::SetSize(_size);
 // 
-//         RTQL8CollisionPtr oParent;
-//         oParent = boost::shared_dynamic_cast<RTQL8Collision>(
-//             this->collisionParent);
+//      RTQL8CollisionPtr oParent;
+//      oParent = boost::shared_dynamic_cast<RTQL8Collision>(
+//          this->collisionParent);
 // 
-//         if (oParent->GetCollisionId() == NULL)
-//           oParent->SetCollision(dCreateBox(0, _size.x, _size.y, _size.z), true);
-//         else
-//           dGeomBoxSetLengths(oParent->GetCollisionId(),
+//      if (oParent->GetCollisionId() == NULL)
+//        oParent->SetCollision(dCreateBox(0, _size.x, _size.y, _size.z), true);
+//      else
+//        dGeomBoxSetLengths(oParent->GetCollisionId(),
 //                              _size.x, _size.y, _size.z);
       }
     };

gazebo/physics/rtql8/RTQL8Collision.cc

 }
 
 //////////////////////////////////////////////////
-void RTQL8Collision::Load(sdf::ElementPtr _sdf)
+void RTQL8Collision::Load(sdf::ElementPtr /*_sdf*/)
 {
 //   Collision::Load(_sdf);
 // 
 }
 
 //////////////////////////////////////////////////
-void RTQL8Collision::SetCollision(bool _placeable)
+void RTQL8Collision::SetCollision(bool /*_placeable*/)
 {
 //   // Must go first in this function
 //   this->collisionId = _collisionId;
 }
 
 //////////////////////////////////////////////////
-void RTQL8Collision::SetCategoryBits(unsigned int _bits)
+void RTQL8Collision::SetCategoryBits(unsigned int /*_bits*/)
 {
 //   if (this->collisionId)
 //     dGeomSetCategoryBits(this->collisionId, _bits);
 }
 
 //////////////////////////////////////////////////
-void RTQL8Collision::SetCollideBits(unsigned int _bits)
+void RTQL8Collision::SetCollideBits(unsigned int /*_bits*/)
 {
 //   if (this->collisionId)
 //     dGeomSetCollideBits(this->collisionId, _bits);

gazebo/physics/rtql8/RTQL8CylinderShape.hh

       public: virtual ~RTQL8CylinderShape() {}
 
       // Documentation inerited.
-      public: void SetSize(double _radius, double _length)
+      public: void SetSize(double /*_radius*/, double /*_length*/)
       {
-//         CylinderShape::SetSize(_radius, _length);
-//         RTQL8CollisionPtr oParent;
-//         oParent =
-//           boost::shared_dynamic_cast<RTQL8Collision>(this->collisionParent);
+//      CylinderShape::SetSize(_radius, _length);
+//      RTQL8CollisionPtr oParent;
+//      oParent =
+//        boost::shared_dynamic_cast<RTQL8Collision>(this->collisionParent);
 // 
-//         if (oParent->GetCollisionId() == NULL)
-//           oParent->SetCollision(dCreateCylinder(0, _radius, _length), true);
-//         else
-//           dGeomCylinderSetParams(oParent->GetCollisionId(), _radius, _length);
+//      if (oParent->GetCollisionId() == NULL)
+//        oParent->SetCollision(dCreateCylinder(0, _radius, _length), true);
+//      else
+//        dGeomCylinderSetParams(oParent->GetCollisionId(), _radius, _length);
       }
     };
   }

gazebo/physics/rtql8/RTQL8Hinge2Joint.cc

 }
 
 //////////////////////////////////////////////////
-math::Vector3 RTQL8Hinge2Joint::GetAnchor(int _index) const
+math::Vector3 RTQL8Hinge2Joint::GetAnchor(int /*_index*/) const
 {
 //   dVector3 result;
 // 
 }
 
 //////////////////////////////////////////////////
-void RTQL8Hinge2Joint::SetAnchor(int /*index*/, const math::Vector3 &_anchor)
+void RTQL8Hinge2Joint::SetAnchor(int /*index*/, const math::Vector3 & /*_anchor*/)
 {
 //   if (this->childLink) this->childLink->SetEnabled(true);
 //   if (this->parentLink) this->parentLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-void RTQL8Hinge2Joint::SetAxis(int _index, const math::Vector3 &_axis)
+void RTQL8Hinge2Joint::SetAxis(int /*_index*/, const math::Vector3 & /*_axis*/)
 {
 //   if (this->childLink) this->childLink->SetEnabled(true);
 //   if (this->parentLink) this->parentLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-void RTQL8Hinge2Joint::SetDamping(int /*_index*/, double _damping)
+void RTQL8Hinge2Joint::SetDamping(int /*_index*/, double /*_damping*/)
 {
 //   dJointSetDamping(this->jointId, _damping);
 }
 
 //////////////////////////////////////////////////
-math::Vector3 RTQL8Hinge2Joint::GetGlobalAxis(int _index) const
+math::Vector3 RTQL8Hinge2Joint::GetGlobalAxis(int /*_index*/) const
 {
 //   dVector3 result;
 // 
 }
 
 //////////////////////////////////////////////////
-double RTQL8Hinge2Joint::GetVelocity(int _index) const
+double RTQL8Hinge2Joint::GetVelocity(int /*_index*/) const
 {
-  double result;
+  // double result;
 
 //   if (_index == 0)
 //     result = dJointGetHinge2Angle1Rate(this->jointId);
 //   else
 //     result = dJointGetHinge2Angle2Rate(this->jointId);
 
-  return result;
+  return 0;
 }
 
 //////////////////////////////////////////////////
-void RTQL8Hinge2Joint::SetVelocity(int _index, double _angle)
+void RTQL8Hinge2Joint::SetVelocity(int /*_index*/, double /*_angle*/)
 {
 //   if (_index == 0)
 //     this->SetParam(dParamVel, _angle);
 }
 
 //////////////////////////////////////////////////
-double RTQL8Hinge2Joint::GetMaxForce(int _index)
+double RTQL8Hinge2Joint::GetMaxForce(int /*_index*/)
 {
 //   if (_index == 0)
 //     return this->GetParam(dParamFMax);
 //   else
 //     return this->GetParam(dParamFMax2);
+  return 0;
 }
 
 
 //////////////////////////////////////////////////
-void RTQL8Hinge2Joint::SetMaxForce(int _index, double _t)
+void RTQL8Hinge2Joint::SetMaxForce(int /*_index*/, double /*_t*/)
 {
 //   if (_index == 0)
 //     this->SetParam(dParamFMax, _t);
 
 
 //////////////////////////////////////////////////
-void RTQL8Hinge2Joint::SetForce(int _index, double _torque)
+void RTQL8Hinge2Joint::SetForce(int /*_index*/, double /*_torque*/)
 {
 //   if (this->childLink) this->childLink->SetEnabled(true);
 //   if (this->parentLink) this->parentLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-double RTQL8Hinge2Joint::GetParam(int _parameter) const
+double RTQL8Hinge2Joint::GetParam(int /*_parameter*/) const
 {
 //   double result = dJointGetHinge2Param(this->jointId, _parameter);
 // 
 }
 
 //////////////////////////////////////////////////
-void RTQL8Hinge2Joint::SetParam(int _parameter, double _value)
+void RTQL8Hinge2Joint::SetParam(int /*_parameter*/, double /*_value*/)
 {
 //   ODEJoint::SetParam(_parameter, _value);
 //   dJointSetHinge2Param(this->jointId, _parameter, _value);

gazebo/physics/rtql8/RTQL8HingeJoint.cc

 }
 
 //////////////////////////////////////////////////
-void RTQL8HingeJoint::SetAnchor(int /*index*/, const math::Vector3 &_anchor)
+void RTQL8HingeJoint::SetAnchor(int /*index*/, const math::Vector3 &/*_anchor*/)
 {
 //   if (this->childLink)
 //     this->childLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-void RTQL8HingeJoint::SetAxis(int /*index*/, const math::Vector3 &_axis)
+void RTQL8HingeJoint::SetAxis(int /*index*/, const math::Vector3 &/*_axis*/)
 {
 //   if (this->childLink)
 //     this->childLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-void RTQL8HingeJoint::SetDamping(int /*index*/, double _damping)
+void RTQL8HingeJoint::SetDamping(int /*index*/, double /*_damping*/)
 {
 //   this->damping_coefficient = _damping;
 //   dJointSetDamping(this->jointId, this->damping_coefficient);
 }
 
 //////////////////////////////////////////////////
-void RTQL8HingeJoint::SetVelocity(int /*index*/, double _angle)
+void RTQL8HingeJoint::SetVelocity(int /*index*/, double /*_angle*/)
 {
 //   this->SetParam(dParamVel, _angle);
 }
 
 //////////////////////////////////////////////////
-void RTQL8HingeJoint::SetMaxForce(int /*index*/, double _t)
+void RTQL8HingeJoint::SetMaxForce(int /*index*/, double /*_t*/)
 {
 //   return this->SetParam(dParamFMax, _t);
 }
 double RTQL8HingeJoint::GetMaxForce(int /*index*/)
 {
 //   return this->GetParam(dParamFMax);
+  return 0;
 }
 
 //////////////////////////////////////////////////
-void RTQL8HingeJoint::SetForce(int /*index*/, double _torque)
+void RTQL8HingeJoint::SetForce(int /*index*/, double /*_torque*/)
 {
 //   if (this->childLink)
 //     this->childLink->SetEnabled(true);

gazebo/physics/rtql8/RTQL8Joint.cc

 }
 
 //////////////////////////////////////////////////
-void RTQL8Joint::SetHighStop(int _index, const math::Angle &_angle)
+void RTQL8Joint::SetHighStop(int _index, const math::Angle & /*_angle*/)
 {
    switch (_index)
    {
 }
 
 //////////////////////////////////////////////////
-void RTQL8Joint::SetLowStop(int _index, const math::Angle &_angle)
+void RTQL8Joint::SetLowStop(int _index, const math::Angle & /*_angle*/)
 {
    switch (_index)
    {
 }
 
 //////////////////////////////////////////////////
-math::Angle RTQL8Joint::GetHighStop(int _index)
+math::Angle RTQL8Joint::GetHighStop(int /*_index*/)
 {
 //   switch (_index)
 //   {
 }
 
 //////////////////////////////////////////////////
-math::Angle RTQL8Joint::GetLowStop(int _index)
+math::Angle RTQL8Joint::GetLowStop(int /*_index*/)
 {
 //   switch (_index)
 //   {
 }
 
 //////////////////////////////////////////////////
-math::Vector3 RTQL8Joint::GetLinkForce(unsigned int _index) const
+math::Vector3 RTQL8Joint::GetLinkForce(unsigned int /*_index*/) const
 {
   math::Vector3 result;
 //   dJointFeedback *jointFeedback = dJointGetFeedback(this->jointId);
 }
 
 //////////////////////////////////////////////////
-math::Vector3 RTQL8Joint::GetLinkTorque(unsigned int _index) const
+math::Vector3 RTQL8Joint::GetLinkTorque(unsigned int /*_index*/) const
 {
   math::Vector3 result;
 //   dJointFeedback *jointFeedback = dJointGetFeedback(this->jointId);
 }
 
 //////////////////////////////////////////////////
-void RTQL8Joint::SetAttribute(Attribute _attr, int /*_index*/, double _value)
+void RTQL8Joint::SetAttribute(Attribute /*_attr*/, int /*_index*/, double /*_value*/)
 {
 //   switch (_attr)
 //   {
 }
 
 //////////////////////////////////////////////////
-void RTQL8Joint::SetAttribute(const std::string &_key, int /*_index*/,
-                            const boost::any &_value)
+void RTQL8Joint::SetAttribute(const std::string &/*_key*/, int /*_index*/,
+                            const boost::any &/*_value*/)
 {
 //   if (_key == "fudge_factor")
 //   {
 //   }
 }
 
-JointWrench RTQL8Joint::GetForceTorque(int _index)
+JointWrench RTQL8Joint::GetForceTorque(int /*_index*/)
 {
   JointWrench wrench;
 //  // Note that:

gazebo/physics/rtql8/RTQL8Link.cc

   Link::Init();
 
   // TODO:
-  math::Pose worldPose = this->GetWorldPose();
+  math::Pose pose = this->GetWorldPose();
 
   // Set pose
   rtql8BodyNode;
 }
 
 //////////////////////////////////////////////////
-void RTQL8Link::SetEnabled(bool _enable) const
+void RTQL8Link::SetEnabled(bool /*_enable*/) const
 {
 //   if (!this->linkId)
 //     return;
 }
 
 //////////////////////////////////////////////////
-void RTQL8Link::SetLinearVel(const math::Vector3 &_vel)
+void RTQL8Link::SetLinearVel(const math::Vector3 & /*_vel*/)
 {
 //   if (this->linkId)
 //   {
 }
 
 //////////////////////////////////////////////////
-void RTQL8Link::SetAngularVel(const math::Vector3 &_vel)
+void RTQL8Link::SetAngularVel(const math::Vector3 & /*_vel*/)
 {
 //   if (this->linkId)
 //   {
 }
 
 //////////////////////////////////////////////////
-void RTQL8Link::SetForce(const math::Vector3 &_force)
+void RTQL8Link::SetForce(const math::Vector3 & /*_force*/)
 {
 //   if (this->linkId)
 //   {
 }
 
 //////////////////////////////////////////////////
-void RTQL8Link::SetTorque(const math::Vector3 &_torque)
+void RTQL8Link::SetTorque(const math::Vector3 & /*_torque*/)
 {
 //   if (this->linkId)
 //   {
 }
 
 //////////////////////////////////////////////////
-void RTQL8Link::AddForce(const math::Vector3 &_force)
+void RTQL8Link::AddForce(const math::Vector3 & /*_force*/)
 {
 //   if (this->linkId)
 //   {
 }
 
 /////////////////////////////////////////////////
-void RTQL8Link::AddRelativeForce(const math::Vector3 &_force)
+void RTQL8Link::AddRelativeForce(const math::Vector3 & /*_force*/)
 {
 //   if (this->linkId)
 //   {
 }
 
 /////////////////////////////////////////////////
-void RTQL8Link::AddForceAtWorldPosition(const math::Vector3 &_force,
-                                      const math::Vector3 &_pos)
+void RTQL8Link::AddForceAtWorldPosition(const math::Vector3 & /*_force*/,
+                                      const math::Vector3 & /*_pos*/)
 {
 //   if (this->linkId)
 //   {
 //   }
 }
 /////////////////////////////////////////////////
-void RTQL8Link::AddForceAtRelativePosition(const math::Vector3 &_force,
-                               const math::Vector3 &_relpos)
+void RTQL8Link::AddForceAtRelativePosition(const math::Vector3 & /*_force*/,
+                               const math::Vector3 & /*_relpos*/)
 {
 //   if (this->linkId)
 //   {
 }
 
 /////////////////////////////////////////////////
-void RTQL8Link::AddTorque(const math::Vector3 &_torque)
+void RTQL8Link::AddTorque(const math::Vector3 & /*_torque*/)
 {
 //   if (this->linkId)
 //   {
 }
 
 /////////////////////////////////////////////////
-void RTQL8Link::AddRelativeTorque(const math::Vector3 &_torque)
+void RTQL8Link::AddRelativeTorque(const math::Vector3 & /*_torque*/)
 {
 //   if (this->linkId)
 //   {
 }
 
 //////////////////////////////////////////////////
-void RTQL8Link::SetSelfCollide(bool _collide)
+void RTQL8Link::SetSelfCollide(bool /*_collide*/)
 {
 //   this->sdf->GetElement("self_collide")->Set(_collide);
 //   if (_collide)
 }
 
 //////////////////////////////////////////////////
-void RTQL8Link::SetLinearDamping(double _damping)
+void RTQL8Link::SetLinearDamping(double /*_damping*/)
 {
 //   if (this->GetODEId())
 //     dBodySetLinearDamping(this->GetODEId(), _damping);
 }
 
 //////////////////////////////////////////////////
-void RTQL8Link::SetAngularDamping(double _damping)
+void RTQL8Link::SetAngularDamping(double /*_damping*/)
 {
 //   if (this->GetODEId())
 //     dBodySetAngularDamping(this->GetODEId(), _damping);
 }
 
 //////////////////////////////////////////////////
-void RTQL8Link::SetAutoDisable(bool _disable)
+void RTQL8Link::SetAutoDisable(bool /*_disable*/)
 {
 //   if (this->GetModel()->GetJointCount() == 0 && this->linkId)
 //   {

gazebo/physics/rtql8/RTQL8PlaneShape.hh

       }
 
       // Documentation inherited
-      public: virtual void SetAltitude(const math::Vector3 &_pos)
+      public: virtual void SetAltitude(const math::Vector3 & /*_pos*/)
       {
-//         PlaneShape::SetAltitude(_pos);
-//         RTQL8CollisionPtr odeParent;
-//         odeParent =
-//           boost::shared_dynamic_cast<RTQL8Collision>(this->collisionParent);
+//      PlaneShape::SetAltitude(_pos);
+//      RTQL8CollisionPtr odeParent;
+//      odeParent =
+//        boost::shared_dynamic_cast<RTQL8Collision>(this->collisionParent);
 // 
-//         dVector4 vec4;
+//      dVector4 vec4;
 // 
-//         dGeomPlaneGetParams(odeParent->GetCollisionId(), vec4);
+//      dGeomPlaneGetParams(odeParent->GetCollisionId(), vec4);
 // 
-//         // Compute "altitude": scalar product of position and normal
-//         vec4[3] = vec4[0] * _pos.x + vec4[1] * _pos.y + vec4[2] * _pos.z;
+//      // Compute "altitude": scalar product of position and normal
+//      vec4[3] = vec4[0] * _pos.x + vec4[1] * _pos.y + vec4[2] * _pos.z;
 // 
-//         dGeomPlaneSetParams(odeParent->GetCollisionId(), vec4[0], vec4[1],
-//                             vec4[2], vec4[3]);
+//      dGeomPlaneSetParams(odeParent->GetCollisionId(), vec4[0], vec4[1],
+//                          vec4[2], vec4[3]);
       }
     };
   }

gazebo/physics/rtql8/RTQL8RayShape.cc

 }
 
 //////////////////////////////////////////////////
-void RTQL8RayShape::GetIntersection(double &_dist, std::string &_entity)
+void RTQL8RayShape::GetIntersection(double &/*_dist*/, std::string &/*_entity*/)
 {
 //   if (this->physicsEngine)
 //   {
 }
 
 //////////////////////////////////////////////////
-void RTQL8RayShape::SetPoints(const math::Vector3 &_posStart,
-                            const math::Vector3 &_posEnd)
+void RTQL8RayShape::SetPoints(const math::Vector3 &/*_posStart*/,
+                            const math::Vector3 &/*_posEnd*/)
 {
 //   math::Vector3 dir;
 //   RayShape::SetPoints(_posStart, _posEnd);

gazebo/physics/rtql8/RTQL8ScrewJoint.cc

 }
 
 //////////////////////////////////////////////////
-void RTQL8ScrewJoint::Load(sdf::ElementPtr _sdf)
+void RTQL8ScrewJoint::Load(sdf::ElementPtr /*_sdf*/)
 {
 //   ScrewJoint<ODEJoint>::Load(_sdf);
 //   this->SetThreadPitch(0, this->threadPitch);
 }
 
 //////////////////////////////////////////////////
-void RTQL8ScrewJoint::SetVelocity(int /*index*/, double _angle)
+void RTQL8ScrewJoint::SetVelocity(int /*index*/, double /*_angle*/)
 {
 //   this->SetParam(dParamVel, _angle);
 }
 
 //////////////////////////////////////////////////
-void RTQL8ScrewJoint::SetAxis(int /*index*/, const math::Vector3 &_axis)
+void RTQL8ScrewJoint::SetAxis(int /*index*/, const math::Vector3 &/*_axis*/)
 {
 //   if (this->childLink) this->childLink->SetEnabled(true);
 //   if (this->parentLink) this->parentLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-void RTQL8ScrewJoint::SetDamping(int /*index*/, double _damping)
+void RTQL8ScrewJoint::SetDamping(int /*index*/, double /*_damping*/)
 {
 //   this->damping_coefficient = _damping;
 //   dJointSetDamping(this->jointId, this->damping_coefficient);
 }
 
 //////////////////////////////////////////////////
-void RTQL8ScrewJoint::SetThreadPitch(int /*_index*/, double _threadPitch)
+void RTQL8ScrewJoint::SetThreadPitch(int /*_index*/, double /*_threadPitch*/)
 {
 //   dJointSetScrewThreadPitch(this->jointId, _threadPitch);
 }
 }
 
 //////////////////////////////////////////////////
-void RTQL8ScrewJoint::SetForce(int /*index*/, double _force)
+void RTQL8ScrewJoint::SetForce(int /*index*/, double /*_force*/)
 {
 //   if (this->childLink) this->childLink->SetEnabled(true);
 //   if (this->parentLink) this->parentLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-void RTQL8ScrewJoint::SetParam(int _parameter, double _value)
+void RTQL8ScrewJoint::SetParam(int /*_parameter*/, double /*_value*/)
 {
 //   ODEJoint::SetParam(_parameter, _value);
 //   dJointSetScrewParam(this->jointId, _parameter, _value);
 }
 
 //////////////////////////////////////////////////
-double RTQL8ScrewJoint::GetParam(int _parameter) const
+double RTQL8ScrewJoint::GetParam(int /*_parameter*/) const
 {
 //   double result = dJointGetScrewParam(this->jointId, _parameter);
 // 
 }
 
 //////////////////////////////////////////////////
-void RTQL8ScrewJoint::SetMaxForce(int /*_index*/, double _t)
+void RTQL8ScrewJoint::SetMaxForce(int /*_index*/, double /*_t*/)
 {
 //   this->SetParam(dParamFMax, _t);
 }

gazebo/physics/rtql8/RTQL8SliderJoint.cc

   SliderJoint<RTQL8Joint>::Load(_sdf);
 
   // Slider joint has only one degree of freedom.
-  rtql8::kinematics::Dof* dofs = new rtql8::kinematics::Dof;
+  // rtql8::kinematics::Dof* dofs = new rtql8::kinematics::Dof;
 
   // TODO: Could I know the sliding axis?; x, y, z
 
 }
 
 //////////////////////////////////////////////////
-void RTQL8SliderJoint::SetVelocity(int /*index*/, double _angle)
+void RTQL8SliderJoint::SetVelocity(int /*index*/, double /*_angle*/)
 {
    //this->SetParam(dParamVel, _angle);
 }
 }
 
 //////////////////////////////////////////////////
-void RTQL8SliderJoint::SetDamping(int /*index*/, double _damping)
+void RTQL8SliderJoint::SetDamping(int /*index*/, double /*_damping*/)
 {
 //   this->damping_coefficient = _damping;
 //   dJointSetDamping(this->jointId, this->damping_coefficient);
 }
 
 //////////////////////////////////////////////////
-void RTQL8SliderJoint::SetForce(int /*index*/, double _force)
+void RTQL8SliderJoint::SetForce(int /*index*/, double /*_force*/)
 {
 //   if (this->childLink)
 //     this->childLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-void RTQL8SliderJoint::SetMaxForce(int /*_index*/, double _t)
+void RTQL8SliderJoint::SetMaxForce(int /*_index*/, double /*_t*/)
 {
 //   this->SetParam(dParamFMax, _t);
 }

gazebo/physics/rtql8/RTQL8SphereShape.hh

       public: virtual ~RTQL8SphereShape() {}
 
       // Documentation inherited.
-      public: virtual void SetRadius(double _radius)
+      public: virtual void SetRadius(double /*_radius*/)
       {
-//         SphereShape::SetRadius(_radius);
-//         RTQL8CollisionPtr oParent;
-//         oParent =
-//           boost::shared_dynamic_cast<RTQL8Collision>(this->collisionParent);
+//      SphereShape::SetRadius(_radius);
+//      RTQL8CollisionPtr oParent;
+//      oParent =
+//        boost::shared_dynamic_cast<RTQL8Collision>(this->collisionParent);
 // 
-//         // Create the sphere geometry
-//         if (oParent->GetCollisionId() == NULL)
-//           oParent->SetCollision(dCreateSphere(0, _radius), true);
-//         else
-//           dGeomSphereSetRadius(oParent->GetCollisionId(), _radius);
+//      // Create the sphere geometry
+//      if (oParent->GetCollisionId() == NULL)
+//        oParent->SetCollision(dCreateSphere(0, _radius), true);
+//      else
+//        dGeomSphereSetRadius(oParent->GetCollisionId(), _radius);
       }
     };
   }

gazebo/physics/rtql8/RTQL8TrimeshShape.cc

 }
 
 //////////////////////////////////////////////////
-void RTQL8TrimeshShape::Load(sdf::ElementPtr _sdf)
+void RTQL8TrimeshShape::Load(sdf::ElementPtr /*_sdf*/)
 {
 //   TrimeshShape::Load(_sdf);
 }

gazebo/physics/rtql8/RTQL8UniversalJoint.cc

 }
 
 //////////////////////////////////////////////////
-void RTQL8UniversalJoint::SetAnchor(int /*index*/, const math::Vector3 &_anchor)
+void RTQL8UniversalJoint::SetAnchor(int /*index*/, const math::Vector3 &/*_anchor*/)
 {
 //   if (this->childLink) this->childLink->SetEnabled(true);
 //   if (this->parentLink) this->parentLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-math::Vector3 RTQL8UniversalJoint::GetGlobalAxis(int _index) const
+math::Vector3 RTQL8UniversalJoint::GetGlobalAxis(int /*_index*/) const
 {
 //   dVector3 result;
 // 
 }
 
 //////////////////////////////////////////////////
-void RTQL8UniversalJoint::SetAxis(int _index, const math::Vector3 &_axis)
+void RTQL8UniversalJoint::SetAxis(int /*_index*/, const math::Vector3 &/*_axis*/)
 {
 //   if (this->childLink) this->childLink->SetEnabled(true);
 //   if (this->parentLink) this->parentLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-void RTQL8UniversalJoint::SetDamping(int /*_index*/, double _damping)
+void RTQL8UniversalJoint::SetDamping(int /*_index*/, double /*_damping*/)
 {
 //   dJointSetDamping(this->jointId, _damping);
 }
 
 //////////////////////////////////////////////////
-math::Angle RTQL8UniversalJoint::GetAngleImpl(int _index) const
+math::Angle RTQL8UniversalJoint::GetAngleImpl(int /*_index*/) const
 {
   math::Angle result;
 
 }
 
 //////////////////////////////////////////////////
-double RTQL8UniversalJoint::GetVelocity(int _index) const
+double RTQL8UniversalJoint::GetVelocity(int /*_index*/) const
 {
-  double result;
+  // double result;
 
 //   if (_index == 0)
 //     result = dJointGetUniversalAngle1Rate(this->jointId);
 //   else
 //     result = dJointGetUniversalAngle2Rate(this->jointId);
 
-  return result;
+  return 0;
 }
 
 //////////////////////////////////////////////////
-void RTQL8UniversalJoint::SetVelocity(int _index, double _angle)
+void RTQL8UniversalJoint::SetVelocity(int /*_index*/, double /*_angle*/)
 {
 //   if (_index == 0)
 //     this->SetParam(dParamVel, _angle);
 }
 
 //////////////////////////////////////////////////
-void RTQL8UniversalJoint::SetForce(int _index, double _torque)
+void RTQL8UniversalJoint::SetForce(int /*_index*/, double /*_torque*/)
 {
 //   if (this->childLink) this->childLink->SetEnabled(true);
 //   if (this->parentLink) this->parentLink->SetEnabled(true);
 }
 
 //////////////////////////////////////////////////
-void RTQL8UniversalJoint::SetMaxForce(int _index, double _t)
+void RTQL8UniversalJoint::SetMaxForce(int /*_index*/, double /*_t*/)
 {
 //   if (_index == 0)
 //     this->SetParam(dParamFMax, _t);
 }
 
 //////////////////////////////////////////////////
-double RTQL8UniversalJoint::GetMaxForce(int _index)
+double RTQL8UniversalJoint::GetMaxForce(int /*_index*/)
 {
 //   if (_index == 0)
 //     return this->GetParam(dParamFMax);
 }
 
 //////////////////////////////////////////////////
-void RTQL8UniversalJoint::SetParam(int _parameter, double _value)
+void RTQL8UniversalJoint::SetParam(int /*_parameter*/, double /*_value*/)
 {
 //   ODEJoint::SetParam(_parameter, _value);
 //   dJointSetUniversalParam(this->jointId, _parameter, _value);

gazebo/physics/rtql8/rtql8_inc.h

+// This file should have a license
+
 #ifndef _RTQL8_INC_H_
 #define _RTQL8_INC_H_
 
+// This disables warning messages for ODE
+#pragma GCC system_header
+
 #include <rtql8/integration/EulerIntegrator.h>
 #include <rtql8/integration/RK4Integrator.h>
 //#include <rtql8/integration/Integrator.h>