Mesh.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_MESH_H
#define AGXCOLLIDE_MESH_H
 
#include <agx/agxPhysics_export.h>
#include <agx/agx_vector_types.h>
 
#include <agxData/LocalVector.h>
 
#include <GIMPACT/AabbTree.h>
 
#include <agxCollide/agxCollide.h>
#include <agxCollide/MeshData.h>
#include <agxCollide/Shape.h>
 
#include <agxStream/Serializable.h>
 
 
namespace agxCollide
{
  AGX_DECLARE_POINTER_TYPES(Mesh);
 
  class AGXPHYSICS_EXPORT Mesh : public Shape
  {
 
    public:
      class AGXPHYSICS_EXPORT Triangle
      {
          friend class Mesh;
        public:
          agx::Vec3 getVertex( uint_fast8_t localVertexIndex ) const;
 
          agx::Vec3 getNormal() const;
 
          bool isValid() const;
 
          size_t getGlobalVertexIndex( uint_fast8_t localVertexIndex ) const;
 
          agx::Vec3 getEdgeStartVertex( uint_fast8_t localEdgeIndex ) const;
 
          agx::Vec3 getEdgeEndVertex( uint_fast8_t localEdgeIndex ) const;
 
          agx::Real getMaximumEdgeLength() const;
 
          bool hasHalfEdgePartner( uint_fast8_t localEdgeIndex ) const;
 
          const Triangle getHalfEdgePartner( uint_fast8_t localEdgeIndex ) const;
 
          size_t getHalfEdgePartnerGlobalEdgeIndex( uint_fast8_t localEdgeIndex ) const;
 
          size_t getHalfEdgePartnerLocalEdgeIndex( uint_fast8_t localEdgeIndex ) const;
 
          size_t getTriangleIndex() const;
 
          const Mesh* getMesh() const;
 
 
        protected:
          Triangle( const Mesh* mesh, size_t triangleIndex );
 
          Triangle();
 
        protected:
          MeshConstRef m_mesh;
          size_t m_triangleIndex;
 
      };
 
 
      class AGXPHYSICS_EXPORT VertexEdgeCirculator
      {
          friend class Mesh;
 
        public:
          void operator++(int);
 
          VertexEdgeCirculator& operator++ ();
 
          bool isValid() const;
 
          bool atEnd() const;
 
          agx::Vec3 getEdgeStartVertex() const;
 
          agx::Vec3 getEdgeEndVertex() const;
 
          inline const Triangle getTriangle() const;
 
          uint_fast8_t getLocalEdgeIndex() const;
 
          bool hasJustJumpedOverHole() const;
 
          size_t getTriangleIndex() const;
 
          const Mesh* getMesh() const;
 
          VertexEdgeCirculator();
 
        protected:
          VertexEdgeCirculator( const Mesh* mesh,
                                size_t triangleIndex, uint_fast8_t localVertexIndex );
 
        protected:
          MeshConstRef m_mesh;
          size_t m_triangleStartIndex;
          size_t m_triangleIndex;
          uint_fast8_t m_localEdgeStartIndex;
          uint_fast8_t m_localEdgeIndex;
          bool m_hasMoved;
          bool m_hasJustJumpedOverHole;
          bool m_valid;
      };
 
      class AGXPHYSICS_EXPORT FaceEdgeCirculator
      {
          friend class Mesh;
 
        public:
          void operator++(int);
 
          FaceEdgeCirculator& operator++();
 
          bool isValid() const;
 
          bool atEnd() const;
 
          agx::Vec3 getEdgeStartVertex() const;
 
          agx::Vec3 getEdgeEndVertex() const;
 
          const Triangle getTriangle() const;
 
          uint_fast8_t getLocalEdgeIndex() const;
 
          const Mesh* getMesh() const;
 
          FaceEdgeCirculator();
 
        protected:
          FaceEdgeCirculator( const Mesh* mesh, size_t triangleIndex );
 
        protected:
          MeshConstRef m_mesh;
          size_t m_triangleIndex;
          uint_fast8_t m_localEdgeIndex;
          bool m_hasMoved;
          bool m_valid;
      };
 
 
      // Methods of the class Mesh.
    public:
 
