Joint.h

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material without having a written signed agreement with Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#ifndef MOMENTUM_JOINT_H
#define MOMENTUM_JOINT_H
 
#include "momentum_export.h"
#include "momentum_namespace.h"
 
#include "macros.h"
#include "RigidBody.h"
#include "AffineMatrix4x4.h"
#include "Vec3.h"
 
#include <memory>
 
#ifndef SWIG
namespace agx
{
  class Constraint;
}
#endif
 
namespace MOMENTUM_NAMESPACE
{
 
  class HingeJoint;
  class PrismaticJoint;
  class CylindricalJoint;
  class BallJoint;
  class LockJoint;
  class SpringJoint;
 
  class MOMENTUM_EXPORT Joint
  {
  public:
    enum DegreeOfFreedom
    {
      X,
      Y,
      Z
    };
#ifndef SWIG
 
    Joint(agx::Constraint* constraint);
 
    Joint();
#endif
 
    bool getEnabled() const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setEnabled(bool enabled);
#endif
 
    std::shared_ptr<RigidBody> getBody(int body) const;
 
    AffineMatrix4x4 getTransformation(int body) const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setTransformation(int body, const AffineMatrix4x4& transform);
#endif
 
    Vec3 getBodyForce(int body) const;
 
    Vec3 getBodyTorque(int body) const;
 
    double getTranslationalElasticity(DegreeOfFreedom dof) const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setTranslationalElasticity(DegreeOfFreedom dof, double elasticity);
#endif
 
    double getRotationalElasticity(DegreeOfFreedom dof) const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setRotationalElasticity(DegreeOfFreedom dof,  double elasticity);
#endif
 
    double getTranslationalDamping(DegreeOfFreedom dof) const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setTranslationalDamping(DegreeOfFreedom dof, double damping);
#endif
 
    double getRotationalDamping(DegreeOfFreedom dof) const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setRotationalDamping(DegreeOfFreedom dof, double damping);
#endif
 
    std::shared_ptr<HingeJoint> asHingeJoint();
 
    std::shared_ptr<PrismaticJoint> asPrismaticJoint();
 
    std::shared_ptr<CylindricalJoint> asCylindricalJoint();
 
    std::shared_ptr<BallJoint> asBallJoint();
 
    std::shared_ptr<LockJoint> asLockJoint();
 
    std::shared_ptr<SpringJoint> asSpringJoint();
 
    std::string getName() const;
 
    virtual std::string __str__() const;
 
    bool operator==(const Joint& other) const;
 
    virtual ~Joint();
 
  protected:
    // Because each constraint have different DOF setup we need to make this function in each specific joint
    virtual int getAgxTranslationalDOF(DegreeOfFreedom ) const { return -1; }
    virtual int getAgxRotationalDOF(DegreeOfFreedom ) const { return -1; }
 
    agx::Real getDampingInternal(int agxDOF) const;
    void setDampingInternal(int agxDOF, double damping);
 
#ifndef SWIG
    agx::Constraint* m_constraint;
#endif
  };
 
  V1_DECLARE_CONTAINER_TYPE(Joint);
} // namespace momentum
 
 
#endif