TrimeshDeformer.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 <agx/agx.h>
#include <agxCollide/Trimesh.h>
#include <agxUtil/agxUtil.h>
 
namespace agxCollide {
  class Trimesh;
}
 
namespace agxUtil {
 
  class ParallelTrimeshDeformer;
 
  AGX_DECLARE_POINTER_TYPES(BodyLocalOffset);
  AGX_DECLARE_VECTOR_TYPES(BodyLocalOffset);
 
  class AGXPHYSICS_EXPORT BodyLocalOffset : public virtual agx::Referenced, public virtual agxStream::Serializable
  {
    public:
      BodyLocalOffset(const agx::RigidBody* relativeBody,
                      const agx::RigidBody* body,
                      agx::Real offsetReach,
                      agx::Real fullOffsetPercent,
                      agx::Vec3* relativePosition);
      agx::Vec3 getWorldOffsetVector() const;
      const agx::RigidBody* getBody() const;
      agx::Real getOffsetReach() const;
      void setFullOffsetPercent(agx::Real percent);
      agx::Real getFullOffsetPercent();
      agx::Real getFullOffsetReach() const;
      agx::Vec3 calculateRelativeTranslate() const;
      agx::Vec3 getOriginalRelativeTranslate() const;
 
      typedef agx::HashVector<size_t, agx::Vec3> IndexVec3HashVector;
 
      const IndexVec3HashVector& getAffectedVertices() const;
      void collectAffectedVertices(const agxData::LocalVector<agx::Vec3>& worldVertices);
 
      AGXSTREAM_DECLARE_SERIALIZABLE(agxUtil::BodyLocalOffset);
 
    protected:
      BodyLocalOffset();
      virtual ~BodyLocalOffset();
      const agx::RigidBody* m_relativeBody;
      const agx::RigidBody* m_body;
      agx::Real m_offsetReach;
      agx::Real m_fullOffsetPercent;
      agx::Vec3 m_relativeRelativeTranslate;
 
      IndexVec3HashVector m_affectedVertices;
  };
 
 
  AGX_DECLARE_POINTER_TYPES(TrimeshDeformer);
  class AGXPHYSICS_EXPORT TrimeshDeformer : public agxSDK::StepEventListener
  {
  public:
 
    TrimeshDeformer(agxCollide::Trimesh* trimesh,
      agxCollide::Geometry* trimeshGeometry);
 
    bool activateDualFrameInterapolation( agx::Frame* interpolationFrame1,
                                          agx::Frame* interpolationFrame2,
                                          agx::Vec3 localMeshDir);
 
    void activateLocalOffsetInterpolation();
 
    bool addLocalDeformation(const agx::RigidBody* relativeBody,
                             const agx::RigidBody* body,
                             agx::Real offsetReach,
                             agx::Real fullOffsetPercent,
                             agx::Vec3* relativePosition = nullptr);
 
    void update();
 
    void last(const agx::TimeStamp&) override;
 
    agxCollide::Geometry* getGeometry();
 
    agxCollide::Trimesh* getTrimesh();
 
    bool isValid() const;
 
    void setEnableUpdateCollisionGeometry(bool enable);
 
    bool getEnableUpdateCollisionGeometry() const;
 
    AGXSTREAM_DECLARE_SERIALIZABLE(agxUtil::TrimeshDeformer);
 
 
    void updateCollisionGeometry();
 
 
  protected:
    TrimeshDeformer();
    virtual ~TrimeshDeformer();
 
    friend class ParallelTrimeshDeformer;
    void setOwner(ParallelTrimeshDeformer* deformer);
 
    void removeNotification() override;
 
 
    void updateDualFrameInterpolation();
    void updateLocalOffset(const BodyLocalOffsetRef offset);
    agxCollide::TrimeshObserver m_trimesh;
    agxCollide::GeometryObserver m_trimeshGeometry;
    agx::FrameRef m_interpolationFrame1;
    agx::FrameRef m_interpolationFrame2;
    agx::Real m_fullInterpolationLength;
    agx::Vec3 m_localMeshNormal;
    bool m_enableUpdate;
    agx::AffineMatrix4x4 m_localFrame1VertexRotation;
#ifndef SWIG
    agx::Vector<agx::Vec3> m_originalVertices;
    agx::Vector<agx::Vec3> m_verticesRelative1;
    agx::Vector<agx::Vec3> m_verticesRelative2;
    BodyLocalOffsetRefVector m_localOffsets;
 
    agx::observer_ptr<ParallelTrimeshDeformer> m_owner;
#endif
 
  };
 
 
 
  AGX_DECLARE_POINTER_TYPES(ParallelTrimeshDeformer);
  class AGXPHYSICS_EXPORT ParallelTrimeshDeformer : public agxSDK::StepEventListener
  {
    public:
 
      ParallelTrimeshDeformer();
      void add(TrimeshDeformer* deformer);
      bool remove(TrimeshDeformer* deformer);
 
      void setParallel(bool flag);
      bool getParallel() const;
 
  protected:
 
    void last(const agx::TimeStamp& time);
 
    void addNotification();
    void removeNotification();
 
 
    typedef agx::SetVector<TrimeshDeformerRef> TrimeshDeformerSetVector;
    TrimeshDeformerSetVector m_deformers;
 
    virtual ~ParallelTrimeshDeformer();
 
    bool m_parallel;
  };
}