      size_t getNumVertices() const;
 
      agx::Vec3 getVertex( size_t globalVertexIndex ) const;
 
      size_t getNumTriangles() const;
 
      agx::Vec3 getTriangleVertex( size_t triangleIndex, uint_fast8_t localVertexIndex ) const;
 
      agx::Vec3 getTriangleNormal( size_t triangleIndex ) const;
 
      size_t getGlobalVertexIndex( size_t triangleIndex, uint_fast8_t localVertexIndex ) const;
 
      agx::Real getTriangleMaximumEdgeLength( size_t triangleIndex ) const;
 
      agx::Real getTotalMaximumEdgeLength() const;
 
      uint32_t getHalfEdgePartnerEdge( size_t globalEdgeIndex ) const;
 
      bool isValid() const;
 
      bool isValidAndClosed() const;
 
      virtual agx::Vec3 getCenter() const override;
 
      virtual agx::Real getVolume() const override;
 
      virtual agx::SPDMatrix3x3 calculateInertia( agx::Real mass ) const override;
 
      bool isTerrain() const;
 
      bool hasInternalCenterPoint() const;
 
      agx::Real getBottomMargin() const;
 
      void setBottomMargin(agx::Real newMargin);
 
      bool isValidEdgeIndex(size_t globalEdgeIndex ) const;
 
      bool isValidTriangleIndex(size_t globalTriangleIndex ) const;
 
      inline const Triangle getTriangle( size_t triangleIndex ) const;
 
      static size_t getLocalEdgeIndex( size_t globalEdgeIndex );
 
      static size_t getGlobalTriangleIndex( size_t globalEdgeIndex );
 
      static size_t getGlobalEdgeIndex ( size_t triangleIndex, uint_fast8_t localEdgeIndex );
 
      void calculateTrianglesInVolume(
        const BoundingAABB& volume, const agx::AffineMatrix4x4& meshToWorld, const agx::AffineMatrix4x4& volumeToWorld,
        agx::UInt32Vector& triangleIndices ) const;
 
      void calculateTrianglesInVolume(
        const BoundingAABB& volume, const agx::AffineMatrix4x4& meshToWorld, const agx::AffineMatrix4x4& volumeToWorld,
        agxData::LocalVector<agx::UInt32>& triangleIndices ) const;
 
 
      struct TriangleLineSegmentResult
      {
        TriangleLineSegmentResult(agx::UInt32 newTriangleIndex,
          agx::Real newLineParameter, bool newIsFrontFace) :
        lineParameter(newLineParameter), triangleIndex(newTriangleIndex),
          isFrontFace(newIsFrontFace)
        {}
        agx::Real lineParameter; // Parameter along line, between 0 and 1.
        agx::UInt32 triangleIndex; // The triangle index.
        bool isFrontFace; // Is triangle hit from front, or back?
      };
 
      typedef agx::Vector<TriangleLineSegmentResult> TriangleLineSegmentResultVector;
 
      void calculateTriangleOverlapsAlongLineSegment(
        const agx::Vec3& segmentStartLocal,
        const agx::Vec3& segmentEndLocal,
        TriangleLineSegmentResultVector& triangleResults) const;
 
      virtual void calculatePossibleTriangleOverlapsAlongLineSegment(
        const agx::Vec3& segmentStartLocal,
        const agx::Vec3& segmentEndLocal,
        agx::UInt32Vector& triangleIndices) const = 0;
 
 
      virtual void calculatePossibleTriangleOverlapsAlongLineSegment(
        const agx::Vec3& segmentStartLocal,
        const agx::Vec3& segmentEndLocal,
        agxData::LocalVector<agx::UInt32>& triangleIndices) const = 0;
 
      VertexEdgeCirculator createVertexEdgeCirculator(
        size_t triangleIndex,
        uint_fast8_t localVertexIndex ) const;
 
      FaceEdgeCirculator createFaceEdgeCirculator(
        size_t triangleIndex ) const;
 
      bool isConvexEdge(size_t globalEdgeIndex) const;
 
      bool isConvexVertex(size_t triangleIndex, size_t localVertexIndex) const;
 
      const CollisionMeshData* getMeshData() const;
 
