TileSpecification.h

Go to the documentation of this file.

/*
Copyright 2007-2024. 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/Integer.h>
#include <agx/Vec3.h>
#include <agx/Quat.h>
#include <agx/AffineMatrix4x4.h>
#include <agx/HashFunction.h>
 
#include <agxStream/StorageStream.h>
 
#include <utility>
 
namespace agx {
 
  typedef std::pair< Real, Real > RealPair;
 
}
 
namespace agxTerrain
{
  class Terrain;
 
 
  typedef agx::Vec2i32 TileId;
 
 
  class AGXTERRAIN_EXPORT TileModification
  {
    public:
      agxTerrain::TileId tileId;
      agx::Vec2i32       vertexIndex;
      float              height;
  };
 
  typedef agx::VectorPOD<TileModification>   TileModificationVector;
 
 
  class AGXTERRAIN_EXPORT TileSpecification
  {
    public:
 
      TileSpecification( agx::Vec3 refPoint, agx::Quat refRotation,
                         agx::Real tileSize, size_t marginSize,
                         size_t resolution, agx::Real maxDepth );
 
      TileSpecification();
 
      agx::Vec3 getReferencePoint() const;
 
      agx::Quat getReferenceRotation() const;
 
      agx::Real getTileSize() const;
 
      size_t getTileMarginSize() const;
 
 
      size_t getTileResolution() const;
 
      agx::Real getMaximumDepth() const;
 
 
 
      agx::Vec3 convertWorldCoordinateToTilePosition( agx::Vec3 worldPos ) const;
 
      agxTerrain::TileId convertWorldCoordinateToTileId( agx::Vec3 worldPos ) const;
 
      agx::Vec3 convertTilePositionToWorld( agxTerrain::TileId id, agx::Vec2 tilePos ) const;
 
 
      agx::Vec3 convertTilePositionToWorld( agxTerrain::TileId id, agx::Vec3 tilePos ) const;
 
 
      agx::AffineMatrix4x4 getTileTransform( agxTerrain::TileId id, agx::Real zPos = 0 ) const;
 
      agx::AffineMatrix4x4 getTileTransform( agxTerrain::TileId id, agx::Vec3 localOffset ) const;
 
      agx::Vec3 getTileCenter( agxTerrain::TileId id ) const;
 
    public:
      DOXYGEN_START_INTERNAL_BLOCK()
      void store(agxStream::OutputArchive& out) const;
      void restore(agxStream::InputArchive& in);
      DOXYGEN_END_INTERNAL_BLOCK()
 
    private:
      agx::Vec3 m_referencePoint;
      agx::Quat m_referenceRotation;
 
      agx::Real m_tileSize;
      size_t m_tileMarginSize;
      size_t    m_tileResolution;
 
      agx::Real m_maximumDepth;
 
      agx::AffineMatrix4x4 m_gridToWorld;
      agx::AffineMatrix4x4 m_worldToGrid;
  };
 
 
 
 
  AGX_FORCE_INLINE agx::Vec3 TileSpecification::getReferencePoint() const
  {
    return m_referencePoint;
  }
 
  AGX_FORCE_INLINE agx::Quat TileSpecification::getReferenceRotation() const
  {
    return m_referenceRotation;
  }
 
  AGX_FORCE_INLINE agx::Real TileSpecification::getTileSize() const
  {
    return m_tileSize;
  }
 
  AGX_FORCE_INLINE size_t TileSpecification::getTileMarginSize() const
  {
    return m_tileMarginSize;
  }
 
  AGX_FORCE_INLINE size_t TileSpecification::getTileResolution() const
  {
    return m_tileResolution;
  }
 
  AGX_FORCE_INLINE agx::Real TileSpecification::getMaximumDepth() const
  {
    return m_maximumDepth;
  }
 
  AGX_FORCE_INLINE agx::Vec3 TileSpecification::convertTilePositionToWorld( agxTerrain::TileId id, agx::Vec2 tilePos ) const
  {
    return convertTilePositionToWorld( id, agx::Vec3( tilePos, 0.0 ) );
  }
 
 
  AGX_FORCE_INLINE agx::Vec3 TileSpecification::convertWorldCoordinateToTilePosition( agx::Vec3 worldPos ) const
  {
    return worldPos * m_worldToGrid;
  }
 
 
 
  AGX_FORCE_INLINE agx::AffineMatrix4x4 TileSpecification::getTileTransform( agxTerrain::TileId id, agx::Real zPos ) const
  {
    agx::Vec3 center = getTileCenter( id );
    center[2] += zPos;
 
    return agx::AffineMatrix4x4::translate( center ) * m_gridToWorld;
  }
 
 
  AGX_FORCE_INLINE agx::AffineMatrix4x4 TileSpecification::getTileTransform( agxTerrain::TileId id, agx::Vec3 localOffset ) const
  {
    agx::Vec3 center = getTileCenter( id );
 
    return agx::AffineMatrix4x4::translate( center + localOffset ) * m_gridToWorld;
 
  }
}