CompactionController.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 <agxTerrain/TerrainContactGenerator.h>
#include <agx/Vec3.h>
 
namespace agxCollide
{
  class Geometry;
}
 
namespace agxTerrain
{
  class Terrain;
  class TerrainDataAtlas;
  class TerrainMassOccupancyController;
 
  typedef agx::HashTable<agxCollide::Geometry*, agx::Real> GeometryContactTimeTable;
  typedef agx::HashTable<agx::Vec3i, agx::Real> VoxelStressTable;
 
  AGX_DECLARE_POINTER_TYPES(CompactionController);
  AGX_DECLARE_VECTOR_TYPES(CompactionController);
 
  class AGXTERRAIN_EXPORT CompactionController : public agx::Referenced
  {
  public:
    enum StressCalculationMethod
    {
      BOUSSINESQ,
      UNIFORM_DISK
    };
 
    enum CompactionMethod
    {
      DENSITY_LOG10,
      VOID_RATIO_LN
    };
 
  public:
    CompactionController(Terrain* terrain);
 
    CompactionController();
 
    void onPost();
 
    void setStressMethod(StressCalculationMethod stressMethod);
 
    StressCalculationMethod getStressMethod() const;
 
    void setCompactionMethod(CompactionMethod compactionMethod);
 
    CompactionMethod getCompactionMethod() const;
 
    bool applyCompactionFromSurfaceForce(const agx::Vec2i& terrainIndex, agx::Real surfaceForce, agx::Real contactTime);
 
    agx::Real getStressInVoxel(const agx::Vec3i& voxelIndex) const;
 
    const agx::HashSet<agx::Vec2i>& getCompressedTerrainIndices() const;
 
  public:
    DOXYGEN_START_INTERNAL_BLOCK()
    AGXTERRAIN_STORE_RESTORE_INTERFACE;
    DOXYGEN_END_INTERNAL_BLOCK()
 
  protected:
    virtual ~CompactionController();
 
    void updateCompactionFromTerrainContacts(const TerrainContactRefVector& contacts);
 
    // Compact the terrain using the uniform disk method
    void handleCompactionFromTerrainContactsUniformDisk(const TerrainContactRefVector& contacts);
 
    // Compact the terrain using the uniform disk method
    agx::Bool compactColumnWithPointForcesUniformDiskLoad(
      const agx::Vec2i& terrainIndex, agx::Real surfaceStress, agx::Real loadRadius, agx::Real currentContactTime);
 
    // Compact the terrain using the BOUSSINESQ method
    void handleCompactionFromTerrainContactsBoussinesq(const TerrainContactRefVector& contacts);
 
    // Compact the terrain using the BOUSSINESQ method
    agx::Bool compactColumnWithPointForces(const agx::Vec2i& terrainIndex,
                                           const TerrainContact::SurfaceForceVector& pointForces,
                                           agx::Real surfaceStress,
                                           bool voxelSurfacecIsInContactArea,
                                           agx::Real minDepth,
                                           agx::Real maxDepth,
                                           agx::Real currentContactTime);
 
    // Calculate compaction in voxel given a compaction stress and time factor
    bool doCompactionInVoxel(const agx::Vec3i& voxelIndex, agx::Real compactionStress, agx::Real timeFactor);
 
    // Calculate subsoil stress in the BOUSSINESQ method
    agx::Real calculateTotalSubSoilStress(const agx::Vec3& voxelPoint,
                                          bool voxelSurfacecIsInContactArea,
                                          const TerrainContact::SurfaceForceVector& pointForces) const;
 
    void debugRenderStressInNode(const agx::Vec3& position, agx::Real stress) const;
 
    TerrainMassOccupancyController* getMassOccupancyController() const;
 
    friend class Terrain;
 
  private:
    Terrain* m_terrain;
    VoxelStressTable m_voxelIndexToStress;
    agx::HashSet<agx::Vec2i> m_compressedTerrainIndices;
    StressCalculationMethod m_stressMethod;
    CompactionMethod m_compactionMethod;
  };
}