agxCollide/HeightField.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.
*/
 
#ifndef AGXCOLLIDE_HEIGHTFIELD_H
#define AGXCOLLIDE_HEIGHTFIELD_H
 
#include <agx/agxPhysics_export.h>
 
#include <agx/Vec2.h>
#include <agx/agx_vector_types.h>
 
#include <agxCollide/Mesh.h>
#include <agxStream/Serializable.h>
#include <GIMPACT/AabbTree.h>
 
#include <agxData/LocalVector.h>
#include <agx/Physics/Geometry/HeightFieldEntity.h>
 
namespace agxIO
{
  class Image;
}
 
namespace agxCollide
{
  AGX_DECLARE_POINTER_TYPES(HeightField);
 
  class AGXPHYSICS_EXPORT HeightField : public Mesh
  {
    public:
      static agxCollide::HeightField* createFromImage( agxIO::Image* image,
          agx::Real sizeX, agx::Real sizeY,
          agx::Real low, agx::Real high,
          agx::Real bottomMargin = agx::Real(1));
 
      static agxCollide::HeightField* createFromFile( const agx::String& filename,
          agx::Real sizeX, agx::Real sizeY,
          agx::Real low, agx::Real high,
          agx::Real bottomMargin = agx::Real(1));
 
    public:
 
      HeightField(size_t resolutionX, size_t resolutionY, agx::Real sizeX,
                  agx::Real sizeY, agx::Real bottomMargin = agx::Real(1));
 
      HeightField(size_t resolutionX, size_t resolutionY, agx::Real sizeX,
                  agx::Real sizeY, const agx::RealVector& heights, bool flipY = false, agx::Real bottomMargin = agx::Real(1));
 
      void setHeights(const agx::RealVector& heights, bool flipY = false);
 
      void setHeightsFromList(const agx::Vec2uVector& indices, const agx::RealVector& heights);
 
      bool setHeights(const agx::RealVector& heights,
                      size_t minVertexX, size_t maxVertexX,
                      size_t minVertexY, size_t maxVertexY);
 
      void setHeight(size_t xIndex, size_t yIndex, agx::Real height);
 
      agx::Real getHeight(size_t x, size_t y) const;
 
      size_t getResolutionX() const;
 
      size_t getResolutionY() const;
 
      Mesh::Triangle getTriangleFromPoint(const agx::Vec3& point) const;
 
      agx::Vec2 projectPointToGrid(const agx::Vec3& point) const;
 
      agx::Real getMinHeight() const;
 
      agx::Real getMaxHeight() const;
 
      agx::Vec2 getSize() const;
 
      agx::Vec2 getScale() const;
 
      agx::Vec3 getVertexFromGrid(size_t xIndex, size_t yIndex) const;
 
      void setMinAllowedHeight(agx::Real minAllowedHeight);
 
      agx::Real getMinAllowedHeight() const;
 
      void setDynamic(bool dynamic);
 
      bool getDynamic() const;
 
      bool calculateVertexIndicesTouchedByAABB(
        const BoundingAABB& volume,
        const agx::AffineMatrix4x4& meshToWorld,
        const agx::AffineMatrix4x4& volumeToWorld,
        agx::Vec2i& gridMin,
        agx::Vec2i& gridMax) const;
 
      virtual void calculatePossibleTriangleOverlapsAlongLineSegment(
        const agx::Vec3& segmentStartLocal,
        const agx::Vec3& segmentEndLocal,
        agx::UInt32Vector& triangleIndices) const override;
 
 
      virtual void calculatePossibleTriangleOverlapsAlongLineSegment(
        const agx::Vec3& segmentStartLocal,
        const agx::Vec3& segmentEndLocal,
        agxData::LocalVector<agx::UInt32>& triangleIndices) const override;
 
      void calculateVertexCoordinates(
        size_t vertexIndex,
        size_t& vertexIndexX, size_t& vertexIndexY) const;
 
      size_t getTriangleIndex(
        size_t indexX, size_t indexY,
        uint_fast8_t upper) const;
 
      HeightField* shallowCopy() const;
 
      HeightField* deepCopy() const;
 
      void calculateMassProperties();
 
      const HeightFieldMeshData* getHeightFieldMeshData() const;
 
      virtual Shape* clone() const override;
 
      agx::Physics::Geometry::HeightFieldPtr getEntity() const;
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxCollide::HeightField );
      DOXYGEN_END_INTERNAL_BLOCK()
 
    protected:
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
      // Update the bounding volume hierarchy.
      virtual void updateBvhTree() override;
 
      void updateTriangle(size_t triangleIndex, bool shouldUpdateBvhNode = true);
 
      void addQuadrantVolume(int xIndex, int yIndex, agx::Real factor);
 
