TerrainPager.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/HashSet.h>
#include <agx/HashTable.h>
 
#include <agx/config/AGX_USE_AGXTERRAIN.h>
#include <agxTerrain/export.h>
 
#include <agxSDK/StepEventListener.h>
 
#include <agxTerrain/TileSpecification.h>
#include <agxTerrain/TerrainCache.h>
#include <agxTerrain/TerrainWheel.h>
 
#include <agxStream/StorageStream.h>
 
namespace agxTerrain
{
 
  class TerrainCache;
  class TerrainDataSource;
 
  AGX_DECLARE_POINTER_TYPES(TerrainPager);
  AGX_DECLARE_VECTOR_TYPES(TerrainPager);
 
  class AGXTERRAIN_EXPORT TerrainPager : public agxSDK::StepEventListener
  {
  public:
 
    typedef agx::Callback2< agxTerrain::TileId, agxTerrain::Terrain* > TileCallback;
 
    typedef agx::Event2< agxTerrain::TileId, agxTerrain::Terrain* > TileLoadEvent;
    typedef agx::Event2< agxTerrain::TileId, agxTerrain::Terrain* > TileUnloadEvent;
 
    struct TileAttachments {
      agx::Real               m_lowestPoint;
      agx::Real               m_highestPoint;
      agx::Real               m_zOffset;
      agxTerrain::TerrainRef  m_terrainTile;
 
      agx::UInt32             m_unusedCount;
    };
 
    typedef agx::Vector<TerrainPager::TileAttachments*> TileAttachmentPtrVector;
    typedef agx::Vector<const TerrainPager::TileAttachments*> TileAttachmentConstPtrVector;
 
    TerrainPager(size_t tileResolution, size_t tileOverlap, agx::Real tileElementSize, agx::Real maximumDepth,
                 agx::Vec3 refPoint, agx::Quat refRotation,
                 agxTerrain::Terrain* templateTerrain );
 
 
    //void setTerrainPlaneLocation( agx::Vec3 referencePoint, agx::Quat referenceRotation );
 
    const TileSpecification& getTileSpecification() const;
 
 
    bool setFileCacheDirectory( agx::String dir );
 
    agx::String getFileCacheDirectory() const;
 
    void setShouldStoreCompaction(bool shouldStoreCompaction, size_t maximumCompactionDepth);
 
    bool getShouldStoreCompaction() const;
 
    void setShouldSynchronizeOverlapCompaction( bool shouldSynchronizeCompaction );
 
    bool getShouldSynchronizeOverlapCompaction();
 
    void setDeformable( bool deformable );
 
    inline bool getDeformable() const;
 
    void setEmbedCacheFilesInArchive( bool embed );
 
    bool getEmbedCacheFilesInArhive() const;
 
    void setShouldStoreDeltas(bool shouldStoreDeltas);
 
    bool getShouldStoreDeltas() const;
 
    TileAttachmentPtrVector getActiveTileAttachments();
 
    TileAttachmentConstPtrVector getActiveTileAttachments() const;
 
    SoilSimulationInterface* getSoilSimulationInterface();
 
    bool add( agx::RigidBody* body, agx::Real requiredTileRadius, agx::Real preloadTileRadius );
 
    bool add( agxTerrain::Shovel* shovel, agx::Real requiredTileRadius, agx::Real preloadTileRadius );
 
    bool add(agxTerrain::TerrainWheel* TerrainWheel, agx::Real requiredTileRadius, agx::Real preloadTileRadius);
 
 
    bool remove( agx::RigidBody* body );
 
    bool remove( agxTerrain::Shovel* shovel );
 
    agxTerrain::Terrain* getTemplateTerrain();
 
    void applyChangesToTemplateTerrain();
 
 
    bool setTileLoadRadiuses( agx::RigidBody* body, agx::Real requiredTileRadius, agx::Real preloadTileRadius );
 
    agx::RealPair getTileLoadRadius( agx::RigidBody* body );
 
    TerrainDataSource* getTerrainDataSource();
 
    void setTerrainDataSource( TerrainDataSource* tds );
 
    agx::Physics::GranularBodySystem* getGranularBodySystem() const;
 
 
    virtual void addNotification() override;
 
    virtual void removeNotification() override;
 
 
 
    virtual void preCollide( const agx::TimeStamp& time ) override;
 
 
    virtual void last(const agx::TimeStamp& time) override;
 
 
    void syncOverlap( const agxTerrain::TileId& tileIndex,
      const agx::Vec2i& sourceIndex, bool shouldSynchronizeCompaction);
 
 
    void syncOverlapCallback(agxTerrain::Terrain* terrain);
 
 
    enum TerrainRaycastResult {
 
      RAYCAST_NO_RESULT,                // No hit
      RAYCAST_HIT_ACTIVE_TERRAIN_TILE,  // Hit active paged in tile
      RAYCAST_RESULT_FROM_DATASOURCE    // Hit via TerrainDataSource
    };
 
    TerrainRaycastResult raycast( agx::Vec3 start, agx::Vec3 end, agx::Vec3& result );
 
 
    using StepEventListener::store;
 
    using StepEventListener::restore;
 