      bool hasHalfEdge() const;
 
      const AabbTree* getBvhTree() const;
 
      virtual const BoundingAABB& updateBoundingVolume() override;
      virtual BoundingAABB calculateLocalBound() const override;
      const BoundingAABB& getLocalBound() const;
 
      // AGXSTREAM_DECLARE_SERIALIZABLE( agxCollide::Mesh );
 
    protected:
      Mesh (Shape::Type type, agx::Physics::Geometry::ShapePtr entity);
 
      virtual ~Mesh();
 
      void store( class agxStream::OutputArchive& out ) const override;
      void restore( class agxStream::InputArchive& in ) override;
 
      // Update the bounding volume hierarchy.
      virtual void updateBvhTree() = 0;
 
 
    protected:
      CollisionMeshDataRef m_collisionMeshData;
      AabbTreeRef m_aabbTree;
      BoundingAABB m_localBound;
  };
 
 
 
  AGX_FORCE_INLINE size_t Mesh::Triangle::getTriangleIndex() const
  {
    return m_triangleIndex;
  }
 
 
  AGX_FORCE_INLINE size_t Mesh::Triangle::getGlobalVertexIndex( uint_fast8_t localVertexIndex ) const
  {
    return m_mesh->getGlobalVertexIndex( m_triangleIndex, localVertexIndex );
  }
 
 
  AGX_FORCE_INLINE bool Mesh::Triangle::isValid() const
  {
    return m_mesh->isValid() && m_mesh->isValidTriangleIndex( m_triangleIndex );
  }
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::Triangle::getNormal() const
  {
    return m_mesh->getTriangleNormal( m_triangleIndex );
  }
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::Triangle::getVertex( uint_fast8_t localVertexIndex ) const
  {
    return m_mesh->getTriangleVertex( m_triangleIndex, localVertexIndex );
  }
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::Triangle::getEdgeStartVertex( uint_fast8_t localEdgeIndex ) const
  {
    return m_mesh->getTriangleVertex( m_triangleIndex, localEdgeIndex );
  }
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::Triangle::getEdgeEndVertex( uint_fast8_t localEdgeIndex ) const
  {
    return m_mesh->getTriangleVertex( m_triangleIndex, (uint_fast8_t)((localEdgeIndex + (uint_fast8_t)1) % (uint_fast8_t)3) );
  }
 
 
  AGX_FORCE_INLINE agx::Real Mesh::Triangle::getMaximumEdgeLength() const
  {
    return m_mesh->getTriangleMaximumEdgeLength( m_triangleIndex );
  }
 
 
  inline size_t Mesh::Triangle::getHalfEdgePartnerGlobalEdgeIndex( uint_fast8_t localEdgeIndex ) const
  {
    return m_mesh->getHalfEdgePartnerEdge( Mesh::getGlobalEdgeIndex( m_triangleIndex, localEdgeIndex ) );
  }
 
 
  inline const Mesh::Triangle Mesh::Triangle::getHalfEdgePartner( uint_fast8_t localEdgeIndex ) const
  {
    agxAssert( localEdgeIndex < 3 );
    return Triangle( m_mesh, this->getHalfEdgePartnerGlobalEdgeIndex( localEdgeIndex ) / 3 ) ;
  }
 
 
  AGX_FORCE_INLINE size_t Mesh::Triangle::getHalfEdgePartnerLocalEdgeIndex( uint_fast8_t localEdgeIndex ) const
  {
    agxAssert( localEdgeIndex < 3 );
    return this->getHalfEdgePartnerGlobalEdgeIndex( localEdgeIndex ) % 3;
  }
 
 
 
