RigidBody.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_RIGIDBODY_H
#define MOMENTUM_RIGIDBODY_H
 
#include "momentum_export.h"
#include "momentum_namespace.h"
 
#include "macros.h"
 
#include "Vec3.h"
#include "AffineMatrix4x4.h"
#include "Matrix3x3.h"
#include "Geometry.h"
#include "ContactPoint.h"
 
 
#ifndef SWIG
#ifndef SWIG
namespace agx
{
  class RigidBody;
}
#endif
#endif
 
namespace MOMENTUM_NAMESPACE
{
#ifndef SWIG
  class ContactPoint;
  class Observer;
#endif
 
  class MOMENTUM_EXPORT RigidBody
  {
  public:
    enum MotionControl
    {
      STATIC = 1, 
      KINEMATICS = 2, 
      DYNAMICS = 3  
    };
 
  public:
#ifndef SWIG
 
    RigidBody(agx::RigidBody *);
#endif
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setTransform(const AffineMatrix4x4& matrix);
#endif
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setRotation(const Quat& q);
 
    void setRotation(const EulerAngles* e);
 
 
    void setPosition(const Vec3& p);
 
    void setPosition(double x, double y, double z);
#endif
 
    AffineMatrix4x4 getTransform() const;
 
    Vec3 getPosition() const;
 
    Quat getRotation() const;
 
    bool isEmittedBody() const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setLinearVelocity(const Vec3& velocity);
 
    void setLinearVelocity(double vx, double vy, double vz);
 
    void setAngularVelocity(const Vec3& angularVelocity);
 
    void setAngularVelocity(double vx, double vy, double vz);
#endif
 
    Vec3 getLinearVelocity() const;
 
    Vec3 getAngularVelocity() const;
 
    Vec3 getModelVelocity(const Vec3& relPos = Vec3()) const;
 
    Vec3 getModelAcceleration(const Vec3& relPos = Vec3()) const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setEnable(bool enable);
#endif
 
    bool getEnable() const;
 
    RigidBody::MotionControl getMotionControl() const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setMotionControl(RigidBody::MotionControl control);
#endif
 
    Vec3 getLastForce() const;
 
    Vec3 getLastTorque() const;
 
    std::string getName() const;
 
    std::string __str__() const;
 
    bool operator==(const RigidBody& other) const;
 
    AffineMatrix4x4 getCmTransform() const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setCmTransform(const AffineMatrix4x4& matrix);
#endif
 
    Vec3 getCmLocalTranslate() const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setCmLocalTranslate(const Vec3& translate);
#endif
 
    Vec3 getCmPosition() const;
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setCmPosition(const Vec3& p);
 
    bool setCmAndInertiaInObserver(const Observer& observer, const Matrix3x3& inertia);
#endif
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setForce(const Vec3& force);
 
    void setForce(double fx, double fy, double fz);
 
    void setTorque(const Vec3& torque);
 
    void setTorque(double tx, double ty, double tz);
 
    void addForce(const Vec3& force);
 
    void addForce(double fx, double fy, double fz);
 
    void addForceAtPosition(const Vec3& force, const Vec3& position);
 
    void addForceAtPosition(double fx, double fy, double fz, double px, double py, double pz);
 
    void addForceAtLocalPosition(const Vec3& force, const Vec3& position);
 
    void addForceAtLocalPosition(double fx, double fy, double fz, double px, double py, double pz);
 
    void addForceAtLocalCmPosition(const Vec3& force, const Vec3& position);
 
    void addForceAtLocalCmPosition(double fx, double fy, double fz, double px, double py, double pz);
 
    void addTorque(const Vec3& torque);
 
    void addTorque(double tx, double ty, double tz);
 
    void addLocalTorque(double tx, double ty, double tz);
 
    void addLocalTorque(const Vec3& torque);
 
    void moveTo(const AffineMatrix4x4& target, double t);
 
    void moveTo(const Vec3& targetPosition, const Quat& targetRotation, double dt);
 
    void setLinearVelocityDamping(double damping);
 
    void setLinearVelocityDamping(const Vec3& damping);
 
    void setAngularVelocityDamping(double damping);
 
    void setAngularVelocityDamping(const Vec3& damping);
 
    void setVelocityDamping(double damping);
#endif
 
    Vec3 getLinearVelocityDamping() const;
 
    Vec3 getAngularVelocityDamping() const;
 
    Vec3 getLinearMomentum() const;
 
    Vec3 getAngularMomentum() const;
 
    double getTranslationalEnergy() const;
 
    double getRotationalEnergy() const;
 
    double getTotalEnergy() const;
 
    Vec3 getLinearAcceleration() const;
 
    Vec3 getAngularAcceleration() const;
 
    size_t getNumConstraints() const;
 
    Vec3 getForce() const;
 
    Vec3 getTorque() const;
 
    double getMass();
 
#ifndef AGX_MOMENTUM_ANALYSIS_API
    void setMass(double mass);
#endif
 
    Matrix3x3 getInertia();
 
#ifndef  AGX_MOMENTUM_ANALYSIS_API
    bool setInertia(Matrix3x3 inertia);
#endif // ! AGX_MOMENTUM_ANALYSIS_API
 
 
    GeometryVector getGeometries() const;
 
#ifndef SWIG
    bool is(agx::RigidBody* body) const;
 
    agx::RigidBody* body() const;
#endif
    ContactPointVector getContacts() const;
 
    virtual ~RigidBody();
 
  protected:
 
    RigidBody();
 
    friend class Simulation;
 
  private:
#ifndef SWIG
    agx::RigidBody *m_body;
#endif
 
  };
 
  V1_DECLARE_CONTAINER_TYPE(RigidBody);
 
} // namespace momentum
#endif