    void store(/*agxStream::StorageStream& str*/agxTerrain::TileModificationVector& storeData);
 
    void reset();
 
    void restore(/*agxStream::StorageStream& str*/ const agxTerrain::TileModificationVector& restoreData);
 
 
    TileLoadEvent tileLoadEvent;
 
    TileUnloadEvent tileUnloadEvent;
 
    agx::Real getTotalTerrainMass();
 
    void setBlockingCallbacks(
        TerrainCache::PreBlockFunc preBlock,
        TerrainCache::PostBlockFunc postBlock);
 
    DOXYGEN_START_INTERNAL_BLOCK()
      AGXSTREAM_DECLARE_SERIALIZABLE(agxTerrain::TerrainPager);
    DOXYGEN_END_INTERNAL_BLOCK()
 
  protected:
    TerrainPager();
 
    virtual ~TerrainPager();
 
    void updateActiveTiles();
 
    void unloadUnusedTiles( bool partOfRemoveNotification );
 
    void handleNewTerrainTile( agxTerrain::TerrainTile );
 
    void unloadAllTiles();
 
    void prepareSimulation(bool fromRestore);
 
    agx::Real getOverlappingAreaSolidMass(agxTerrain::TileId, agxTerrain::TileId);
 
    agx::Real getSolidMassBeneathSurfaceCoord(const size_t& x, const size_t& y, agxTerrain::TerrainRef& terrainTile);
 
    void synchronizeCompactionInColumn( agxTerrain::Terrain* sourceTile, agx::Vec2i sourceIndex,
                                        agxTerrain::Terrain* targetTile, agx::Vec2i targetIndex);
 
     void synchronizeTerrainMaterialInColumn( agxTerrain::Terrain* sourceTile, agx::Vec2i sourceIndex,
                                              agxTerrain::Terrain* targetTile, agx::Vec2i targetIndex );
 
    void synchronizeDataInColumn( agxTerrain::TileId sourceTileId, agxTerrain::TileId tileIdOffset, agx::Vec2i sourceIndex,
                                  bool shouldSynchronizeCompaction);
 
    bool isIndexWithinTileMargin(const agx::Vec2i& terrainIndex) const;
 
 
  private:
    DOXYGEN_START_INTERNAL_BLOCK()
    friend class agx::InternalData;
    agx::Referenced* getInternalData() const;
 
    void setInternalData( agx::Referenced* data );
 
    agx::ref_ptr<agx::Referenced> m_internalData;
    DOXYGEN_END_INTERNAL_BLOCK()
 
  private:
    mutable TerrainCache m_cache;
 
    TileSpecification    m_tileSpec;
 
    bool                 m_shouldStoreDeltas;
 
    bool                 m_justRestored;
 
    bool                 m_shouldSynchronizeCompaction;
 
    struct BodyAttachments {
      agx::RigidBodyObserver      m_bodyObserver;
      agx::Real                   m_requiredRadius;
      agx::Real                   m_preloadRadius;
      agxTerrain::ShovelRefVector m_shovels;
      agxTerrain::TerrainWheelRefVector m_terrainWheels;
    };
 
    typedef std::pair<TileId, agx::Vec2i> GlobalTerrainIndex;
 
    // Bodies this TerrainPager keeps track of
    agx::HashTable < agx::RigidBody *, BodyAttachments > m_bodies;
 
    // Tiles this TerrainPager keeps track of
    agx::HashTable< TileId, TileAttachments > m_terrainTiles;
 
    // Stores heightfield changes since the last call to the store method
    agx::HashTable< GlobalTerrainIndex, agx::Real > m_heightFieldDelta;
    //agx::HashTable< TileId, TerrainIndexHeight > m_heightFieldDelta;
 
    agx::Physics::GranularBodySystemRef m_gbs;
 
    agx::Vector<agxTerrain::TileId>  m_missingRequiredTiles;
    agx::HashSet<agxTerrain::TileId> m_pendingRequests;
 
 
 
    void fillTileAttachment( agxTerrain::TerrainTile tile, agxTerrain::TerrainPager::TileAttachments& ta );
 
    void getCompactionFromNeighbourTiles(agxTerrain::TerrainTile tile);
 
    void fillHeightDelta(const GlobalTerrainIndex& gtid, agx::Real height);
 
  };
 
 
  inline void TerrainPager::fillHeightDelta(const GlobalTerrainIndex& gtid, agx::Real height)
  {
    m_heightFieldDelta[gtid] = height;
  }
 
 
  inline void TerrainPager::setEmbedCacheFilesInArchive( bool embed )
  {
    m_cache.setEmbedCacheFilesInArchive( embed );
  }
 
  inline void TerrainPager::setBlockingCallbacks(
      TerrainCache::PreBlockFunc preBlock,
      TerrainCache::PostBlockFunc postBlock)
  {
    m_cache.setBlockingCallbacks(std::move(preBlock), std::move(postBlock));
  }
 
 
  inline bool TerrainPager::getEmbedCacheFilesInArhive() const
  {
    return m_cache.getEmbedCacheFilesInArhive();
  }
 
  inline bool TerrainPager::getDeformable() const
  {
    return m_cache.getTemplateTerrain()->getDeformable();
  }
}