Geometry.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 <agxCollide/agxCollide.h>
#include <agx/agx.h>
#include <agx/observer_ptr.h>
#include <agxCollide/BoundingAABB.h>
#include <agxCollide/Shape.h>
#include <agx/Physics/GeometryEntity.h>
#include <agx/Material.h>
#include <agx/Event.h>
 
#include <agxStream/Serializable.h>
 
#include <agx/Property.h>
 
#include <agxCollide/agxcollide_vector_types.h>
#include <agx/RigidBody.h>
#include <agx/HashSet.h>
#include <agx/AffineMatrix4x4.h>
#include <agx/BitArray.h>
#include <agx/SymmetricPair.h>
#include <agxCollide/CollisionGroupManager.h>
#include <agxCollide/GeometryState.h>
#include <agxCollide/GroupIdCollection.h>
#include <agx/SetVector.h>
 
 
namespace agx
{
  class Frame;
  class InternalData;
  class Emitter;
}
 
namespace agxCollide
{
  class SweepAndPrune;
  class LocalContactPoint;
 
}
 
namespace agxTerrain
{
  class Terrain;
}
 
namespace agxData
{
  typedef agx::SymmetricPair<agx::Physics::GeometryPtr> GeometryPair;
}
 
AGX_TYPE_BINDING(agxData::GeometryPair, "GeometryPair")
 
 
namespace agxCollide
{
  class Space;
  class ContactPoint;
 
 
  AGX_DECLARE_POINTER_TYPES( Geometry );
  AGX_DECLARE_VECTOR_TYPES( Geometry );
  typedef agx::HashVector<const Geometry *,  agx::observer_ptr<const Geometry> > GeometryHashVector;
  typedef agx::HashSet<const Geometry * > GeometryHashSet;
  typedef agx::SetVector< agx::ref_ptr<agxCollide::Geometry> > GeometryRefSetVector;
 
  class AGXPHYSICS_EXPORT Geometry : public agx::Referenced, public virtual agxStream::Serializable
  {
    public:
      typedef agx::Event1<Geometry *> ShapeChangeEvent;
      ShapeChangeEvent shapeChangeEvent;
 
    public:
 
      Geometry( const agx::Name& name = "" );
 
 
      Geometry( Shape* shape );
 
      Geometry( Shape* shape, const agx::AffineMatrix4x4& localShapeTransform );
 
      Geometry *clone( bool shallowCopyRenderData=false ) const;
 
      agx::Int64 getId() const;
 
      const agx::Name& getName() const;
 
      void setName( const agx::Name& name );
 
      agx::RigidBody *getRigidBody();
 
      const agx::RigidBody *getRigidBody() const;
 
      void setMaterial( agx::Material *material );
 
      agx::Material *getMaterial();
 
      const agx::Material *getMaterial() const;
 
      void removeMaterial();
 
      agx::Real calculateMass() const;
 
      agx::Real calculateVolume() const;
 
      agx::Vec3 calculateCenterOfMassOffset() const;
 
      agx::SPDMatrix3x3 calculateInertia( agx::Real mass ) const;
 
      void setEnable( bool flag );
 
      bool isEnabled() const;
 
      bool getEnable() const;
 
      void setSensor(bool flag, bool generateContactData = true);
 
      bool isSensor() const;
 
      bool isSensorGeneratingContactData() const;
 
      void setEnableMassProperties(bool enableMassProperties);
      
      bool getEnableMassProperties() const;
 
      void addGroup( agx::UInt32 id, bool forceContactUpdate = false );
 
      void addGroup( const agx::Name& name, bool forceContactUpdate = false);
 
      void removeGroup( agx::UInt32 id, bool forceContactUpdate = false );
 
      void removeGroup( const agx::Name& name, bool forceContactUpdate = false);
 
      void removeAllGroups(bool forceContactUpdate = false);
 
      bool hasGroup( agx::UInt32 id ) const;
 
      bool hasGroup( const agx::Name& name ) const;
 
      void setGroupSet( agx::Physics::CollisionGroupSetPtr set );
 
      const agx::Physics::CollisionGroupSetPtr& getGroupSet() const;
 
      typedef CollisionGroupManager::GroupIdHash GroupSet;
      const GroupSet& getGroupIDs() const;
 
      void setEnableCollisions( const Geometry* otherGeometry, bool flag );
 
      bool getEnableCollisions( const Geometry* otherGeometry ) const;
 
      void setEnableCollisions(bool collide);
 
      bool getEnableCollisions() const;
 
 
      bool canCollide( const Geometry *otherGeometry ) const;
 
 
      virtual agx::Vec3f calculateSurfaceVelocity( const agxCollide::LocalContactPoint& point, size_t index ) const;
 
      virtual const BoundingAABB* getBoundingVolume() const;
 
      agx::PropertyContainer* getPropertyContainer();
 
      const agx::PropertyContainer* getPropertyContainer() const;
 
      bool hasPropertyContainer() const;
 
      void setPropertyContainer( agx::PropertyContainer *container );
 
      Space* getSpace();
 
