TerrainProperties.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 <agx/config/AGX_USE_AGXTERRAIN.h>
#include <agxTerrain/export.h>
#include <agx/Referenced.h>
#include <agx/BitState.h>
#include <array>
 
namespace agxTerrain
{
  AGX_DECLARE_POINTER_TYPES(TerrainProperties);
  class AGXTERRAIN_EXPORT TerrainProperties : public agx::Referenced
  {
  public:
 
    agx::Real getSoilMergeSpeedThreshold() const;
 
    bool getEnableLockedBorders() const;
 
    bool getEnableSoilCompaction() const;
 
    bool getEnableAvalanching() const;
 
    bool getDeleteSoilParticlesOutsideBounds() const;
 
    agx::Real getSoilParticleLifeTime() const;
 
    agx::Real getPenetrationForceVelocityScaling() const;
 
    agx::Real getAvalancheMaxHeightGrowth() const;
 
    agx::Real getAvalancheDecayFraction() const;
 
    agx::Real getAvalancheErrorThreshold() const;
 
    agx::Real getSoilAggregateLockCompliance(agx::Int dof) const;
 
    bool getCreateParticles() const;
 
    agx::Real getMaximumParticleActivationVolume() const;
 
    agx::Real getActivationSpeed() const;
 
    agx::Real getSoilParticleGrowthRate() const;
 
    bool getEnableCreateDynamicMass() const;
 
    bool getEnableDeformation() const;
 
    void setSoilMergeSpeedThreshold(agx::Real speedThreshold);
 
    void setSoilParticleMergeRate( agx::Real mergeRate );
 
    agx::Real getSoilParticleMergeRate() const;
 
    void setSoilParticleMergeThreshold( agx::Real radiusFraction );
 
    agx::Real getSoilParticleMergeThreshold() const;
 
    void setSoilParticleLifeTime(agx::Real lifeTime);
 
    void setAvalancheDecayFraction(agx::Real decayFraction);
 
    void setAvalancheMaxHeightGrowth(agx::Real maxHeightGrowth);
 
    void setAvalancheErrorThreshold( agx::Real errorThreshold );
 
    void setCreateParticles(bool enable);
 
    void setEnableSoilCompaction(bool enable);
 
    void setDeleteSoilParticlesOutsideBounds(bool enable);
 
    void setEnableLockedBorders(bool enable);
 
    void setEnableAvalanching(bool enable);
 
    void setSoilParticleGrowthRate( agx::Real growthRateFactor );
 
    void setSoilAggregateLockCompliance(agx::Real compliance, agx::Int dof);
 
    void setPenetrationForceVelocityScaling(agx::Real penetrationForceVelocityScaling);
 
    void setMaximumParticleActivationVolume(agx::Real volume);
 
    void setEnableCreateDynamicMass( bool enable );
 
 
    void setEnableDeformation( bool enable );
 
    void setActivationSpeed( agx::Real activationSpeed );
 
    float getSoilParticleSizeScaling() const;
 
    void setSoilParticleSizeScaling(float scalingFactor);
 
    void setEnableGroundCollapse( bool enable );
 
    bool getEnableGroundCollapse() const;
 
    void setAlwaysEnableSoilFailure( bool enable );
 
    bool getAlwaysEnableSoilFailure() const;
 
    void setEnableUpdateDynamicBodyMass(bool enable);
 
    bool getEnableUpdateDynamicBodyMass() const;
 
    agx::UInt32 getFlags() const;
 
    void setFlags(agx::UInt32 flags);
 
    bool isDirty() const;
 
    void setDirty( bool isDirty );
 
    DOXYGEN_START_INTERNAL_BLOCK()
 
    
    TerrainProperties();
 
    TerrainProperties( const TerrainProperties& other );
 
    AGXTERRAIN_STORE_RESTORE_INTERFACE;
 
    DOXYGEN_END_INTERNAL_BLOCK()
  protected:
    virtual ~TerrainProperties();
 
    enum StateFlags : agx::UInt32
    {
      LOCKED_BORDERS = 1 << 0,
      CREATE_PATICLES = 1 << 1,
      DELETE_PARTICLES_OUTSIDE_BOUNDS = 1 << 2,
      ENABLE_SOIL_COMPACTION = 1 << 3,
      ENABLE_AVALANCHING = 1 << 4,
      ENABLE_DYNAMIC_MASS = 1 << 5,
      ENABLE_DEFORMATION = 1 << 6,
      ENABLE_GROUND_COLLAPSE = 1 << 7,
      ENABLE_ALWAYS_SOIL_FAILURE = 1 << 8,
      ENABLE_UPDATE_DYNAMIC_BODY_MASS = 1 << 9,
    };
    using Flags = agx::BitState<StateFlags, agx::UInt32>;
 
  private:
    Flags                    m_flags;
    agx::Real                m_avalancheDecayFraction;
    agx::Real                m_avalancheMaxHeightGrowth;
    agx::Real                m_penetrationForceVelocityScaling;
    agx::Real                m_soilMergeSpeedThreshold;
    agx::Real                m_maximumActivationVolume;
    agx::Real                m_soilParticleLifeTime;
    agx::Real                m_avalancheErrorThreshold;
    std::array<agx::Real, 6> m_soilAggregateCompliance;
    agx::Real                m_activationSpeed;
    agx::Real                m_particleGrowthRateFactor;
    agx::Real                m_soilParticleMergeRate;
    agx::Real                m_soilParticleMergeThreshold;
    float                    m_particleSizeScaling;
    bool                     m_isDirty;
  };
 
 
  inline bool TerrainProperties::getEnableDeformation() const
  {
    return m_flags.Is( StateFlags::ENABLE_DEFORMATION );
  }
 
  inline bool TerrainProperties::getEnableLockedBorders() const
  {
    return m_flags.Is(StateFlags::LOCKED_BORDERS);
  }
 
 
 
  inline agx::Real TerrainProperties::getAvalancheMaxHeightGrowth() const
  {
    return m_avalancheMaxHeightGrowth;
  }
 
 
 
  inline agx::Real TerrainProperties::getAvalancheDecayFraction() const
  {
    return m_avalancheDecayFraction;
  }
 
 
 
  inline bool TerrainProperties::getDeleteSoilParticlesOutsideBounds() const
  {
    return m_flags.Is(StateFlags::DELETE_PARTICLES_OUTSIDE_BOUNDS);
  }
 
 
 
  inline agx::Real TerrainProperties::getPenetrationForceVelocityScaling() const
  {
    return m_penetrationForceVelocityScaling;
  }
 
 
 
  inline agx::Real TerrainProperties::getMaximumParticleActivationVolume() const
  {
    return m_maximumActivationVolume;
  }
 
 
 
  inline agx::Real TerrainProperties::getSoilAggregateLockCompliance(agx::Int dof) const
  {
    return m_soilAggregateCompliance[dof];
  }
 
 
 
  inline bool TerrainProperties::getEnableCreateDynamicMass() const
  {
    return m_flags.Is( StateFlags::ENABLE_DYNAMIC_MASS );
  }
 
 
}