ConstraintAngle.h

Go to the documentation of this file.

/*
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 unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from 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 AGX_CONSTRAINTANGLE_H
#define AGX_CONSTRAINTANGLE_H
 
#include <agx/Vec3.h>
 
#include <agxStream/Serializable.h>
 
namespace agx
{
  class AttachmentPair;
 
  class AGXPHYSICS_EXPORT Angle : public agx::Referenced, public agxStream::Serializable
  {
    public:
      enum Axis
      {
        U, 
        V, 
        N  
      };
 
      enum Type
      {
        TRANSLATIONAL, 
        ROTATIONAL     
      };
 
    public:
      virtual void transform( const agx::AttachmentPair& ap );
 
      virtual void onPostSolve( const agx::AttachmentPair& ap, agx::Real dt );
 
      agx::Angle::Axis getAxis() const;
 
      agx::Angle::Type getType() const;
 
      agx::Real getValue() const;
 
      virtual const agx::Vec3& getDir( const agx::AttachmentPair& ap, agx::UInt index ) const;
 
      virtual void store( agxStream::OutputArchive& out ) const override;
 
      virtual void restore( agxStream::InputArchive& in ) override;
 
      AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( agx::Angle );
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      Angle( agx::Angle::Axis axis, agx::Angle::Type type, agx::Real initialAngle = agx::Real( 0 ) );
 
      virtual ~Angle();
 
    protected:
      Axis      m_axis;
      Type      m_type;
      agx::Real m_value;
  };
 
  typedef agx::ref_ptr< Angle> AngleRef;
  typedef agx::Vector<AngleRef> AngleContainer;
 
  class AGXPHYSICS_EXPORT RotationalAngle : public agx::Angle
  {
    public:
      static agx::RotationalAngle* safeCast( const agx::Angle* angle );
 
    public:
      RotationalAngle( agx::Angle::Axis axis, agx::Real initialAngle = agx::Real( 0 ) );
 
      virtual void transform( const agx::AttachmentPair& ap ) override;
 
      virtual void onPostSolve( const agx::AttachmentPair& ap, agx::Real dt ) override;
 
      agx::Int getWindingNumber() const;
 
      void setWindingNumber( agx::Int windingNumber );
 
      agx::Real getLastAngle() const;
 
      void setLastAngle( agx::Real lastAngle );
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::RotationalAngle );
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      RotationalAngle();
 
    protected:
      virtual ~RotationalAngle();
 
      virtual void transformImpl( const agx::AttachmentPair& ap, bool firstIsReference );
 
      virtual void stepBy( agx::Real deltaAngle );
 
      virtual void stepAbout( const agx::Vec3& worldAxis, const AttachmentPair& ap, agx::Real dt );
 
    protected:
      agx::Int  m_windingNumber;
      agx::Real m_lastAngle;
  };
 
  typedef agx::ref_ptr<RotationalAngle> RotationalAngleRef;
 
  class AGXPHYSICS_EXPORT SeparationAngle : public agx::Angle
  {
    public:
      static agx::SeparationAngle* safeCast( const agx::Angle* angle );
 
    public:
      SeparationAngle( agx::Angle::Axis axis, agx::Real initialAngle = agx::Real( 0 ) );
 
      virtual void transform( const agx::AttachmentPair& ap ) override;
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agx::SeparationAngle);
 
    protected:
      SeparationAngle();
 
      virtual ~SeparationAngle();
  };
 
  typedef agx::ref_ptr<SeparationAngle> SeparationAngleRef;
 
 
 
  class AGXPHYSICS_EXPORT ConeLimitAngle : public Angle
  {
  public:
    ConeLimitAngle(bool useRotAngle);
 
    ConeLimitAngle();
 
    virtual void transform(const AttachmentPair& ap) override;
 
    virtual const Vec3& getDir(const AttachmentPair& ap, agx::UInt index) const override;
 
    void setConeLimitRange(Vec2 limit);
 
    Vec2 getConeLimitRange() const;
 
    AGXSTREAM_DECLARE_SERIALIZABLE(ConeLimitAngle);
 
  protected:
    bool m_useRotAngle;
 
  private:
    Vec2 m_currentLimit;
    Vec3 m_dir;
  };
 
  typedef ref_ptr<ConeLimitAngle> ConeLimitAngleRef;
 
  inline Real Angle::getValue() const
  {
    return m_value;
  }
} //namespace agx
 
#endif