  AGX_FORCE_INLINE bool Mesh::Triangle::hasHalfEdgePartner( uint_fast8_t localEdgeIndex )
  const
  {
    return m_mesh->isValidEdgeIndex( this->getHalfEdgePartnerGlobalEdgeIndex( localEdgeIndex ) );
  }
 
 
  AGX_FORCE_INLINE const Mesh* Mesh::Triangle::getMesh() const
  {
    return m_mesh.get();
  }
 
 
  AGX_FORCE_INLINE size_t Mesh::getGlobalEdgeIndex ( size_t triangleIndex, uint_fast8_t localEdgeIndex )
  {
    return 3 * triangleIndex + localEdgeIndex;
  }
 
 
  inline const Mesh::Triangle Mesh::getTriangle( size_t triangleIndex ) const
  {
    return Mesh::Triangle( this, triangleIndex );
  }
 
 
  AGX_FORCE_INLINE size_t Mesh::getLocalEdgeIndex( size_t globalEdgeIndex )
  {
    return globalEdgeIndex % 3;
  }
 
 
  AGX_FORCE_INLINE size_t Mesh::getGlobalTriangleIndex( size_t globalEdgeIndex )
  {
    return globalEdgeIndex / 3;
  }
 
 
  AGX_FORCE_INLINE size_t Mesh::getNumVertices() const
  {
    return m_collisionMeshData->m_vertices.size();
  }
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::getVertex( size_t globalVertexIndex ) const
  {
    return m_collisionMeshData->m_vertices[ globalVertexIndex ];
  }
 
 
  AGX_FORCE_INLINE size_t Mesh::getNumTriangles() const
  {
    return m_collisionMeshData->m_numTriangles;
  }
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::getTriangleVertex( size_t triangleIndex, uint_fast8_t localVertexIndex ) const
  {
    return m_collisionMeshData->m_vertices[m_collisionMeshData->m_indices[3 * triangleIndex + localVertexIndex]];
  }
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::getTriangleNormal( size_t triangleIndex ) const
  {
    return m_collisionMeshData->m_normals[triangleIndex];
  }
 
 
  AGX_FORCE_INLINE size_t Mesh::getGlobalVertexIndex( size_t triangleIndex, uint_fast8_t localVertexIndex ) const
  {
    return m_collisionMeshData->m_indices[3 * triangleIndex + localVertexIndex];
  }
 
 
  AGX_FORCE_INLINE agx::Real Mesh::getTriangleMaximumEdgeLength( size_t triangleIndex ) const
  {
    return m_collisionMeshData->m_triangleMaximumEdgeLengths[triangleIndex];
  }
 
 
  AGX_FORCE_INLINE agx::Real Mesh::getTotalMaximumEdgeLength() const
  {
    return m_collisionMeshData->m_totalMaximumEdgeLength;
  }
 
 
  AGX_FORCE_INLINE uint32_t Mesh::getHalfEdgePartnerEdge( size_t globalEdgeIndex ) const
  {
    return m_collisionMeshData->m_halfEdges[globalEdgeIndex];
  }
 
 
  AGX_FORCE_INLINE bool Mesh::isValid() const
  {
    return m_collisionMeshData->m_valid;
  }
 
 
  AGX_FORCE_INLINE bool Mesh::isValidAndClosed() const
  {
    return (m_collisionMeshData->m_valid && m_collisionMeshData->m_closed);
  }
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::getCenter() const
  {
    return m_collisionMeshData->m_center;
  }
 
 
  AGX_FORCE_INLINE agx::Real Mesh::getVolume() const
  {
    return m_collisionMeshData->m_volume;
  }
 
 
  AGX_FORCE_INLINE agx::SPDMatrix3x3 Mesh::calculateInertia( agx::Real mass ) const
  {
    return mass * m_collisionMeshData->m_inertia;
  }
 
 
  AGX_FORCE_INLINE bool Mesh::isTerrain() const
  {
    return m_collisionMeshData->m_isTerrain;
  }
 