      const Space* getSpace() const;
 
 
      AGXSTREAM_DECLARE_SERIALIZABLE( agxCollide::Geometry );
 
 
      agx::Referenced* getCustomData();
 
      const agx::Referenced* getCustomData() const;
 
      void setCustomData( agx::Referenced* data );
 
      void setSurfaceVelocity( const agx::Vec3f& surfaceVelocity );
 
      const agx::Vec3f& getSurfaceVelocity() const;
 
      agx::UInt32 getSweepAndPruneIndex() const;
 
      // Normally updated automatically
      virtual void updateBoundingVolume();
 
      agx::Physics::GeometryPtr getEntity() const;
 
      // Normally handled automatically
      virtual void shapeUpdated();
 
      agxCollide::GroupIdCollection findGroupIdCollection() const;
 
    public:
      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 );
 
      agx::AffineMatrix4x4 getTransform() const;
 
      agx::Vec3 getPosition() const;
 
      agx::Quat getRotation() const;
 
 
    public:
      /* Old interface, use ShapeGroup instead */
 
      bool add( Shape *shape, const agx::AffineMatrix4x4& localTransform = agx::AffineMatrix4x4() );
 
      bool remove( Shape *shape );
 
      DOXYGEN_START_INTERNAL_BLOCK()
      Shape *getShape();
 
      const Shape *getShape() const;
 
      bool setShape(Shape *shape);
      DOXYGEN_END_INTERNAL_BLOCK()
 
 
      bool remove( size_t index );
 
      const ShapeRefVector& getShapes() const;
 
      bool replace( size_t shapeIndex, Shape *newShape, const agx::AffineMatrix4x4& localTransform = agx::AffineMatrix4x4());
      bool replace( Shape *oldShape, Shape *newShape, const agx::AffineMatrix4x4& localTransform = agx::AffineMatrix4x4());
 
      bool replaceShapeTransform( size_t shapeIndex, const agx::AffineMatrix4x4& newTransform );
 
      bool replaceShapeTransform( Shape *shape, const agx::AffineMatrix4x4& newTransform );
 
      void cloneShapeRenderData(agxCollide::Shape* target, bool shallowCopy) const;
 
    public:
 
    protected:
      virtual ~Geometry();
 
    private:
      friend class agx::Emitter;
      friend class agx::RigidBody;
      friend class agx::Frame;
      friend class GeometryGroup;
      friend class agxCollide::Space;
      friend class agxCollide::SweepAndPrune;
      friend class agxCollide::ShapeGroup;
      friend class agxTerrain::Terrain;
 
      void propagateTransform();
      void updateFrameStorage();
      ShapeGroup *createWrapperGroup();
 
      void init(const agx::Name& name);
 
      mutable agx::PropertyContainerRef m_propertyContainer;
 
      void setBody( agx::RigidBody *body, const agx::AffineMatrix4x4& invBodyTransform );
      void removeBody();
 
      bool setSpace( Space* space, agx::Int64 id );
 
      void setSweepAndPruneIndex( agx::UInt32 index );
      void setEntity( agx::Physics::GeometryPtr entity );
      // void transfer(Space *space);
      void transfer( agxData::EntityStorage *storage );
 
      size_t findShapeIndex(Shape *shape);
 
      void enableCollisionsWithGroup(agx::UInt32 groupId);
      void disableCollisionsWithGroup(agx::UInt32 groupId);
 
      DOXYGEN_START_INTERNAL_BLOCK()
      friend class agx::InternalData;
      agx::Referenced* getInternalData() const;
 
      void setInternalData( agx::Referenced* data );
      DOXYGEN_END_INTERNAL_BLOCK()
 
    private:
      agx::Int64                m_id;
      ShapeRef                  m_shape;
      agx::Physics::GeometryRef m_entity;
      agx::RigidBody *          m_rigidBody;
      Space *                   m_space;
 
      agx::MaterialRef m_material;
 
      mutable GeometryHashVector m_disabledCollisionsHash;
 
      agx::FrameRef                     m_frame;
      agx::ref_ptr<agx::Referenced>     m_customData;
      agx::ref_ptr<agx::Referenced>     m_internalData;
      agx::observer_ptr<agx::RigidBody> m_originalBody;
 
      // Backward compatibility
      ShapeRefVector                m_singleShapeVector;
 