      void addTriangleVolume(const agx::Vec3& v0, const agx::Vec3& v1,
                             const agx::Vec3& v2, agx::Real factor);
 
 
      // Builds a partial tree of the bounding volume hierarchy.
      void buildSubTree(
        agx::Vec2u start,
        agx::Vec2u end,
        int& nextNodeIndex,
        int parentIndex );
 
      void finalize(bool updateMassProperties, const agx::RealVector& heights, bool flipY = false);
 
      void setHeights(bool shouldUpdateMassProperties, const agx::RealVector& heights, bool flipY = false);
 
      // Hiding default constructor.
      HeightField();
 
      // hiding assignment operator
      HeightField& operator=(const HeightField&);
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
      // hiding destructor
      virtual ~HeightField();
 
 
    protected:
      HeightFieldMeshDataRef m_heightFieldData;
  };
 
 
 
  /* IMPLEMENTATIONS */
 
  AGX_FORCE_INLINE agx::Real HeightField::getMinHeight() const
  {
    return m_localBound.min().z() + m_collisionMeshData->m_bottomMargin;
  }
 
 
  AGX_FORCE_INLINE agx::Real HeightField::getMaxHeight() const
  {
    return m_localBound.max().z();
  }
 
 
  AGX_FORCE_INLINE size_t HeightField::getResolutionX() const
  {
    return m_heightFieldData->m_resolutionX;
  }
 
 
  AGX_FORCE_INLINE size_t HeightField::getResolutionY() const
  {
    return m_heightFieldData->m_resolutionY;
  }
 
 
  AGX_FORCE_INLINE agx::Real HeightField::getHeight(size_t x, size_t y) const
  {
    return m_collisionMeshData->m_vertices[x + y * m_heightFieldData->m_resolutionX][2];
  }
 
 
  AGX_FORCE_INLINE agx::Vec2 HeightField::getSize() const
  {
    return m_heightFieldData->m_size;
  }
 
 
  AGX_FORCE_INLINE agx::Vec2 HeightField::getScale() const
  {
    return m_heightFieldData->m_scale;
  }
 
 
  AGX_FORCE_INLINE void HeightField::calculateVertexCoordinates( size_t vertexIndex,
      size_t& vertexIndexX, size_t& vertexIndexY) const
  {
    vertexIndexX = vertexIndex % m_heightFieldData->m_resolutionX;
    vertexIndexY = vertexIndex / m_heightFieldData->m_resolutionX;
  }
 
 
  AGX_FORCE_INLINE size_t HeightField::getTriangleIndex(size_t indexX, size_t indexY, uint_fast8_t upper) const
  {
    return 2 * (indexX + indexY * (m_heightFieldData->m_resolutionX - 1)) + upper;
  }
 
 
 
  AGX_FORCE_INLINE agx::Vec3 HeightField::getVertexFromGrid(size_t xIndex, size_t yIndex) const
  {
    return getVertex(yIndex * m_heightFieldData->m_resolutionX + xIndex);
  }
 
 
  AGX_FORCE_INLINE void HeightField::setMinAllowedHeight( agx::Real minAllowedHeight )
  {
    m_heightFieldData->m_minAllowedHeight = minAllowedHeight;
    if (m_heightFieldData->m_dynamic)
      calculateMassProperties();
  }
 
 
  AGX_FORCE_INLINE agx::Real HeightField::getMinAllowedHeight() const
  {
    return m_heightFieldData->m_minAllowedHeight;
  }
 
 
  AGX_FORCE_INLINE bool HeightField::getDynamic() const
  {
    return m_heightFieldData->m_dynamic;
  }
 
 
  AGX_FORCE_INLINE void HeightField::setDynamic( bool dynamic )
  {
    m_heightFieldData->m_dynamic = dynamic;
    calculateMassProperties();
  }
 
 
  AGX_FORCE_INLINE const HeightFieldMeshData* HeightField::getHeightFieldMeshData() const
  {
    return m_heightFieldData;
  }
 
 
  AGX_FORCE_INLINE agx::Vec2 HeightField::projectPointToGrid(const agx::Vec3& point) const
  {
    const agx::Vec2 projectedPoint = agx::Vec2(point[0], point[1]) + m_heightFieldData->m_size * agx::Real(0.5);
    const agx::Vec2 pointInGrid(projectedPoint[0] * m_heightFieldData->m_invScale[0], projectedPoint[1] * m_heightFieldData->m_invScale[1]);
    return pointInGrid;
  }
 
  inline agx::Physics::Geometry::HeightFieldPtr HeightField::getEntity() const
  {
    return m_entity;
  }
}
 
 
#endif /* AGXCOLLIDE_HEIGHTFIELD_H */