Shovel.h

Go to the documentation of this file.

/*
Copyright 2007-2024. 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 <agx/BitState.h>
#include <agxTerrain/PrimaryActiveZone.h>
#include <agxTerrain/SoilParticleAggregate.h>
#include <agxTerrain/SoilPenetrationResistance.h>
 
#include <agxStream/Serializable.h>
 
namespace agxCollide
{
  class Geometry;
  class Shape;
}
 
namespace agxTerrain
{
  class Terrain;
  class TerrainMaterial;
  class TerrainToolCollection;
 
  AGX_DECLARE_POINTER_TYPES(Shovel);
  AGX_DECLARE_VECTOR_TYPES(Shovel);
  class AGXTERRAIN_EXPORT Shovel : public agx::Referenced, public agxStream::Serializable
  {
  public:
    class ExcavationSettings;
 
 
    Shovel(agx::RigidBody* shovelBody,
           const agx::Line& topEdge,
           const agx::Line& cuttingEdge,
           const agx::Vec3& cuttingDirection,
           Shovel* connectedShovel=nullptr);
 
    enum class ExcavationMode : agx::UInt32
    {
      PRIMARY = 0,
      DEFORM_BACK = 1,
      DEFORM_RIGHT = 2,
      DEFORM_LEFT = 3
    };
 
    agx::RigidBody* getRigidBody() const;
 
    ExcavationSettings& getExcavationSettings(ExcavationMode mode);
 
    agx::Line getTopEdge() const;
 
    agx::Line getTopEdgeWorld() const;
 
    agx::Line getCuttingEdge() const;
 
    agx::Line getCuttingEdgeWorld() const;
 
    agx::Vec3 getCuttingDirection() const;
 
    agx::Vec3 getCuttingDirectionWorld() const;
 
    agx::Real getToothLength() const;
 
    agx::Real getToothMinimumRadius() const;
 
    agx::Real getToothMaximumRadius() const;
 
    agx::UInt getNumberOfTeeth() const;
 
    agx::Real computeCuttingEdgeLength() const;
 
    void setExcavationSettings( ExcavationMode mode, ExcavationSettings excavationSettings );
 
    void setTopEdge(agx::Line topEdge);
 
    void setCuttingEdge(agx::Line cuttingEdge);
 
    void setCuttingDirection(agx::Vec3 cuttingDirection);
 
    void setToothLength(agx::Real length);
 
    void setToothMinimumRadius(agx::Real radius);
 
    void setToothMaximumRadius(agx::Real radius);
 
    void setNumberOfTeeth(agx::UInt count);
 
    void setNoMergeExtensionDistance(agx::Real extensionDistance);
 
    void setMinimumSubmergedContactLengthFraction(agx::Real minimumSubmergedContactLengthFraction);
 
    agx::Plane getCurrentSeparationPlane( Terrain* terrain, ExcavationMode mode ) const;
 
    agx::Real getMinimumSubmergedContactLengthFraction() const;
 
    agx::Real getNoMergeExtensionDistance() const;
 
    void setVerticalBladeSoilMergeDistance(agx::Real verticalSoilBladeMergeDistance);
 
    void setSecondarySeparationDeadloadLimit( agx::Real secondarySeparationLimit );
 
    agx::Real getVerticalBladeSoilMergeDistance() const;
 
    bool getSoilPenetrationModel(agxTerrain::Terrain* terrain, agxTerrain::SoilPenetrationResistance::PenetrationModel& model) const;
 
    void setPenetrationDepthThreshold(agx::Real depthThreshold);
 
    bool setSoilPenetrationModel(agxTerrain::SoilPenetrationResistance::PenetrationModel model, agxTerrain::Terrain* terrain);
 
    agx::Real getPenetrationDepthThreshold() const;
 
    void setPenetrationForceScaling(agx::Real penetrationForceScaling);
 
    agx::Real getPenetrationForceScaling() const;
 
    void setEnableParticleFreeDeformers(bool enable);
 
    bool getEnableParticleFreeDeformers() const;
 
    void setAlwaysRemoveShovelContacts(bool enable);
 
    bool getAlwaysRemoveShovelContacts() const;
 
    void setMaxPenetrationForce(agx::Real maxPenetrationForce);
 
    agx::Real getMaxPenetrationForce() const;
 
    agx::Real getSecondarySeparationDeadloadLimit() const;
 
    agx::Vec3 getSecondaryCuttingDirection( Terrain* terrain ) const;
 
    agx::Real getSecondarySeparationAngle( Terrain* terrain ) const;
 
    agx::Real getDeadLoadFraction() const;
 
    agx::Real getInnerContactArea() const;
 
    void setContactRegionThreshold( agx::Real contactRegionThreshold );
 
    agx::Real getContactRegionThreshold() const;
 
    void setContactRegionVerticalLimit( agx::Real verticalLimit );
 
    /*
    Get the maximum vertical distance from the shovel bottom plane where regular geometry
    contacts between the shovel and the terrain are allowed to be created. Contacts past that distance
    will be filtered away.
    \return the maximum vertical distance from the shovel bottom plane where regular geometry
            contacts between the shovel and the terrain are allowed to be created
    */
    agx::Real  getContactRegionVerticalLimit() const;
 
    void setEnableInnerShapeCreateDynamicMass( bool enable );
 
    bool getEnableInnerShapeCreateDynamicMass() const;
 
    void setEnableParticleForceFeedback( bool enable );
 
    bool getEnableParticleForceFeedback();
 
    void setEnable(bool enable);
 
    bool getEnable() const;
 
 
    agx::Real getParticleInclusionMultiplier() const;
 
    /*
    Get the radius multiplier for extending the inclusion bound with
    particle radius during post-excavation with particles in bucket.
    \param radiusMultiplier - The multiplier for the particle radius
                              extension of the shovel inclusion
                              bound. (Default: 1.0)
    \note - This will only be active pos-excavation and NOT during excavation
            when we have active soil wedges.
    */
    void setParticleInclusionMultiplier( agx::Real radiusMultiplier );
 
  public:
 
    class AGXTERRAIN_EXPORT ExcavationSettings
    {
    public:
      ExcavationSettings();
 
      ExcavationSettings(agx::UInt32 state);
 
      void setEnable(bool enable);
 
      void setEnableCreateDynamicMass(bool enable);
 
      void setEnableForceFeedback(bool enable);
 
      bool getEnable() const;
 
      bool getEnableForceFeedback() const;
 
      bool getEnableCreateDynamicMass() const;
 
      agx::UInt32 getState() const;
 
      void store( agxStream::OutputArchive& out ) const { m_settings.store( out ); }
      void restore( agxStream::InputArchive& in ) { m_settings.restore( in ); }
 
    private:
      enum StateFlags : agx::UInt32
      {
        ENABLED = 1 << 0,
        ENABLE_CREATE_DYNAMIC_MASS = 1 << 1,
        ENABLE_FORCE_FEEDBACK = 1 << 2,
      };
      using Flags = agx::BitState<StateFlags, agx::UInt32>;
      Flags m_settings;
    };
 
   public:
 
    DOXYGEN_START_INTERNAL_BLOCK()
    agx::Bool initializeCollection( TerrainToolCollection* collection, agxSDK::Simulation* simulation );
 
    void uninitializeCollection( TerrainToolCollection* collection, agxSDK::Simulation* simulation );
 
    void onPre( TerrainToolCollection* collection );
 
    void onPost( TerrainToolCollection* collection );
 
    bool getShovelPlanes(TerrainToolCollection* collection,
                         agx::Plane& bottomPlane,
                         agx::Plane& backPlane,
                         agx::Plane& leftPlane,
                         agx::Plane& rightPlane);
 
    void removeTerrainShovelContacts(TerrainToolCollection* collection);
 
    void removeTerrainShovelContactsDeformer(TerrainToolCollection* collection);
 
    bool isEdgeSubmerged(const agx::Line& edge, const Terrain* terrain) const;
 
    bool isEdgeSubmergedInSolid(const agx::Line& edge, const Terrain* terrain) const;
 
    bool isEdgeSubmergedInHeightfield(const agx::Line& edge, const agxCollide::HeightField* heightfield, const Terrain* terrain) const;
 
    agx::Real getSubmergedEdgeLength(const agx::Line& edge, const Terrain* terrain) const;
 
    agx::Vec3 getCuttingEdgeVelocity();
 
    void correctShovelVectors();
 
    void calculateDeadLoadFraction( const Terrain* terrain,
                                    const ActiveZone* activeZone,
                                    const agx::Physics::GranularBodyPtrVector& innerParticles );
 
    void setInnerContactArea( agx::Real contactArea );
 
    void setSettingsAreDirty(bool enable);
 
    bool getSettingsAreDirty() const;
 
    agx::Real computeDefaultContactRegionThreshold() const;
 
    Shovel* getConnectedShovel();
 
    AGXSTREAM_DECLARE_SERIALIZABLE( agxTerrain::Shovel );
    DOXYGEN_END_INTERNAL_BLOCK()
 
  protected:
    Shovel();
 
    virtual ~Shovel();
 
    agxCollide::GeometryRefVector createVoxelCollisionGeometries( agx::Real tessellationLevel ) const;
 
  protected:
    struct SoilPenetrationParameters
    {
      agx::Real depthThreshold;
      agx::Real forceScaling;
      agx::Real maxForce;
    };
 
    enum StateFlags : agx::UInt32
    {
      ENABLED = 1 << 0,
      REMOVE_SHOVEL_CONTACTS = 1 << 1,
      INNER_SHAPE_CREATE_DYNAMIC_MASS = 1 << 2,
      ENABLE_PARTICLE_FREE_DEFORMATION = 1 << 3,
      ENABLE_PARTICLE_FORCE_FEEDBACK = 1 << 4
    };
    using Flags = agx::BitState<StateFlags, agx::UInt32>;
 
    agx::RigidBodyObserver    m_shovelBody;
    agx::Line                 m_cuttingEdge;
    agx::Line                 m_topEdge;
    agx::Vec3                 m_cuttingDirection;
    agx::Real                 m_toothLength;
    agx::Real                 m_toothMinRadius;
    agx::Real                 m_toothMaxRadius;
    agx::UInt                 m_nTeeth;
    agx::Real                 m_noMergeExtensionDistance;
    agx::Real                 m_verticalSoilBladeMergeDistance;
    agx::Real                 m_minimumSubmergedContactLengthFraction;
    agx::Real                 m_secondarySeparationDeadLoadLimit;
    agx::Real                 m_particleInclusionMultiplier;
    Flags                     m_flags;
    SoilPenetrationParameters m_soilPenetrationParameters;
 
    std::array< ExcavationSettings, 4 > m_excavationSettings;
 
    agx::Real                           m_contactThreshold;
    agx::Real                           m_verticalContactThreshold;
 
    // Caching of dead load
    agx::Real                 m_deadLoadFraction;
    // Caching of inner contact area
    agx::Real                 m_innerContactArea;
 
    // Geometries used to find shovel-voxel collisions
    agxCollide::GeometryRefVector m_voxelCollisionGeometries;
    bool                          m_settingsAreDirty;
 
    Shovel*                       m_connectedShovel;
  };
}