TwoBodyTire.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.
*/
 
#pragma once
 
#include <agxModel/export.h>
 
#include <agxModel/Tire.h>
#include <agx/Vec2.h>
#include <agx/Hinge.h>
#include <agxUtil/agxUtil.h>
 
namespace agxSDK
{
  class Simulation;
}
 
 
namespace agxModel
{
  AGX_DECLARE_POINTER_TYPES(TireFilter);
    // Class for allowing contacts as long as any of the bodies is involved.
  class TireFilter : public agxSDK::ExecuteFilter
  {
  public:
 
    TireFilter()
    {}
 
    void addBody(agx::RigidBody* body)
    {
      m_bodies.push_back(body);
    }
 
    virtual bool match(const agxCollide::Geometry* g0, const agxCollide::Geometry* g1) const override
    {
      const agxCollide::Geometry* geos[] = { g0, g1 };
 
      for (size_t j = 0; j < 2; ++j)
      if (geos[j]->getRigidBody())
      for (size_t i = 0; i < m_bodies.size(); ++i)
      if (geos[j]->getRigidBody() == m_bodies[i])
        return true;
 
      return false;
    }
 
    using ExecuteFilter::match;
 
  protected:
    virtual ~TireFilter() {};
 
 
  protected:
    agx::RigidBodyRefVector m_bodies;
  };
 
 
  AGX_DECLARE_POINTER_TYPES(TireFriction);
  class AGXMODEL_EXPORT TireFriction : public agx::IterativeProjectedConeFriction
  {
    public:
      TireFriction( const agx::Frame* referenceFrame );
 
      virtual void calculateTangentPlane(
        const agxCollide::Geometry* geometry1,
        const agxCollide::Geometry* geometry2,
        const agx::Vec3& point,
        const agx::Vec3& normal,
        const agx::Real depth,
        agx::Vec3& ret_u,
        agx::Vec3& ret_v ) const override;
 
    protected:
      virtual ~TireFriction();
 
    protected:
      agx::FrameConstObserver m_refFrame;
  };
 
 
  AGX_DECLARE_POINTER_TYPES( TwoBodyTire );
  AGX_DECLARE_VECTOR_TYPES( TwoBodyTire );
  class AGXMODEL_EXPORT TwoBodyTire : public agxModel::Tire
  {
    public:
      TwoBodyTire( agx::RigidBody* tireBody, agx::Real outerRadius,
        agx::RigidBody* hubBody, agx::Real innerRadius,
        const agx::AffineMatrix4x4& localTransform = agx::AffineMatrix4x4() );
 
      enum DeformationMode {
        RADIAL,      // Translation orthogonal to rotation axis.
        LATERAL,     // Translation in rotation axis.
        BENDING,     // Rotation orthogonal to rotation axis.
        TORSIONAL    // Rotation in rotation axis.
      };
 
      agx::RigidBody* getTireRigidBody();
 
      const agx::RigidBody* getTireRigidBody() const;
 
      agx::RigidBody* getHubRigidBody();
 
      const agx::RigidBody* getHubRigidBody() const;
 
      agx::Real getOuterRadius() const;
 
      agx::Real getInnerRadius() const;
 
      virtual bool isValid() const;
 
      const agx::Frame* getReferenceFrame() const;
 
      agx::Vec2 getImplicitFrictionMultiplier() const;
 
      void setImplicitFrictionMultiplier(const agx::Vec2& implicitFrictionMultiplier);
 
      virtual agx::Real getLoadedRadius() const override;
 
      virtual bool setStiffness(const agx::Real stiffness, DeformationMode mode);
 
      virtual agx::Real getStiffness(DeformationMode mode);
 
      virtual bool setDampingCoefficient(const agx::Real dampingCoefficient, DeformationMode mode);
 
      virtual agx::Real getDampingCoefficient(DeformationMode mode);
 
      static TwoBodyTire* find( agxSDK::Simulation* simulation, const agx::Name& name );
 
      static TwoBodyTire* find( agxSDK::Assembly* assembly, const agx::Name& name );
 
      static TwoBodyTirePtrVector findAll( const agxSDK::Simulation* simulation, const agx::Name& name );
 
      static TwoBodyTirePtrVector findAll( const agxSDK::Simulation* simulation );
 
      agx::Hinge* getHinge();
 
      enum Flags
      {
        NONE, 
        CONTACT_FILTER = 1 << 0, 
        CONSTRAINT = 1 << 1, 
        DEFAULT=CONTACT_FILTER | CONSTRAINT
      };
 
      void setEnable(Flags flags);
 
 
      Flags getEnable() const;
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agxModel::TwoBodyTire);
 
    protected:
      TwoBodyTire();
 
      void initBodies(agx::Real outerRadius, agx::Real innerRadius);
 
      virtual ~TwoBodyTire();
 
      // Adding to/removing from simulation.
      virtual void addNotification( agxSDK::Simulation* simulation ) override;
 
      using agxSDK::Assembly::addNotification;
 
      virtual void removeNotification( agxSDK::Simulation* simulation )override;
 
      using agxSDK::Assembly::removeNotification;
 
      // Contact events.
      friend class agxUtil::GeneralContactEventListener< TwoBodyTire >;
 
      agxSDK::ContactEventListener::KeepContactPolicy impact(
        const agx::TimeStamp&, agxCollide::GeometryContact* gc );
 
      agxSDK::ContactEventListener::KeepContactPolicy contact(
        const agx::TimeStamp&, agxCollide::GeometryContact* gc );
 
      void separation(
        const agx::TimeStamp&, agxCollide::GeometryPair& );
 
      agxSDK::ContactEventListener::KeepContactPolicy handleContacts(
        const agx::TimeStamp&, agxCollide::GeometryContact* gc);
 
      agx::Vec3 getTireCenterWorld() const;
 
      agx::Vec3 getTireAxisWorld() const;
 
      void reduceContacts(agxCollide::LocalGeometryContact& gc);
 
      // Step events.
      friend class agxUtil::GeneralStepListener< TwoBodyTire >;
 
      virtual void preCollide( const agx::TimeStamp& );
      virtual void pre( const agx::TimeStamp& );
      virtual void post( const agx::TimeStamp& );
      virtual void last( const agx::TimeStamp& );
 
 
    protected:
      // More persistent variables, will be serialized.
      agx::RigidBodyObserver m_tireBody;
      agx::RigidBodyObserver m_hubBody;
      agx::Real m_innerRadius;
      agx::Vec2 m_implicitFrictionMultiplier;
      agx::HingeRef m_hinge;
      agx::FrameRef m_refFrame;
      bool m_initialized;
      agx::Real m_loadedRadius;
      // Implementation dependent temporary variables, only valid per simulation.
      agx::UInt32 m_collisionGroup;
      agx::ref_ptr< agxUtil::GeneralContactEventListener< TwoBodyTire > > m_contactCallback;
      agx::ref_ptr< agxUtil::GeneralStepListener< TwoBodyTire > > m_stepCallback;
      // Implementation dependent temporary variables, only valid per time step.
      agx::Vector<agxCollide::LocalGeometryContact> m_contacts;
      agx::Vector<agx::ContactMaterialRef> m_contactMaterials;
  };
}