Deformable1DAttachment.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.
*/
 
#ifndef AGXMODEL_DEFORMABLE1DATTACHMENT_H
#define AGXMODEL_DEFORMABLE1DATTACHMENT_H
 
#include <agxModel/export.h>
 
#include <agx/LockJoint.h>
#include <agx/BallJoint.h>
#include <agx/Hinge.h>
#include <agx/Prismatic.h>
 
namespace agxModel
{
  class Deformable1DNode;
 
  AGX_DECLARE_POINTER_TYPES( NodeAttachment );
 
  class AGXMODEL_EXPORT NodeAttachment : public agx::Referenced, public agxStream::Serializable
  {
    public:
      enum InitializationMode
      {
        USE_RELATIVE_TRANSFORM,
        ROTATE_TO_NODE_DIRECTION
      };
 
    public:
      template< typename T >
      static agxModel::NodeAttachmentRef createFromWorld( agx::Vec3 worldPoint, agx::RigidBody* rb );
 
      template< typename T >
      static agxModel::NodeAttachmentRef createFromBody( agx::Vec3 bodyPoint, agx::RigidBody* rb );
 
      template< typename T >
      static agxModel::NodeAttachmentRef createFromWorld( agx::AffineMatrix4x4 worldTransform, agx::RigidBody* rb );
 
      template< typename T >
      static agxModel::NodeAttachmentRef createFromBody( agx::AffineMatrix4x4 bodyTransform, agx::RigidBody* rb );
 
    public:
      void setName( const agx::String& name );
 
      const agx::String& getName() const;
 
      agx::Frame* getFrame() const;
 
      agx::Constraint* getConstraint() const;
 
      agx::RigidBody* getRigidBody() const;
 
      agx::AffineMatrix4x4 getWorldMatrix() const;
 
      InitializationMode getInitMode() const;
 
 
    public:
      virtual agx::Bool initialize(agxModel::Deformable1DNode* node);
 
      AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( agxModel::NodeAttachment );
 
      virtual void storeLightData( agxStream::StorageStream& str ) const override;
 
      virtual void restoreLightData( agxStream::StorageStream& str ) override;
 
    protected:
      NodeAttachment( agx::RigidBody* rb, agx::Frame* rbAttachmentFrame, agxModel::NodeAttachment::InitializationMode initMode );
 
      void store( agxStream::OutputArchive& out ) const override;
 
      void restore( agxStream::InputArchive& in ) override;
 
    protected:
      virtual ~NodeAttachment();
 
      virtual agx::ConstraintRef createConstraint( agx::RigidBodyRef rb1, agx::FrameRef f1, agx::RigidBodyRef rb2, agx::FrameRef f2 ) const = 0;
 
    protected:
      agx::String        m_name;
      agx::RigidBodyRef  m_rb;
      agx::FrameRef      m_rbAttachmentFrame;
      agx::ConstraintRef m_constraint;
      InitializationMode m_initMode;
  };
 
  template< typename T >
  class NodeAttachmentT : public agxModel::NodeAttachment
  {
    public:
      NodeAttachmentT( agx::RigidBody* rb, agx::Frame* rbAttachmentFrame, agxModel::NodeAttachment::InitializationMode initMode ) : NodeAttachment( rb, rbAttachmentFrame, initMode ) {}
 
    protected:
      NodeAttachmentT() : NodeAttachment( nullptr, nullptr, agxModel::NodeAttachment::ROTATE_TO_NODE_DIRECTION ) {}
 
      virtual ~NodeAttachmentT() {}
 
      virtual agx::ConstraintRef createConstraint( agx::RigidBodyRef rb1, agx::FrameRef f1, agx::RigidBodyRef rb2, agx::FrameRef f2 ) const override
      {
        return new T( rb1, f1, rb2, f2 );
      }
  };
 
#ifdef SWIG
  %template(NodeAttachmentTBallJoint) agxModel::NodeAttachmentT<agx::BallJoint>;
  %template(NodeAttachmentTLockJoint) agxModel::NodeAttachmentT<agx::LockJoint>;
  %template(NodeAttachmentTHinge)     agxModel::NodeAttachmentT<agx::Hinge>;
  %template(NodeAttachmentTPrismatic) agxModel::NodeAttachmentT<agx::Prismatic>;
#endif
 
  class AGXMODEL_EXPORT PointNodeAttachment : public agxModel::NodeAttachmentT< agx::BallJoint >
  {
    public:
      PointNodeAttachment( agx::RigidBody* rb, const agx::Vec3& relPosition );
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxModel::PointNodeAttachment );
 
    protected:
      PointNodeAttachment();
 
      virtual ~PointNodeAttachment();
  };
 
  class AGXMODEL_EXPORT RigidNodeAttachment : public agxModel::NodeAttachmentT< agx::LockJoint >
  {
    public:
      RigidNodeAttachment( agx::RigidBody* rb, const agx::Vec3& relPosition );
 
      RigidNodeAttachment( agx::RigidBody* rb, const agx::AffineMatrix4x4& relTransform );
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxModel::RigidNodeAttachment );
 
    protected:
      RigidNodeAttachment();
 
      virtual ~RigidNodeAttachment();
  };
 
  class AGXMODEL_EXPORT RotatingNodeAttachment : public agxModel::NodeAttachmentT< agx::Hinge >
  {
    public:
      RotatingNodeAttachment( agx::RigidBody* rb, const agx::Vec3& relPosition );
 
      RotatingNodeAttachment( agx::RigidBody* rb, const agx::AffineMatrix4x4& relTransform );
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxModel::RotatingNodeAttachment );
 
    protected:
      RotatingNodeAttachment();
 
      virtual ~RotatingNodeAttachment();
  };
 
  class AGXMODEL_EXPORT SlidingNodeAttachment : public agxModel::NodeAttachmentT< agx::Prismatic >
  {
    public:
      SlidingNodeAttachment( agx::RigidBody* rb, const agx::Vec3& relPosition );
 
      SlidingNodeAttachment( agx::RigidBody* rb, const agx::AffineMatrix4x4& relTransform );
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxModel::SlidingNodeAttachment );
 
    protected:
      SlidingNodeAttachment();
 
      virtual ~SlidingNodeAttachment();
  };
 
  template< typename T >
  agxModel::NodeAttachmentRef NodeAttachment::createFromWorld( agx::Vec3 worldPoint, agx::RigidBody* rb )
  {
    return createFromBody< T >( (rb != nullptr ? rb->getFrame()->transformPointToLocal( worldPoint ) : worldPoint), rb );
  }
 
  template< typename T >
  agxModel::NodeAttachmentRef NodeAttachment::createFromBody( agx::Vec3 bodyPoint, agx::RigidBody* rb )
  {
    return new T( rb, bodyPoint );
  }
 
  template< typename T >
  agxModel::NodeAttachmentRef NodeAttachment::createFromWorld( agx::AffineMatrix4x4 worldTransform, agx::RigidBody* rb )
  {
    return createFromBody< T >( (rb != nullptr ? worldTransform * rb->getTransform().inverse() : worldTransform), rb );
  }
 
  template< typename T >
  agxModel::NodeAttachmentRef NodeAttachment::createFromBody( agx::AffineMatrix4x4 bodyTransform, agx::RigidBody* rb )
  {
    return new T( rb, bodyTransform );
  }
}
 
#endif // AGXMODEL_DEFORMABLE1DATTACHMENT_H