ObserverFrame.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 <agx/RigidBody.h>
#include <agx/Frame.h>
 
#ifdef _MSC_VER
#  pragma warning(push)
#  pragma warning(disable:4355) //Disable 'this' : used in base member initializer list warning
#endif
 
namespace agx
{
  class DynamicsSystem;
 
  AGX_DECLARE_POINTER_TYPES( ObserverFrame );
  AGX_DECLARE_VECTOR_TYPES( ObserverFrame );
  typedef agx::SetVector<ObserverFrameRef> ObserverFrameRefSetVector;
 
 
  class CALLABLE AGXPHYSICS_EXPORT ObserverFrame : public agx::Referenced, public virtual agxStream::Serializable
  {
    public:
 
 
    public:
      ObserverFrame( const agx::Name& name = "", agx::RigidBody* body = nullptr, const agx::AffineMatrix4x4& transform = agx::AffineMatrix4x4());
      ObserverFrame(agx::RigidBody* body , const agx::AffineMatrix4x4& transform = agx::AffineMatrix4x4());
 
      agx::Frame* getFrame();
 
      const agx::Frame* getFrame() const;
 
      void setTransform( const agx::AffineMatrix4x4& matrix );
 
      const agx::AffineMatrix4x4& getLocalTransform() const;
 
      void setLocalTransform( const agx::AffineMatrix4x4& matrix );
 
      agx::Vec3 getLocalPosition() const;
 
      void setLocalPosition( const agx::Vec3& p );
 
      void setLocalPosition( agx::Real x, agx::Real y, agx::Real z );
 
      void setRotation( const agx::Quat& q );
 
      void setRotation( const agx::EulerAngles& e);
 
      void setRotation( const agx::OrthoMatrix3x3& m );
 
      agx::Quat getLocalRotation() const;
 
      void setLocalRotation( const agx::Quat& q );
 
      void setLocalRotation( const agx::EulerAngles& e );
 
      agx::Frame* getParentFrame();
 
      const agx::Frame* getParentFrame() const;
 
      bool setParentFrame( agx::Frame* frame );
 
      void setPosition( const agx::Vec3& p );
 
      void setPosition( agx::Real x, agx::Real y, agx::Real z );
 
      void setEnable( bool enable );
 
      bool getEnable() const;
 
      bool isEnabled() const;
 
      agx::DynamicsSystem* getSystem();
 
      const agx::DynamicsSystem* getSystem() const;
 
 
      agx::Vec3 getPosition() const;
 
      agx::Quat getRotation() const;
 
      agx::Vec3 transformVectorToWorld(const agx::Vec3& vectorLocal) const;
 
      agx::Vec3 transformVectorToLocal(const agx::Vec3& vectorWorld) const;
 
      agx::Vec3 transformPointToWorld(const agx::Vec3& pointLocal) const;
 
      agx::Vec3 transformPointToLocal(const agx::Vec3& pointWorld) const;
 
      agx::Vec3 getVelocity() const;
 
      agx::Vec3 getAngularVelocity() const;
 
      agx::Vec3 getAcceleration() const;
 
      agx::Vec3 getAngularAcceleration() const;
 
      agx::Vec3 getRelativeVelocity(const agx::RigidBody* body) const;
 
      agx::Vec3 getRelativeAngularVelocity(const agx::RigidBody* body) const;
 
      agx::Vec3 getRelativeAcceleration(const agx::RigidBody* body) const;
 
      agx::Vec3 getRelativeAngularAcceleration(const agx::RigidBody* body) const;
 
      agx::Vec3 getRelativeVelocity(const agx::ObserverFrame* obs) const;
 
      agx::Vec3 getRelativeAngularVelocity(const agx::ObserverFrame* obs) const;
 
      agx::Vec3 getRelativeAcceleration(const agx::ObserverFrame* obs) const;
 
      agx::Vec3 getRelativeAngularAcceleration(const agx::ObserverFrame* obs) const;
 
      agx::Vec3 getRelativePosition(const agx::ObserverFrame* obs) const;
 
      agx::Vec3 getRelativePosition(const agx::RigidBody* body) const;
 
      agx::Quat getRelativeRotation(const agx::ObserverFrame* obs) const;
 
      agx::Quat getRelativeRotation(const agx::RigidBody* body) const;
      
      void attach(agx::RigidBody* body, const agx::AffineMatrix4x4& transform = agx::AffineMatrix4x4());
 
      void attachWithWorldTransform(agx::RigidBody* body, const agx::AffineMatrix4x4& transform = agx::AffineMatrix4x4());
 
      void detach();
 
      agx::RigidBody* getAttachment() const;
 
      agx::Name getName() const;
 
      const agx::RigidBody* getRigidBody() const;
 
      agx::RigidBody* getRigidBody();
 
      void setName( const agx::Name& name );
 
      bool setCmAndInertiaInObserver(agx::RigidBody* body, const agx::SPDMatrix3x3& inertia);
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agx::ObserverFrame );
 
    protected:
      friend class DynamicsSystem;
 
      virtual ~ObserverFrame();
 
      void setSystem( agx::DynamicsSystem* system );
 
    private:
      void init(const agx::Name& name, agx::RigidBody* body, const agx::AffineMatrix4x4& transform = agx::AffineMatrix4x4() );
 
    private:
      DynamicsSystem* m_mainSystem;
 
      FrameRef m_frame;
      bool m_enabled;
      agx::Name m_name;
      agx::RigidBodyRef m_rigidBody;
  };
 
  AGX_FORCE_INLINE bool ObserverFrame::getEnable() const
  {
    return m_enabled;
  }
 
  AGX_FORCE_INLINE bool ObserverFrame::isEnabled() const
  {
    return m_enabled;
  }
 
  AGX_FORCE_INLINE Frame* ObserverFrame::getFrame()
  {
    return m_frame.get();
  }
 
  AGX_FORCE_INLINE const Frame* ObserverFrame::getFrame() const
  {
    return m_frame.get();
  }
 
  inline const agx::RigidBody* ObserverFrame::getRigidBody() const
  {
    return m_rigidBody.get();
  }
 
  inline  agx::RigidBody* ObserverFrame::getRigidBody()
  {
    return m_rigidBody.get();
  }
 
} // namespace agx
 
#ifdef _MSC_VER
# pragma warning(pop)
#endif