agx/Frame.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 AGX_FRAME_H
#define AGX_FRAME_H
 
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning( disable: 4290) //: C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
#endif
 
#include <agx/observer_ptr.h>
#include <agx/Vec3.h>
#include <agx/AffineMatrix4x4.h>
#include <agx/OrthoMatrix3x3.h>
 
#include <agxStream/Serializable.h>
#include <agx/SetVector.h>
#include <agxData/EntityPtr.h>
#include <agxData/AttributePtr.h>
#include <agx/Physics/FrameEntity.h>
 
namespace agxSDK
{
  class Assembly;
}
 
namespace agxCollide
{
  class Geometry;
}
 
namespace agx
{
  class RigidBody;
  class EulerAngles;
  class OrthoMatrix3x3;
 
  AGX_DECLARE_POINTER_TYPES(Frame);
 
  class AGXPHYSICS_EXPORT Frame : public Referenced, public agxStream::Serializable
  {
    public:
      Frame();
 
      Frame( const agxData::AttributePtr< AffineMatrix4x4 >& localTransform, const agxData::AttributePtr< AffineMatrix4x4 >& globalTransform );
 
      explicit Frame( const agx::AffineMatrix4x4 matrix );
 
      Frame( const agx::Frame& frame );
 
      Frame& operator = ( const agx::Frame& frame );
 
    public:
      bool setParent( agx::Frame* frame );
 
      agx::Frame* getParent();
 
      const agx::Frame* getParent() const;
 
      bool hasParent() const;
 
      void setMatrix( const agx::AffineMatrix4x4& matrix );
 
      const agx::AffineMatrix4x4& getMatrix() const;
 
 
      bool isFinite() const;
 
      void setLocalMatrix( const agx::AffineMatrix4x4& matrix );
 
      const agx::AffineMatrix4x4& getLocalMatrix() const;
 
      agx::Vec3 getTranslate() const;
 
      void setTranslate( const agx::Vec3& translate );
 
      void setTranslate( agx::Real x, agx::Real y, agx::Real z );
 
      agx::Vec3 getLocalTranslate() const;
 
      void setLocalTranslate( const agx::Vec3& translate );
 
      void setLocalTranslate( agx::Real x, agx::Real y, agx::Real z );
 
      agx::Quat getRotate() const;
 
      void setRotate( const agx::Quat& rotation );
 
      void setRotate( const agx::OrthoMatrix3x3& rotation );
 
      void setRotate( const agx::EulerAngles& euler);
 
      Quat getLocalRotate() const;
 
      void setLocalRotate( const agx::Quat& rotation );
 
      void setLocalRotate( const agx::EulerAngles& rotation );
 
      agx::Vec3 transformVectorToWorld( const agx::Vec3& vectorLocal ) const;
 
      agx::Vec3 transformVectorToWorld( agx::Real vx, agx::Real vy, agx::Real vz ) const;
 
      agx::Vec3& transformVectorToWorld( const agx::Vec3& localVector, agx::Vec3& worldVector ) const;
 
      agx::Vec3 transformPointToWorld( const agx::Vec3& pointLocal ) const;
 
      agx::Vec3 transformPointToWorld( agx::Real px, agx::Real py, agx::Real pz ) const;
 
      agx::Vec3& transformPointToWorld( const agx::Vec3& localPoint, agx::Vec3& worldPoint ) const;
 
      agx::Vec3 transformVectorToLocal( const agx::Vec3& worldVector ) const;
 
      agx::Vec3 transformVectorToLocal( agx::Real vx, agx::Real vy, agx::Real vz ) const;
 
      agx::Vec3& transformVectorToLocal( const agx::Vec3& vectorWorld, agx::Vec3& vectorLocal ) const;
 
      agx::Vec3 transformPointToLocal( const agx::Vec3& pointWorld ) const;
 
      agx::Vec3 transformPointToLocal( agx::Real px, agx::Real py, agx::Real pz ) const;
 
      agx::Vec3& transformPointToLocal( const agx::Vec3& pointWorld, agx::Vec3& pointLocal ) const;
 
      void transferDataIntoLeaves( bool keepLocalVelocity = true, bool clearTransform=true );
 
