TerrainDataAtlas.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 <agxTerrain/export.h>
#include <agxTerrain/Grid.h>
#include <agx/StackArray.h>
#include <agxTerrain/TerrainMaterial.h>
 
namespace agxTerrain
{
  DOXYGEN_START_INTERNAL_BLOCK()
 
  typedef agx::HashTable<agx::Vec3i, agx::Vec3f> VoxelToVelocityTable;
  typedef agx::HashTable<agx::Vec3i, agx::UInt32> VoxelToTerrainMaterialTable;
  typedef  agx::Vector<TerrainMaterialRef> TerrainMaterialRefVector;
 
  struct MaterialPair {
    TerrainMaterialRef  terrainMaterial;
    agx::MaterialRef    material;
 
    MaterialPair()
      : terrainMaterial( nullptr )
      , material( nullptr ) {}
 
    MaterialPair(TerrainMaterial* terrainMaterial, agx::Material* material)
      : terrainMaterial(terrainMaterial)
      , material(material)
    {}
  };
  typedef agx::Vector<agxTerrain::MaterialPair> MaterialPairVector;
 
  AGX_DECLARE_POINTER_TYPES(TerrainDataAtlas);
 
  /*
  Atlas for holding information about terrain mass and material in the grid system.
  Is active in the same index space as the regular grid.
  */
  class AGXTERRAIN_EXPORT TerrainDataAtlas : public agx::Referenced
  {
    static constexpr float MAX_MASS = 1.0;
 
  public:
    enum MassType
    {
      SOLID,
      PARTICLE,
      FLUID
    };
    struct MassTypeHash
    {
      AGX_FORCE_INLINE agx::UInt32 operator()(TerrainDataAtlas::MassType key) const
      {
        return agx::hash((agx::UInt32)key);
      }
    };
 
  public:
    TerrainDataAtlas(agx::Real voxelSize, size_t resolutionX, size_t resolutionY, agx::Real lowestminimumHeight);
 
 
    float getOccupancy(const Grid::GridCoord& coord) const;
 
 
    /*
    Returns the mass [kg] in the voxel at the given coordinates.
    This is calculated as:
      mass = base_density * compaction * voxelVolume * occupancy == density * filledVolume
    */
    agx::Real getMass(const Grid::GridCoord& coord) const;
 
 
    float addOccupancy(const agx::Vec2i& ti, float occupancy);
 
 
    float addOccupancy(const Grid::GridCoord& coord, float occupancy);
 
 
    float removeOccupancy(const agx::Vec2i& ti, float occupancy, agx::Real& removedMass);
 
 
    float removeOccupancy(const Grid::GridCoord& coord, float occupancy, agx::Real& removedMass);
 
 
    bool addMass(const agx::Vec2i& ti, agx::Real mass, float compaction);
 
 
    bool addMass(const Grid::GridCoord& coord, agx::Real mass, float compaction);
 
 
    float getMassOccupancy(const Grid::GridCoord& coord, MassType massType) const;
 
    void setMassOccupancy(const Grid::GridCoord& coord, MassType massType, float value);
 
    float addMassOccupancy(const Grid::GridCoord& coord, MassType massType, float value);
 
    void setCompaction(const Grid::GridCoord& coord, float value);
 
    float getCompaction(const Grid::GridCoord& coord) const;
 
    float getCompactedSolidMassOccupancy(const Grid::GridCoord& coord) const;
 
    float getMaximumAllowedSolidMassOccupancyInVoxel(const Grid::GridCoord& coord) const;
 
    bool isActiveVoxel(const Grid::GridCoord& coord, MassType massType) const;
 
    agx::Vec3iVector getIndicesWithMassOccupancy(MassType massType) const;
 
 
    float getTotalMassOccupancyInVoxel(const Grid::GridCoord& coord) const;
 
    void setVelocity(const Grid::GridCoord& coord, const agx::Vec3f& value);
    agx::Vec3f getVelocity(const Grid::GridCoord& coord) const;
    void clearVelocityGrid();
 
    bool addNewTerrainMaterial(TerrainMaterial* terrainMaterial);
    void setDefaultTerrainMaterial(TerrainMaterial* defaultTerrainMaterial, agx::Material* defaultMaterial = nullptr);
    TerrainMaterial* getDefaulTerrainMaterial() const;
    int setTerrainMaterialInVoxels(const Grid::GridCoordVector& coords, TerrainMaterial* terrainMaterial);
    bool setTerrainMaterialInVoxel(const Grid::GridCoord& coord, TerrainMaterial* terrainMaterial);
    bool setTerrainMaterialInVoxel(const Grid::GridCoord& coord, const agx::UInt32 terrainMaterialIndex);
 
