Trimesh.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_TRIMESH_H
#define AGXCOLLIDE_TRIMESH_H
 
#include <agx/agx_vector_types.h>
 
#include <agx/agxPhysics_export.h>
#include <agxCollide/Mesh.h>
 
#include <agxStream/Serializable.h>
 
#include <agxData/LocalVector.h>
 
 
 
namespace agxCollide
{
  AGX_DECLARE_POINTER_TYPES(Trimesh);
 
  class AGXPHYSICS_EXPORT Trimesh : public agxCollide::Mesh
  {
  public:
 
    enum TrimeshOptionsFlags {
      CLOCKWISE_ORIENTATION = 0x1,
      NO_WARNINGS = 0x10,
      TERRAIN = 0x20,
      REMOVE_DUPLICATE_VERTICES = 0x40,
      RECALCULATE_NORMALS_GIVEN_FIRST_TRIANGLE = 0x80
    };
 
 
    // Trimesh member declarations //
 
    // Constructors //
 
    Trimesh(
      const agx::Vec3Vector* vertices, const agx::UInt32Vector* indices,
      const char* sourceName, uint32_t optionsMask = Trimesh::REMOVE_DUPLICATE_VERTICES, agx::Real bottomMargin = 0);
 
    // Accessors //
 
    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;
 
    virtual Shape* clone() const override;
 
    Trimesh* shallowCopy() const;
 
    Trimesh* deepCopy() const;
 
    void updateMeshGeometry(bool showWarnings, bool recalculateMassProperties = true);
 
    uint32_t getOptionsMask() const;
 
    const agx::String& getSourceName() const;
 
    const agx::String& getWarnings() const;
 
    bool isShallowCopy() const;
 
    const Trimesh* getShallowCopySource();
 
    AGXSTREAM_DECLARE_SERIALIZABLE(agxCollide::Trimesh);
 
  private:
    Trimesh();
 
    Trimesh(const Trimesh& trimesh);
 
    Trimesh& operator=(const Trimesh& trimesh);
 
    void addConstructionData(const agx::Vec3Vector* vertices,
      const agx::UInt32Vector* indices,
      const char* sourceName,
      uint32_t optionsMask);
 
    void finalize(const char* sourceName, bool showWarnings, uint32_t optionsMask);
 
    void flipNormal(const size_t triangleIndex);
 
    bool getTriangleHalfEdgePartnerTriangleIndexAndLocalEdgeIndex(const size_t triangleIndex, const size_t localEdgeIndex, size_t& neighborIndex, size_t& neighborLocalEdgeIndex);
 
 
 
  protected:
    void calculateMassProperties(bool showWarnings);
 
    void finalizeMeshTopology(bool showWarnings, uint32_t optionsMask);
 
    Trimesh(Type type, agx::Physics::Geometry::ShapePtr entity, const agx::Vec3Vector* vertices, const agx::UInt32Vector* indices,
      const char* sourceName, uint32_t optionsMask = 0);
 
    Trimesh(Type type, agx::Physics::Geometry::ShapePtr entity);
 
    // Sets the values in a shallow-copy way.
    void setValuesAsShallowCopy(const Trimesh* other);
 
    virtual ~Trimesh();
 
    virtual void updateBvhTree() override;
 
 
  protected:
    agx::String m_sourceName;
    agx::String m_warnings;
    uint32_t m_optionsMask;
    agx::ref_ptr<const Trimesh> m_shallowCopySource;
 
  };
 
 
  // Implementations
 
  inline void Trimesh::calculatePossibleTriangleOverlapsAlongLineSegment(
    const agx::Vec3& segmentStartLocal,
    const agx::Vec3& segmentEndLocal,
    agx::UInt32Vector& triangleIndices) const
  {
    this->getBvhTree()->findCollisionWithLineSegment(segmentStartLocal, segmentEndLocal, triangleIndices);
  }
 
 
 
  inline void Trimesh::calculatePossibleTriangleOverlapsAlongLineSegment(
    const agx::Vec3& segmentStartLocal,
    const agx::Vec3& segmentEndLocal,
    agxData::LocalVector<agx::UInt32>& triangleIndices) const
  {
    this->getBvhTree()->findCollisionWithLineSegment(segmentStartLocal, segmentEndLocal, triangleIndices);
  }
 
}
 
#endif