      void setAllowTransferIntoChildren( bool allow );
 
      bool allowTransferDataIntoChildren() const;
 
      void transferChildren( agx::Frame* newParent );
 
      bool hasChildren() const;
 
      bool removeChild( agx::Frame* frame );
 
      void removeAllChildren();
 
      agx::RigidBody* getRigidBody();
 
      const agx::RigidBody* getRigidBody() const;
 
      void setMatrixPointers( const agxData::AttributePtr< agx::AffineMatrix4x4 >& localTransform, const agxData::AttributePtr< agx::AffineMatrix4x4 >& globalTransform );
 
      void setEntityData(agxData::AttributePtr< agx::AffineMatrix4x4 > localTransform, agxData::AttributePtr< agx::AffineMatrix4x4 > globalTransform);
 
      void updateLocalMatrix();
 
      void updateLocalMatrixSSE();
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::Frame );
 
    protected:
      virtual ~Frame();
 
    private:
      friend class RigidBody;
      friend class agxCollide::Geometry;
 
      void setRigidBody( agx::RigidBody* body );
 
      void setGeometry( agxCollide::Geometry* geometry );
 
      void propagateUpdate();
 
      void postTransformUpdate();
 
      bool addChild( agx::Frame* frame );
 
 
 
    private:
      typedef SetVector< Frame* > FramePtrVector;
 
    private:
      Physics::FrameRef                              m_entity;
      mutable agxData::AttributePtr<AffineMatrix4x4> m_globalTransform;
      agxData::AttributePtr<AffineMatrix4x4>         m_localTransform;
 