    /*
    \return the index in the MaterialPair vector if it exists, otherwise agx::InvalidIndex.
    */
    agx::UInt32 getTerrainMaterialPairIndex(TerrainMaterial* terrainMaterial) const;
 
    /*
    \return whether the given index corresponds to any added terrain materials
    */
    bool terrainMaterialIndexIsValid(const agx::UInt32& terrainMaterialIndex) const;
 
    TerrainMaterial* getTerrainMaterialInVoxel(const Grid::GridCoord& coord) const;
    TerrainMaterial* getTerrainMaterialByIndex(const agx::UInt32 terrainMaterialIndex) const;
    agx::Vector<TerrainMaterial*> getTerrainMaterials();
 
    void clearTerrainMaterials();
 
    void setTerrainMaterialIndexInVoxelNoChecks(const Grid::GridCoord& coord, const agx::UInt32 terrainMaterialIndex);
 
 
    bool exchangeTerrainMaterial(TerrainMaterial* oldTerrainMaterial, TerrainMaterial* newTerrainMaterial);
    bool removeTerrainMaterial(TerrainMaterial* terrainMaterialToRemove);
    bool associateMaterialToTerrainMaterial(agx::Material* material, TerrainMaterial* terrainMaterial);
 
    void setDefaultMaterial(agx::Material* defaultMaterial);
    agx::Material* getDefaultMaterial() const;
    agx::Material* getMaterial(TerrainMaterial* terrainMaterial) const;
    agx::Material* getMaterialInVoxel(const Grid::GridCoord& coord) const;
 
    /*
    \returns The corresponding index (>= 0) in m_terrainMaterialPairs.
    */
    agx::UInt32 getTerrainMaterialIndex(const Grid::GridCoord& coord) const;
    void clearTerrainMaterialGrid();
    bool removeSpecificTerrainMaterialFromVoxel(const Grid::GridCoord& coord);
 
    MaterialPairVector getTerrainMaterialPairs();
    void setTerrainMaterialPairs(MaterialPairVector materialPairs);
 
    Grid* getSolidGridMassOccupancyData() const;
 
    BasicGrid* getGridMassOccupancyData(MassType massType) const;
    BasicGrid* getCompactionGridData() const;
 
    size_t getTotalGridMemoryUsage() const;
 
    size_t getTotalActiveVoxels() const;
 
    void clearMassOccupancyGrid(MassType massType);
 
    agx::Real getMassOccupancyInTerrain(MassType massType) const;
 
    VoxelToVelocityTable& getVelocityTable();
    VoxelToTerrainMaterialTable& getTerrainMaterialTable();
 
    bool getEnableMinimumHeights() const;
 
    void setEnableMinimumHeights(bool enable);
 
    agx::RealVector getMinimumHeights() const;
 
    /*
    \param minimumHeights - row major array for setting minimum heights in the terrain.
    */
    void setMinimumHeights(const agx::RealVector& minimumHeights);
 
  public:
    AGXTERRAIN_STORE_RESTORE_INTERFACE;
 
  protected:
    virtual ~TerrainDataAtlas();
 
    agx::Real getBaseDensity(const Grid::GridCoord& coord) const;
    float getBaseDensityFloat(const Grid::GridCoord& coord) const;
 
    void fillGridVector();
 
  protected:
    agx::Real m_voxelSize;
    agx::Real m_voxelVolume;
    BasicGridRef m_solidMassOccupancyGrid;
    BasicGridRef m_fluidMassOccupancyGrid;
    BasicGridRef m_particleMassOccupancyGrid;
    BasicGridRef m_compactionGrid;
 
    VoxelToVelocityTable m_voxelToVelocityTable;
 
    // \todo Move this to a separate grid!
    agx::Vector<MaterialPair>           m_terrainMaterialPairs;
    VoxelToTerrainMaterialTable         m_voxelToTerrainMaterialTable;
 
    agx::StackArray<BasicGrid*, 3> m_gridVector;
 
    Grid*     m_rawSolidMassOccupancyGrid; // alias for m_solidMassGrid
  };
  DOXYGEN_END_INTERNAL_BLOCK()
}