      static ShapeRefVector s_defaultChildVector;
      static GroupSet s_emptySet;
  };
 
 
  /* Implementation */
 
  AGX_FORCE_INLINE Shape *Geometry::getShape()
  {
    return m_shape;
  }
 
  AGX_FORCE_INLINE const Shape *Geometry::getShape() const
  {
    return const_cast<Geometry *>( this )->getShape();
  }
 
  inline agx::Physics::GeometryPtr Geometry::getEntity() const
  {
    return m_entity;
  }
  AGX_FORCE_INLINE agx::RigidBody *Geometry::getRigidBody()
  {
    return m_rigidBody;
  }
 
  AGX_FORCE_INLINE const agx::RigidBody *Geometry::getRigidBody() const
  {
    return m_rigidBody;
  }
 
  AGX_FORCE_INLINE agx::Int64 Geometry::getId() const
  {
    return m_id;
  }
 
  AGX_FORCE_INLINE bool Geometry::isEnabled() const
  {
    return m_entity.state().enabled();
  }
 
  AGX_FORCE_INLINE bool Geometry::isSensor() const
  {
    return m_entity.state().sensor();
  }
 
  AGX_FORCE_INLINE bool Geometry::getEnableMassProperties() const
  {
    return m_entity.state().enableMassProperties();
  }
 
 
  inline bool Geometry::isSensorGeneratingContactData() const
  {
    return !m_entity.state().booleanSensor();
  }
 
  AGX_FORCE_INLINE agx::UInt32 Geometry::getSweepAndPruneIndex() const
  {
    return m_entity.sweepAndPruneIndex();
  }
 
  AGX_FORCE_INLINE bool Geometry::hasGroup( agx::UInt32 id ) const
  {
    return CollisionGroupManager::hasGroup(m_entity.collisionGroupSet(), id);
  }
 
  AGX_FORCE_INLINE bool Geometry::hasGroup( const agx::Name& name ) const
  {
    return CollisionGroupManager::hasGroup(m_entity.collisionGroupSet(), name);
  }
 
  AGX_FORCE_INLINE const agx::Physics::CollisionGroupSetPtr& Geometry::getGroupSet() const
  {
    return m_entity.collisionGroupSet();
  }
 
  AGX_FORCE_INLINE void Geometry::setGroupSet( agx::Physics::CollisionGroupSetPtr set )
  {
    m_entity.collisionGroupSet() = set;
  }
 
  AGX_FORCE_INLINE const agx::Material *Geometry::getMaterial() const
  {
    return m_material;
  }
 
  AGX_FORCE_INLINE agx::Material *Geometry::getMaterial()
  {
    return m_material;
  }
 
  AGX_FORCE_INLINE void Geometry::setSurfaceVelocity( const agx::Vec3f& surfaceVelocity )
  {
    m_entity.surfaceVelocity() = surfaceVelocity;
  }
 
  AGX_FORCE_INLINE const agx::Vec3f& Geometry::getSurfaceVelocity( ) const
  {
    return m_entity.surfaceVelocity();
  }
 
  AGX_FORCE_INLINE bool Geometry::getEnable() const
  {
    return m_entity.state().enabled();
  }
 
  AGX_FORCE_INLINE Space* Geometry::getSpace()
  {
    return m_space;
  }
  AGX_FORCE_INLINE const Space* Geometry::getSpace() const
  {
    return m_space;
  }
 
  AGX_FORCE_INLINE agx::Frame* Geometry::getFrame()
  {
    return m_frame.get();
  }
 
  AGX_FORCE_INLINE const agx::Frame* Geometry::getFrame() const
  {
    return m_frame.get();
  }
 
  AGX_FORCE_INLINE const BoundingAABB* Geometry::getBoundingVolume() const
  {
    return &m_entity.boundingAABB();
  }
 
 
  AGX_FORCE_INLINE agx::PropertyContainer* Geometry::getPropertyContainer()
  {
    if ( !m_propertyContainer )
      m_propertyContainer = new agx::PropertyContainer;
    return m_propertyContainer;
  }
 
  AGX_FORCE_INLINE bool Geometry::hasPropertyContainer() const
  {
    return ( m_propertyContainer.isValid() );
  }
 
  AGX_FORCE_INLINE const agx::PropertyContainer* Geometry::getPropertyContainer() const
  {
    if ( !m_propertyContainer )
      m_propertyContainer = new agx::PropertyContainer;
 
    return m_propertyContainer;
  }
 
  AGX_FORCE_INLINE agx::Vec3f Geometry::calculateSurfaceVelocity( const agxCollide::LocalContactPoint& /* point */, size_t /* index */) const
  {
    return getSurfaceVelocity();
  }
 
  AGX_FORCE_INLINE agx::AffineMatrix4x4 Geometry::getTransform() const
  {
    if (m_rigidBody)
      return m_entity.transform();
    else
      return m_frame->getMatrix();
 
  }
 
  AGX_FORCE_INLINE agx::Vec3 Geometry::getPosition() const
  {
    if (m_rigidBody)
      return m_entity.transform().getTranslate();
    else
      return m_frame->getTranslate();
  }
 
  AGX_FORCE_INLINE agx::Quat Geometry::getRotation() const
  {
    if (m_rigidBody)
      return m_entity.transform().getRotate();
    return m_frame->getRotate();
  }
 
  AGX_FORCE_INLINE void Geometry::updateFrameStorage()
  {
    m_frame->setMatrixPointers(agxData::AttributePtr<agx::AffineMatrix4x4>(getEntity(), agx::Physics::GeometryModel::localTransformAttribute), agxData::AttributePtr<agx::AffineMatrix4x4>(getEntity(), agx::Physics::GeometryModel::transformAttribute));
  }
 
  inline agx::Referenced* Geometry::getInternalData() const
  {
    return m_internalData;
  }
} // namespace agxCollide