  AGX_FORCE_INLINE bool Mesh::hasInternalCenterPoint() const
  {
    return m_collisionMeshData->m_hasInternalCenterPoint;
  }
 
 
  AGX_FORCE_INLINE agx::Real Mesh::getBottomMargin() const
  {
    return m_collisionMeshData->m_bottomMargin;
  }
 
 
  AGX_FORCE_INLINE void Mesh::setBottomMargin(agx::Real newMargin)
  {
    if (newMargin >= 0) {
      m_collisionMeshData->m_bottomMargin = newMargin;
      incrementModifiedCount();
      updateBoundingVolume();
    }
  }
 
 
  AGX_FORCE_INLINE bool Mesh::isValidEdgeIndex(size_t globalEdgeIndex ) const
  {
    return globalEdgeIndex < m_collisionMeshData->m_indices.size();
  }
 
 
  AGX_FORCE_INLINE bool Mesh::isValidTriangleIndex(size_t globalTriangleIndex ) const
  {
    return globalTriangleIndex < m_collisionMeshData->m_numTriangles;
  }
 
 
  AGX_FORCE_INLINE const CollisionMeshData* Mesh::getMeshData() const
  {
    return m_collisionMeshData.get();
  }
 
 
  AGX_FORCE_INLINE bool Mesh::hasHalfEdge() const
  {
    return m_collisionMeshData->m_hasHalfEdge;
  }
 
 
  AGX_FORCE_INLINE const AabbTree* Mesh::getBvhTree() const
  {
    return m_aabbTree;
  }
 
 
 
  // From class VertexEdgeCirculator.
 
  AGX_FORCE_INLINE void Mesh::VertexEdgeCirculator::operator++(int)
  {
    if (m_valid) {
      if (m_hasJustJumpedOverHole) {
        // must have moved already to come here
        // keep same triangle, just move local index
        m_localEdgeIndex = (uint_fast8_t)((m_localEdgeIndex + (uint_fast8_t)1) % (uint_fast8_t)3);
        m_hasJustJumpedOverHole = false;
      } else {
        m_hasMoved = true;
        size_t he = m_mesh->getHalfEdgePartnerEdge(3 * m_triangleIndex + m_localEdgeIndex);
        if (!m_mesh->isValidEdgeIndex(he)) {
          // Found hole.
          // Go all the way in counter clockwise direction from start.
          m_triangleIndex = m_triangleStartIndex;
          m_localEdgeIndex = (uint_fast8_t)((m_localEdgeStartIndex + (uint_fast8_t)2) % (uint_fast8_t)3);
          m_hasJustJumpedOverHole = true;
          size_t he2 = m_mesh->getHalfEdgePartnerEdge(3 * m_triangleIndex + m_localEdgeIndex);
          while (m_mesh->isValidEdgeIndex( he2 )) {
            m_triangleIndex = he2 / 3;
            m_localEdgeIndex = (uint_fast8_t)((he2 + 2) % 3);
            he2 = m_mesh->getHalfEdgePartnerEdge(3 * m_triangleIndex + m_localEdgeIndex);
          }
        } else {
          // normal case not influenced by hole: continue in clockwise direction
          m_triangleIndex = he / 3;
          m_localEdgeIndex = (uint_fast8_t)((he + 1) % 3);
        }
      }
    }
  }
 
 
  AGX_FORCE_INLINE Mesh::VertexEdgeCirculator& Mesh::VertexEdgeCirculator::operator++()
  {
    (*this)++;
    return *this;
  }
 
 
 
  AGX_FORCE_INLINE bool Mesh::VertexEdgeCirculator::isValid() const
  {
    return m_valid;
  }
 
 
 
  AGX_FORCE_INLINE bool Mesh::VertexEdgeCirculator::atEnd() const
  {
    return (m_valid && m_hasMoved && m_localEdgeIndex == m_localEdgeStartIndex &&
            m_triangleIndex == m_triangleStartIndex);
  }
 
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::VertexEdgeCirculator::getEdgeStartVertex()
  const
  {
    return m_mesh->getMeshData()->m_vertices[
             m_mesh->getMeshData()->m_indices[3 * m_triangleIndex + m_localEdgeIndex]];
  }
 
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::VertexEdgeCirculator::getEdgeEndVertex()
  const
  {
    return m_mesh->getMeshData()->m_vertices[
             m_mesh->getMeshData()->m_indices[3 * m_triangleIndex + (m_localEdgeIndex + 1) % 3]];
  }
 
 
  AGX_FORCE_INLINE bool Mesh::VertexEdgeCirculator::hasJustJumpedOverHole() const
  {
    return m_hasJustJumpedOverHole;
  }
 
 
  inline const Mesh::Triangle Mesh::VertexEdgeCirculator::getTriangle()
  const
  {
    return Triangle( m_mesh->getTriangle( m_triangleIndex ));
  }
 
 
  AGX_FORCE_INLINE uint_fast8_t Mesh::VertexEdgeCirculator::getLocalEdgeIndex() const
  {
    return m_localEdgeIndex;
  }
 
 
  AGX_FORCE_INLINE size_t Mesh::VertexEdgeCirculator::getTriangleIndex() const
  {
    return m_triangleIndex;
  }
 
 
  AGX_FORCE_INLINE const Mesh* Mesh::VertexEdgeCirculator::getMesh() const
  {
    return m_mesh.get();
  }
 
 
  AGX_FORCE_INLINE void Mesh::calculateTrianglesInVolume( const BoundingAABB& volume,
      const agx::AffineMatrix4x4& meshToWorld, const agx::AffineMatrix4x4& volumeToWorld,
      agx::UInt32Vector& triangleIndices ) const
  {
    m_aabbTree->findCollision(&volume, std::back_inserter(triangleIndices), meshToWorld, volumeToWorld );
  }
 
 
 