      agx::observer_ptr<agx::Referenced>             m_rigidBody;
      agx::observer_ptr<agx::Referenced>             m_geometry;
      bool                                           m_allowTransferDataIntoChildren;
      Frame*                                         m_parent;
      FramePtrVector                                 m_children;
  };
 
  AGX_FORCE_INLINE void Frame::setMatrix( const AffineMatrix4x4& matrix )
  {
    m_localTransform.get() = matrix;
    const Frame* parent = getParent();
    if (parent)
      m_localTransform.get().postMult(parent->getMatrix().inverse());
 
    this->postTransformUpdate();
  }
 
  AGX_FORCE_INLINE void Frame::updateLocalMatrix()
  {
    m_localTransform.get() = m_parent ? m_globalTransform.get() * m_parent->m_globalTransform.get().inverse() : m_globalTransform.get();
  }
 
 
  AGX_FORCE_INLINE Frame* Frame::getParent()
  {
    return m_parent;
  }
 
  AGX_FORCE_INLINE const Frame* Frame::getParent() const
  {
    return m_parent;
  }
 
  AGX_FORCE_INLINE bool Frame::hasParent() const
  {
    return m_parent != nullptr;
  }
 
  AGX_FORCE_INLINE const AffineMatrix4x4& Frame::getLocalMatrix() const
  {
    return m_localTransform.get();
  }
 
  AGX_FORCE_INLINE void Frame::setLocalMatrix( const AffineMatrix4x4& matrix )
  {
    m_localTransform.get() = matrix;
    this->postTransformUpdate();
  }
 
  AGX_FORCE_INLINE Vec3 Frame::getTranslate() const
  {
    return getMatrix().getTranslate();
  }
 
  AGX_FORCE_INLINE void Frame::setTranslate( const Vec3& translate )
  {
    if ( getParent() )
      m_localTransform.get().setTranslate ( translate * m_parent->getMatrix().inverse() );
    else
      m_localTransform.get().setTranslate( translate );
 
    this->postTransformUpdate();
  }
 
  AGX_FORCE_INLINE void Frame::setTranslate( Real x, Real y, Real z )
  {
    setTranslate( Vec3( x, y, z ) );
  }
 
  AGX_FORCE_INLINE Vec3 Frame::getLocalTranslate() const
  {
    return m_localTransform.get().getTranslate();
  }
 
  AGX_FORCE_INLINE void Frame::setLocalTranslate( const Vec3& translate )
  {
    m_localTransform.get().setTranslate( translate );
    this->postTransformUpdate();
  }
 
  AGX_FORCE_INLINE void Frame::setLocalTranslate( Real x, Real y, Real z )
  {
    setLocalTranslate( Vec3( x, y, z ) );
  }
 
  AGX_FORCE_INLINE Vec3 Frame::transformVectorToWorld( const Vec3& vectorLocal ) const
  {
    Vec3 vectorWorld;
    return transformVectorToWorld( vectorLocal, vectorWorld );
  }
 
  AGX_FORCE_INLINE Vec3 Frame::transformVectorToWorld( Real vx, Real vy, Real vz ) const
  {
    return transformVectorToWorld( Vec3( vx, vy, vz ) );
  }
 
  AGX_FORCE_INLINE Vec3& Frame::transformVectorToWorld( const Vec3& localVector, Vec3& worldVector ) const
  {
    const AffineMatrix4x4& m = getMatrix();
 
    m.transform3x3( localVector, worldVector );
    return worldVector;
  }
 
  AGX_FORCE_INLINE Vec3 Frame::transformPointToWorld( const Vec3& pointLocal ) const
  {
    Vec3 wP;
    return transformPointToWorld( pointLocal, wP);
  }
 
  AGX_FORCE_INLINE Vec3 Frame::transformPointToWorld( Real px, Real py, Real pz ) const
  {
    return transformPointToWorld( Vec3( px, py, pz ) );
  }
 
  AGX_FORCE_INLINE Vec3& Frame::transformPointToWorld( const Vec3& localPoint, Vec3& worldPoint ) const
  {
    const AffineMatrix4x4& m = getMatrix();
 
    worldPoint = m.preMult( localPoint );
    return worldPoint;
  }
 
  AGX_FORCE_INLINE Vec3 Frame::transformVectorToLocal( const Vec3& worldVector ) const
  {
    Vec3 localVector;
    return transformVectorToLocal( worldVector, localVector );
  }
 
  AGX_FORCE_INLINE Vec3 Frame::transformVectorToLocal( Real vx, Real vy, Real vz ) const
  {
    return transformVectorToLocal( Vec3( vx, vy, vz ) );
  }
 
  AGX_FORCE_INLINE Vec3& Frame::transformVectorToLocal( const Vec3& vectorWorld, Vec3& vectorLocal ) const
  {
    AffineMatrix4x4 m = getMatrix();
 
    m.setTranslate( 0, 0, 0 );
    vectorLocal = m.postMult( vectorWorld );
    return vectorLocal;
  }
 
  AGX_FORCE_INLINE Vec3 Frame::transformPointToLocal( const Vec3& pointWorld ) const
  {
    Vec3 pointLocal;
    return transformPointToLocal( pointWorld, pointLocal );
  }
 
  AGX_FORCE_INLINE Vec3 Frame::transformPointToLocal( Real px, Real py, Real pz ) const
  {
    return transformPointToLocal( Vec3( px, py, pz ) );
  }
 
  AGX_FORCE_INLINE Vec3& Frame::transformPointToLocal( const Vec3& pointWorld, Vec3& pointLocal ) const
  {
    AffineMatrix4x4 m = getMatrix().inverse();
 
    pointLocal = m.preMult( pointWorld );
    return pointLocal;
  }
 
  AGX_FORCE_INLINE bool Frame::allowTransferDataIntoChildren() const
  {
    return m_allowTransferDataIntoChildren;
  }
 
  AGX_FORCE_INLINE void Frame::setAllowTransferIntoChildren( bool allow )
  {
    m_allowTransferDataIntoChildren = allow;
  }
 
  AGX_FORCE_INLINE bool Frame::hasChildren() const
  {
    return !m_children.empty();
  }
 
 #define AGX_ADD_FRAME_TRANSFORM_INTERFACE()                                                               \
   AGX_FORCE_INLINE const agx::AffineMatrix4x4& getTransform() const { return getFrame()->getMatrix(); }   \
   AGX_FORCE_INLINE agx::Vec3                   getPosition() const { return getFrame()->getTranslate(); } \
   AGX_FORCE_INLINE agx::Quat                   getRotation() const { return getFrame()->getRotate(); }
 
} // namespace agx
 
#ifdef _MSC_VER
# pragma warning(pop)
#endif
 
#endif