  AGX_FORCE_INLINE void Mesh::calculateTrianglesInVolume( const BoundingAABB& volume,
      const agx::AffineMatrix4x4& meshToWorld, const agx::AffineMatrix4x4& volumeToWorld,
      agxData::LocalVector<agx::UInt32>& triangleIndices ) const
  {
    m_aabbTree->findCollision(&volume, std::back_inserter(triangleIndices), meshToWorld, volumeToWorld );
  }
 
 
  inline Mesh::VertexEdgeCirculator Mesh::createVertexEdgeCirculator(
    size_t triangleIndex,
    uint_fast8_t localVertexIndex ) const
  {
    return VertexEdgeCirculator( this, triangleIndex, localVertexIndex );
  }
 
 
 
  // From class FaceEdgeCirculator.
 
  AGX_FORCE_INLINE void Mesh::FaceEdgeCirculator::operator++(int)
  {
    if (m_valid) {
      m_hasMoved = true;
      m_localEdgeIndex = (uint_fast8_t)((m_localEdgeIndex + (uint_fast8_t)1) % (uint_fast8_t)3);
    }
  }
 
 
  AGX_FORCE_INLINE Mesh::FaceEdgeCirculator& Mesh::FaceEdgeCirculator::operator++()
  {
    (*this)++;
    return *this;
  }
 
 
  AGX_FORCE_INLINE bool Mesh::FaceEdgeCirculator::isValid() const
  {
    return m_valid;
  }
 
 
 
  AGX_FORCE_INLINE bool Mesh::FaceEdgeCirculator::atEnd() const
  {
    return (m_valid && m_hasMoved && m_localEdgeIndex == 0);
  }
 
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::FaceEdgeCirculator::getEdgeStartVertex()
  const
  {
    return m_mesh->getMeshData()->m_vertices[
             m_mesh->getMeshData()->m_indices[3 * m_triangleIndex + m_localEdgeIndex]];
  }
 
 
 
  AGX_FORCE_INLINE agx::Vec3 Mesh::FaceEdgeCirculator::getEdgeEndVertex()
  const
  {
    return m_mesh->getMeshData()->m_vertices[
             m_mesh->getMeshData()->m_indices[3 * m_triangleIndex + (m_localEdgeIndex + 1) % 3]];
  }
 
 
  inline const Mesh::Triangle Mesh::FaceEdgeCirculator::getTriangle()
  const
  {
    return m_mesh->getTriangle( m_triangleIndex );
  }
 
 
  AGX_FORCE_INLINE uint_fast8_t Mesh::FaceEdgeCirculator::getLocalEdgeIndex() const
  {
    return m_localEdgeIndex;
  }
 
 
 
  inline Mesh::FaceEdgeCirculator Mesh::createFaceEdgeCirculator(
    size_t triangleIndex ) const
  {
    return FaceEdgeCirculator( this, triangleIndex );
  }
 
 
  AGX_FORCE_INLINE const Mesh* Mesh::FaceEdgeCirculator::getMesh() const
  {
    return m_mesh.get();
  }
 
  AGX_FORCE_INLINE const BoundingAABB& Mesh::getLocalBound() const
  {
    return m_localBound;
  }
 
 
}
 
#endif /* AGXCOLLIDE_MESH_H */