doc/html/RigidBodyEntity_8h_source.html

/*

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.

*/


// AUTOMATICALLY GENERATED ENTITY, DO NOT EDIT! //


#ifndef GENERATED_AGX_PHYSICS_RIGIDBODY_H_PLUGIN

#define GENERATED_AGX_PHYSICS_RIGIDBODY_H_PLUGIN


#define AGX_ENTITY_WRAPPER 1


#ifdef _MSC_VER

# pragma warning(push)

// warning C4505: 'agxData::VectorAttributeT<T>::print' : unreferenced local function has been removed

# pragma warning( disable : 4505 )

//  warning C4251:  'X' : class 'Y' needs to have dll-interface to be used by clients of class 'Z'

# pragma warning( disable : 4251 )

//  warning C4355: 'this' : used in base member initializer list

# pragma warning( disable : 4355 )

//  marked as __forceinline not inlined

# pragma warning( disable: 4714 )

#endif


#include <agxData/EntityModel.h>

#include <agxData/EntityStorage.h>

#include <agxData/EntityRef.h>

#include <agxData/EntityPtr.h>

#include <agxData/EntityInstance.h>

#include <agx/Integer.h>

#include <agx/Real.h>

#include <agx/macros.h>

#include <agx/ReferencedEntity.h>

#include <agx/Integer.h>

#include <agx/RigidBodyState.h>

#include <agx/Name.h>

#include <agx/Real.h>

#include <agx/Vec3.h>

#include <agx/SPDMatrix3x3.h>

#include <agx/Matrix3x3.h>

#include <agx/AffineMatrix4x4.h>

#include <agx/Physics/GeometryEntity.h>

#include <agx/Physics/GraphNodeEntity.h>

#include <agx/Range6.h>

namespace agx { class RigidBody; }


namespace agx { namespace Physics { class GeometryPtr; }}

namespace agx { namespace Physics { class GraphNodePtr; }}


namespace agx

{

  namespace Physics

  {


    class RigidBodyModel;

    class RigidBodyData;

    class RigidBodyPtr;

    class RigidBodyInstance;

    class RigidBodySemantics;


    AGX_DECLARE_POINTER_TYPES(RigidBodyModel);


    class AGXPHYSICS_EXPORT RigidBodyModel : public agx::ReferencedModel

    {

    public:

      typedef RigidBodyPtr PtrT;


      RigidBodyModel(const agx::String& name = "RigidBody");


      static RigidBodyModel* instance();


      static RigidBodyPtr createInstance();


      static agxData::EntityStorage* defaultStorage();


      virtual void shutdownCleanup() override;


      /* Attributes */

      static agxData::ScalarAttributeT< agx::UInt32 >* idAttribute;

      static agxData::ScalarAttributeT< agx::RigidBodyState >* stateAttribute;

      static agxData::ScalarAttributeT< agx::Name >* nameAttribute;

      static agxData::ScalarAttributeT< agx::Real >* massAttribute;

      static agxData::ScalarAttributeT< agx::Real >* invMassAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* effectiveMassAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* effectiveMassCoefficientsAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* effectiveMassTransformDiagonalAttribute;

      static agxData::ScalarAttributeT< agx::SPDMatrix3x3 >* inertiaAttribute;

      static agxData::ScalarAttributeT< agx::SPDMatrix3x3 >* effectiveInertiaAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* effectiveInertiaCoefficientsAttribute;

      static agxData::ScalarAttributeT< agx::Matrix3x3 >* worldMassMatrixAttribute;

      static agxData::ScalarAttributeT< agx::Matrix3x3 >* invWorldMassMatrixAttribute;

      static agxData::ScalarAttributeT< agx::Matrix3x3 >* effectiveWorldMassMatrixAttribute;

      static agxData::ScalarAttributeT< agx::Matrix3x3 >* effectiveInvWorldMassMatrixAttribute;

      static agxData::ScalarAttributeT< agx::Matrix3x3 >* worldInertiaAttribute;

      static agxData::ScalarAttributeT< agx::Matrix3x3 >* invWorldInertiaAttribute;

      static agxData::ScalarAttributeT< agx::Matrix3x3 >* effectiveWorldInertiaAttribute;

      static agxData::ScalarAttributeT< agx::Matrix3x3 >* effectiveInvWorldInertiaAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* forceAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* torqueAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* lastForceAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* lastTorqueAttribute;

      static agxData::ScalarAttributeT< agx::AffineMatrix4x4 >* modelTransformAttribute;

      static agxData::ScalarAttributeT< agx::AffineMatrix4x4 >* localModelTransformAttribute;

      static agxData::ScalarAttributeT< agx::AffineMatrix4x4 >* cmTransformAttribute;

      static agxData::ScalarAttributeT< agx::AffineMatrix4x4 >* localCmTransformAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* velocityAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* angularVelocityAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* linearAccelerationAttribute;

      static agxData::ScalarAttributeT< agx::Vec3 >* angularAccelerationAttribute;

      static agxData::ScalarAttributeT< agx::Vec3f >* linearVelocityDampingAttribute;

      static agxData::ScalarAttributeT< agx::Vec3f >* angularVelocityDampingAttribute;

      static agxData::ScalarAttributeT< agx::Vec3f >* linearVelocityZeroDampingAttribute;

      static agxData::ScalarAttributeT< agx::Vec3f >* angularVelocityZeroDampingAttribute;

      static agxData::ScalarAttributeT< agx::Physics::GeometryPtr >* geometryAttribute;

      static agxData::ScalarAttributeT< agx::Physics::GraphNodePtr >* graphNodeAttribute;

      static agxData::ScalarAttributeT< agx::Range6 >* velocityRangesAttribute;

      static agxData::PointerAttributeT< agx::RigidBody*>* modelAttribute;

      static agxData::ScalarAttributeT< agx::UInt32 >* solveIndexAttribute;

      static agxData::ScalarAttributeT< agx::UInt16 >* numConstraintsAttribute;


    protected:

      virtual ~RigidBodyModel();

      virtual agxData::EntityData* createData(agxData::EntityStorage* storage) override;

      virtual void configure(agx::TiXmlElement* eEntity) override;

      virtual void initAttributeAccessors() override;

      virtual void construct(agxData::EntityPtr instance) override;

      void construct(agx::Physics::RigidBodyPtr rigidBody);

    };


    DOXYGEN_START_INTERNAL_BLOCK()

    #ifndef AGX_PHYSICS_RIGIDBODY_DATA_SET_OVERRIDE

    #define AGX_PHYSICS_RIGIDBODY_DATA_SET

    class AGXPHYSICS_EXPORT RigidBodyData : public agx::ReferencedData

    {

    public:

      RigidBodyInstance operator[] (size_t index);


    public:

      agxData::Array< RigidBodyPtr >& instance;

      agxData::Array< agx::UInt32 > id;

      agxData::Array< agx::RigidBodyState > state;

      agxData::Array< agx::Name > name;

      agxData::Array< agx::Real > mass;

      agxData::Array< agx::Real > invMass;

      agxData::Array< agx::Vec3 > effectiveMass;

      agxData::Array< agx::Vec3 > effectiveMassCoefficients;

      agxData::Array< agx::Vec3 > effectiveMassTransformDiagonal;

      agxData::Array< agx::SPDMatrix3x3 > inertia;

      agxData::Array< agx::SPDMatrix3x3 > effectiveInertia;

      agxData::Array< agx::Vec3 > effectiveInertiaCoefficients;

      agxData::Array< agx::Matrix3x3 > worldMassMatrix;

      agxData::Array< agx::Matrix3x3 > invWorldMassMatrix;

      agxData::Array< agx::Matrix3x3 > effectiveWorldMassMatrix;

      agxData::Array< agx::Matrix3x3 > effectiveInvWorldMassMatrix;

      agxData::Array< agx::Matrix3x3 > worldInertia;

      agxData::Array< agx::Matrix3x3 > invWorldInertia;

      agxData::Array< agx::Matrix3x3 > effectiveWorldInertia;

      agxData::Array< agx::Matrix3x3 > effectiveInvWorldInertia;

      agxData::Array< agx::Vec3 > force;

      agxData::Array< agx::Vec3 > torque;

      agxData::Array< agx::Vec3 > lastForce;

      agxData::Array< agx::Vec3 > lastTorque;

      agxData::Array< agx::AffineMatrix4x4 > modelTransform;

      agxData::Array< agx::AffineMatrix4x4 > localModelTransform;

      agxData::Array< agx::AffineMatrix4x4 > cmTransform;

      agxData::Array< agx::AffineMatrix4x4 > localCmTransform;

      agxData::Array< agx::Vec3 > velocity;

      agxData::Array< agx::Vec3 > angularVelocity;

      agxData::Array< agx::Vec3 > linearAcceleration;

      agxData::Array< agx::Vec3 > angularAcceleration;

      agxData::Array< agx::Vec3f > linearVelocityDamping;

      agxData::Array< agx::Vec3f > angularVelocityDamping;

      agxData::Array< agx::Vec3f > linearVelocityZeroDamping;

      agxData::Array< agx::Vec3f > angularVelocityZeroDamping;

      agxData::Array< agx::Physics::GeometryPtr > geometry;

      agxData::Array< agx::Physics::GraphNodePtr > graphNode;

      agxData::Array< agx::Range6 > velocityRanges;

      agxData::Array< agx::RigidBody* > model;

      agxData::Array< agx::UInt32 > solveIndex;

      agxData::Array< agx::UInt16 > numConstraints;


    public:

      typedef agx::UInt32 idType;

      typedef agx::RigidBodyState stateType;

      typedef agx::Name nameType;

      typedef agx::Real massType;

      typedef agx::Real invMassType;

      typedef agx::Vec3 effectiveMassType;

      typedef agx::Vec3 effectiveMassCoefficientsType;

      typedef agx::Vec3 effectiveMassTransformDiagonalType;

      typedef agx::SPDMatrix3x3 inertiaType;

      typedef agx::SPDMatrix3x3 effectiveInertiaType;

      typedef agx::Vec3 effectiveInertiaCoefficientsType;

      typedef agx::Matrix3x3 worldMassMatrixType;

      typedef agx::Matrix3x3 invWorldMassMatrixType;

      typedef agx::Matrix3x3 effectiveWorldMassMatrixType;

      typedef agx::Matrix3x3 effectiveInvWorldMassMatrixType;

      typedef agx::Matrix3x3 worldInertiaType;

      typedef agx::Matrix3x3 invWorldInertiaType;

      typedef agx::Matrix3x3 effectiveWorldInertiaType;

      typedef agx::Matrix3x3 effectiveInvWorldInertiaType;

      typedef agx::Vec3 forceType;

      typedef agx::Vec3 torqueType;

      typedef agx::Vec3 lastForceType;

      typedef agx::Vec3 lastTorqueType;

      typedef agx::AffineMatrix4x4 modelTransformType;

      typedef agx::AffineMatrix4x4 localModelTransformType;

      typedef agx::AffineMatrix4x4 cmTransformType;

      typedef agx::AffineMatrix4x4 localCmTransformType;

      typedef agx::Vec3 velocityType;

      typedef agx::Vec3 angularVelocityType;

      typedef agx::Vec3 linearAccelerationType;

      typedef agx::Vec3 angularAccelerationType;

      typedef agx::Vec3f linearVelocityDampingType;

      typedef agx::Vec3f angularVelocityDampingType;

      typedef agx::Vec3f linearVelocityZeroDampingType;

      typedef agx::Vec3f angularVelocityZeroDampingType;

      typedef agx::Physics::GeometryPtr geometryType;

      typedef agx::Physics::GraphNodePtr graphNodeType;

      typedef agx::Range6 velocityRangesType;

      typedef agx::RigidBody* modelType;

      typedef agx::UInt32 solveIndexType;

      typedef agx::UInt16 numConstraintsType;


    public:

      RigidBodyData(agxData::EntityStorage* storage);

      RigidBodyData();


    protected:

      virtual ~RigidBodyData() {}

      virtual void setNumElements(agx::Index numElements) override;


    private:

      RigidBodyData& operator= (const RigidBodyData&) { return *this; }


    };

    #endif

    DOXYGEN_END_INTERNAL_BLOCK()


    DOXYGEN_START_INTERNAL_BLOCK()

    class AGXPHYSICS_EXPORT RigidBodySemantics : public agx::ReferencedSemantics

    {

    public:


      // Automatic getters

      agx::UInt32 const& getId() const;

      agx::RigidBodyState const& getState() const;

      agx::Name const& getName() const;

      agx::Real const& getMass() const;

      agx::Real const& getInvMass() const;

      agx::Vec3 const& getEffectiveMass() const;

      agx::Vec3 const& getEffectiveMassCoefficients() const;

      agx::Vec3 const& getEffectiveMassTransformDiagonal() const;

      agx::SPDMatrix3x3 const& getInertia() const;

      agx::SPDMatrix3x3 const& getEffectiveInertia() const;

      agx::Vec3 const& getEffectiveInertiaCoefficients() const;

      agx::Matrix3x3 const& getWorldMassMatrix() const;

      agx::Matrix3x3 const& getInvWorldMassMatrix() const;

      agx::Matrix3x3 const& getEffectiveWorldMassMatrix() const;

      agx::Matrix3x3 const& getEffectiveInvWorldMassMatrix() const;

      agx::Matrix3x3 const& getWorldInertia() const;

      agx::Matrix3x3 const& getInvWorldInertia() const;

      agx::Matrix3x3 const& getEffectiveWorldInertia() const;

      agx::Matrix3x3 const& getEffectiveInvWorldInertia() const;

      agx::Vec3 const& getForce() const;

      agx::Vec3 const& getTorque() const;

      agx::Vec3 const& getLastForce() const;

      agx::Vec3 const& getLastTorque() const;

      agx::AffineMatrix4x4 const& getModelTransform() const;

      agx::AffineMatrix4x4 const& getLocalModelTransform() const;

      agx::AffineMatrix4x4 const& getCmTransform() const;

      agx::AffineMatrix4x4 const& getLocalCmTransform() const;

      agx::Vec3 const& getVelocity() const;

      agx::Vec3 const& getAngularVelocity() const;

      agx::Vec3 const& getLinearAcceleration() const;

      agx::Vec3 const& getAngularAcceleration() const;

      agx::Vec3f const& getLinearVelocityDamping() const;

      agx::Vec3f const& getAngularVelocityDamping() const;

      agx::Vec3f const& getLinearVelocityZeroDamping() const;

      agx::Vec3f const& getAngularVelocityZeroDamping() const;

      agx::Physics::GeometryPtr const& getGeometry() const;

      agx::Physics::GraphNodePtr const& getGraphNode() const;

      agx::Range6 const& getVelocityRanges() const;

      agx::RigidBody* const& getModel() const;

      agx::UInt32 const& getSolveIndex() const;

      agx::UInt16 const& getNumConstraints() const;


      // Semantics defined by explicit kernels


      // Automatic setters

      void setId(agx::UInt32 const& value);

      void setState(agx::RigidBodyState const& value);

      void setName(agx::Name const& value);

      void setMass(agx::Real const& value);

      void setInvMass(agx::Real const& value);

      void setEffectiveMass(agx::Vec3 const& value);

      void setEffectiveMassCoefficients(agx::Vec3 const& value);

      void setEffectiveMassTransformDiagonal(agx::Vec3 const& value);

      void setInertia(agx::SPDMatrix3x3 const& value);

      void setEffectiveInertia(agx::SPDMatrix3x3 const& value);

      void setEffectiveInertiaCoefficients(agx::Vec3 const& value);

      void setWorldMassMatrix(agx::Matrix3x3 const& value);

      void setInvWorldMassMatrix(agx::Matrix3x3 const& value);

      void setEffectiveWorldMassMatrix(agx::Matrix3x3 const& value);

      void setEffectiveInvWorldMassMatrix(agx::Matrix3x3 const& value);

      void setWorldInertia(agx::Matrix3x3 const& value);

      void setInvWorldInertia(agx::Matrix3x3 const& value);

      void setEffectiveWorldInertia(agx::Matrix3x3 const& value);

      void setEffectiveInvWorldInertia(agx::Matrix3x3 const& value);

      void setForce(agx::Vec3 const& value);

      void setTorque(agx::Vec3 const& value);

      void setLastForce(agx::Vec3 const& value);

      void setLastTorque(agx::Vec3 const& value);

      void setModelTransform(agx::AffineMatrix4x4 const& value);

      void setLocalModelTransform(agx::AffineMatrix4x4 const& value);

      void setCmTransform(agx::AffineMatrix4x4 const& value);

      void setLocalCmTransform(agx::AffineMatrix4x4 const& value);

      void setVelocity(agx::Vec3 const& value);

      void setAngularVelocity(agx::Vec3 const& value);

      void setLinearAcceleration(agx::Vec3 const& value);

      void setAngularAcceleration(agx::Vec3 const& value);

      void setLinearVelocityDamping(agx::Vec3f const& value);

      void setAngularVelocityDamping(agx::Vec3f const& value);

      void setLinearVelocityZeroDamping(agx::Vec3f const& value);

      void setAngularVelocityZeroDamping(agx::Vec3f const& value);

      void setGeometry(agx::Physics::GeometryPtr const& value);

      void setGraphNode(agx::Physics::GraphNodePtr const& value);

      void setVelocityRanges(agx::Range6 const& value);

      void setModel(agx::RigidBody* const& value);

      void setSolveIndex(agx::UInt32 const& value);

      void setNumConstraints(agx::UInt16 const& value);


    protected:

      friend class RigidBodyPtr;

      friend class RigidBodyInstance;

      RigidBodySemantics();

    };

    DOXYGEN_END_INTERNAL_BLOCK()


    class CALLABLE RigidBodyPtr : public agx::ReferencedPtr

    {

    public:

      typedef RigidBodyModel ModelType;

      typedef RigidBodyData DataType;

      typedef RigidBodyInstance InstanceType;


    public:

      AGXPHYSICS_EXPORT RigidBodyPtr();

      AGXPHYSICS_EXPORT RigidBodyPtr(agxData::EntityStorage* storage, agx::Index id);

      AGXPHYSICS_EXPORT RigidBodyPtr(const agxData::EntityPtr& ptr);

      AGXPHYSICS_EXPORT RigidBodyPtr(const agxData::EntityInstance& instance);

      AGXPHYSICS_EXPORT RigidBodyPtr& operator= (const agxData::EntityPtr& ptr);

      AGXPHYSICS_EXPORT RigidBodyPtr& operator= (const agxData::EntityInstance& instance);

      AGXPHYSICS_EXPORT RigidBodyInstance instance();

      AGXPHYSICS_EXPORT const RigidBodyInstance instance() const;


      AGXPHYSICS_EXPORT RigidBodySemantics* operator->();

      AGXPHYSICS_EXPORT const RigidBodySemantics* operator->() const;


      RigidBodyData* getData();

      const RigidBodyData* getData() const;


      AGXPHYSICS_EXPORT agx::UInt32& id();

      AGXPHYSICS_EXPORT agx::UInt32 const& id() const;


      AGXPHYSICS_EXPORT agx::RigidBodyState& state();

      AGXPHYSICS_EXPORT agx::RigidBodyState const& state() const;


      AGXPHYSICS_EXPORT agx::Name& name();

      AGXPHYSICS_EXPORT agx::Name const& name() const;


      AGXPHYSICS_EXPORT agx::Real& mass();

      AGXPHYSICS_EXPORT agx::Real const& mass() const;


      AGXPHYSICS_EXPORT agx::Real& invMass();

      AGXPHYSICS_EXPORT agx::Real const& invMass() const;


      AGXPHYSICS_EXPORT agx::Vec3& effectiveMass();

      AGXPHYSICS_EXPORT agx::Vec3 const& effectiveMass() const;


      AGXPHYSICS_EXPORT agx::Vec3& effectiveMassCoefficients();

      AGXPHYSICS_EXPORT agx::Vec3 const& effectiveMassCoefficients() const;


      AGXPHYSICS_EXPORT agx::Vec3& effectiveMassTransformDiagonal();

      AGXPHYSICS_EXPORT agx::Vec3 const& effectiveMassTransformDiagonal() const;


      AGXPHYSICS_EXPORT agx::SPDMatrix3x3& inertia();

      AGXPHYSICS_EXPORT agx::SPDMatrix3x3 const& inertia() const;


      AGXPHYSICS_EXPORT agx::SPDMatrix3x3& effectiveInertia();

      AGXPHYSICS_EXPORT agx::SPDMatrix3x3 const& effectiveInertia() const;


      AGXPHYSICS_EXPORT agx::Vec3& effectiveInertiaCoefficients();

      AGXPHYSICS_EXPORT agx::Vec3 const& effectiveInertiaCoefficients() const;


      AGXPHYSICS_EXPORT agx::Matrix3x3& worldMassMatrix();

      AGXPHYSICS_EXPORT agx::Matrix3x3 const& worldMassMatrix() const;


      AGXPHYSICS_EXPORT agx::Matrix3x3& invWorldMassMatrix();

      AGXPHYSICS_EXPORT agx::Matrix3x3 const& invWorldMassMatrix() const;


      AGXPHYSICS_EXPORT agx::Matrix3x3& effectiveWorldMassMatrix();

      AGXPHYSICS_EXPORT agx::Matrix3x3 const& effectiveWorldMassMatrix() const;


      AGXPHYSICS_EXPORT agx::Matrix3x3& effectiveInvWorldMassMatrix();

      AGXPHYSICS_EXPORT agx::Matrix3x3 const& effectiveInvWorldMassMatrix() const;


      AGXPHYSICS_EXPORT agx::Matrix3x3& worldInertia();

      AGXPHYSICS_EXPORT agx::Matrix3x3 const& worldInertia() const;


      AGXPHYSICS_EXPORT agx::Matrix3x3& invWorldInertia();

      AGXPHYSICS_EXPORT agx::Matrix3x3 const& invWorldInertia() const;


      AGXPHYSICS_EXPORT agx::Matrix3x3& effectiveWorldInertia();

      AGXPHYSICS_EXPORT agx::Matrix3x3 const& effectiveWorldInertia() const;


      AGXPHYSICS_EXPORT agx::Matrix3x3& effectiveInvWorldInertia();

      AGXPHYSICS_EXPORT agx::Matrix3x3 const& effectiveInvWorldInertia() const;


      AGXPHYSICS_EXPORT agx::Vec3& force();

      AGXPHYSICS_EXPORT agx::Vec3 const& force() const;


      AGXPHYSICS_EXPORT agx::Vec3& torque();

      AGXPHYSICS_EXPORT agx::Vec3 const& torque() const;


      AGXPHYSICS_EXPORT agx::Vec3& lastForce();

      AGXPHYSICS_EXPORT agx::Vec3 const& lastForce() const;


      AGXPHYSICS_EXPORT agx::Vec3& lastTorque();

      AGXPHYSICS_EXPORT agx::Vec3 const& lastTorque() const;


      AGXPHYSICS_EXPORT agx::AffineMatrix4x4& modelTransform();

      AGXPHYSICS_EXPORT agx::AffineMatrix4x4 const& modelTransform() const;


      AGXPHYSICS_EXPORT agx::AffineMatrix4x4& localModelTransform();

      AGXPHYSICS_EXPORT agx::AffineMatrix4x4 const& localModelTransform() const;


      AGXPHYSICS_EXPORT agx::AffineMatrix4x4& cmTransform();

      AGXPHYSICS_EXPORT agx::AffineMatrix4x4 const& cmTransform() const;


      AGXPHYSICS_EXPORT agx::AffineMatrix4x4& localCmTransform();

      AGXPHYSICS_EXPORT agx::AffineMatrix4x4 const& localCmTransform() const;


      AGXPHYSICS_EXPORT agx::Vec3& velocity();

      AGXPHYSICS_EXPORT agx::Vec3 const& velocity() const;


      AGXPHYSICS_EXPORT agx::Vec3& angularVelocity();

      AGXPHYSICS_EXPORT agx::Vec3 const& angularVelocity() const;


      AGXPHYSICS_EXPORT agx::Vec3& linearAcceleration();

      AGXPHYSICS_EXPORT agx::Vec3 const& linearAcceleration() const;


      AGXPHYSICS_EXPORT agx::Vec3& angularAcceleration();

      AGXPHYSICS_EXPORT agx::Vec3 const& angularAcceleration() const;


      AGXPHYSICS_EXPORT agx::Vec3f& linearVelocityDamping();

      AGXPHYSICS_EXPORT agx::Vec3f const& linearVelocityDamping() const;


      AGXPHYSICS_EXPORT agx::Vec3f& angularVelocityDamping();

      AGXPHYSICS_EXPORT agx::Vec3f const& angularVelocityDamping() const;


      AGXPHYSICS_EXPORT agx::Vec3f& linearVelocityZeroDamping();

      AGXPHYSICS_EXPORT agx::Vec3f const& linearVelocityZeroDamping() const;


      AGXPHYSICS_EXPORT agx::Vec3f& angularVelocityZeroDamping();

      AGXPHYSICS_EXPORT agx::Vec3f const& angularVelocityZeroDamping() const;


      AGXPHYSICS_EXPORT agx::Physics::GeometryPtr& geometry();

      AGXPHYSICS_EXPORT agx::Physics::GeometryPtr const& geometry() const;


      AGXPHYSICS_EXPORT agx::Physics::GraphNodePtr& graphNode();

      AGXPHYSICS_EXPORT agx::Physics::GraphNodePtr const& graphNode() const;


      AGXPHYSICS_EXPORT agx::Range6& velocityRanges();

      AGXPHYSICS_EXPORT agx::Range6 const& velocityRanges() const;


      AGXPHYSICS_EXPORT agx::RigidBody*& model();

      AGXPHYSICS_EXPORT agx::RigidBody* const& model() const;


      AGXPHYSICS_EXPORT agx::UInt32& solveIndex();

      AGXPHYSICS_EXPORT agx::UInt32 const& solveIndex() const;


      AGXPHYSICS_EXPORT agx::UInt16& numConstraints();

      AGXPHYSICS_EXPORT agx::UInt16 const& numConstraints() const;


    };


    // Entity is Referenced

    typedef agxData::EntityRef< RigidBodyPtr > RigidBodyRef;


    DOXYGEN_START_INTERNAL_BLOCK()

    class AGXPHYSICS_EXPORT RigidBodyInstance : public agx::ReferencedInstance

    {

    public:

      RigidBodyInstance();

      RigidBodyInstance(RigidBodyData* data, agx::Index index);

      RigidBodyInstance(agxData::EntityStorage *storage, agx::Index index);

      RigidBodyInstance(const agxData::EntityInstance& other);

      RigidBodyInstance(const agxData::EntityPtr& ptr);


      RigidBodyData* getData();

      const RigidBodyData* getData() const;


    public:

      agx::UInt32& id();

      agx::UInt32 const& id() const;


      agx::RigidBodyState& state();

      agx::RigidBodyState const& state() const;


      agx::Name& name();

      agx::Name const& name() const;


      agx::Real& mass();

      agx::Real const& mass() const;


      agx::Real& invMass();

      agx::Real const& invMass() const;


      agx::Vec3& effectiveMass();

      agx::Vec3 const& effectiveMass() const;


      agx::Vec3& effectiveMassCoefficients();

      agx::Vec3 const& effectiveMassCoefficients() const;


      agx::Vec3& effectiveMassTransformDiagonal();

      agx::Vec3 const& effectiveMassTransformDiagonal() const;


      agx::SPDMatrix3x3& inertia();

      agx::SPDMatrix3x3 const& inertia() const;


      agx::SPDMatrix3x3& effectiveInertia();

      agx::SPDMatrix3x3 const& effectiveInertia() const;


      agx::Vec3& effectiveInertiaCoefficients();

      agx::Vec3 const& effectiveInertiaCoefficients() const;


      agx::Matrix3x3& worldMassMatrix();

      agx::Matrix3x3 const& worldMassMatrix() const;


      agx::Matrix3x3& invWorldMassMatrix();

      agx::Matrix3x3 const& invWorldMassMatrix() const;


      agx::Matrix3x3& effectiveWorldMassMatrix();

      agx::Matrix3x3 const& effectiveWorldMassMatrix() const;


      agx::Matrix3x3& effectiveInvWorldMassMatrix();

      agx::Matrix3x3 const& effectiveInvWorldMassMatrix() const;


      agx::Matrix3x3& worldInertia();

      agx::Matrix3x3 const& worldInertia() const;


      agx::Matrix3x3& invWorldInertia();

      agx::Matrix3x3 const& invWorldInertia() const;


      agx::Matrix3x3& effectiveWorldInertia();

      agx::Matrix3x3 const& effectiveWorldInertia() const;


      agx::Matrix3x3& effectiveInvWorldInertia();

      agx::Matrix3x3 const& effectiveInvWorldInertia() const;


      agx::Vec3& force();

      agx::Vec3 const& force() const;


      agx::Vec3& torque();

      agx::Vec3 const& torque() const;


      agx::Vec3& lastForce();

      agx::Vec3 const& lastForce() const;


      agx::Vec3& lastTorque();

      agx::Vec3 const& lastTorque() const;


      agx::AffineMatrix4x4& modelTransform();

      agx::AffineMatrix4x4 const& modelTransform() const;


      agx::AffineMatrix4x4& localModelTransform();

      agx::AffineMatrix4x4 const& localModelTransform() const;


      agx::AffineMatrix4x4& cmTransform();

      agx::AffineMatrix4x4 const& cmTransform() const;


      agx::AffineMatrix4x4& localCmTransform();

      agx::AffineMatrix4x4 const& localCmTransform() const;


      agx::Vec3& velocity();

      agx::Vec3 const& velocity() const;


      agx::Vec3& angularVelocity();

      agx::Vec3 const& angularVelocity() const;


      agx::Vec3& linearAcceleration();

      agx::Vec3 const& linearAcceleration() const;


      agx::Vec3& angularAcceleration();

      agx::Vec3 const& angularAcceleration() const;


      agx::Vec3f& linearVelocityDamping();

      agx::Vec3f const& linearVelocityDamping() const;


      agx::Vec3f& angularVelocityDamping();

      agx::Vec3f const& angularVelocityDamping() const;


      agx::Vec3f& linearVelocityZeroDamping();

      agx::Vec3f const& linearVelocityZeroDamping() const;


      agx::Vec3f& angularVelocityZeroDamping();

      agx::Vec3f const& angularVelocityZeroDamping() const;


      agx::Physics::GeometryPtr& geometry();

      agx::Physics::GeometryPtr const& geometry() const;


      agx::Physics::GraphNodePtr& graphNode();

      agx::Physics::GraphNodePtr const& graphNode() const;


      agx::Range6& velocityRanges();

      agx::Range6 const& velocityRanges() const;


      agx::RigidBody*& model();

      agx::RigidBody* const& model() const;


      agx::UInt32& solveIndex();

      agx::UInt32 const& solveIndex() const;


      agx::UInt16& numConstraints();

      agx::UInt16 const& numConstraints() const;


    };

    DOXYGEN_END_INTERNAL_BLOCK()


    typedef agx::VectorPOD<RigidBodyPtr> RigidBodyPtrVector;

    typedef agxData::Array<RigidBodyPtr> RigidBodyPtrArray;


    DOXYGEN_START_INTERNAL_BLOCK()

    /* Implementation */

    //-----------------------------------------------------------------------------------------------------

    //-----------------------------------------------------------------------------------------------------

    inline RigidBodyInstance agx::Physics::RigidBodyData::operator[] (size_t index) { return RigidBodyInstance(this, (agx::Index)index); }

    //-----------------------------------------------------------------------------------------------------

    AGX_FORCE_INLINE RigidBodyPtr::RigidBodyPtr() {}

    AGX_FORCE_INLINE RigidBodyPtr::RigidBodyPtr(agxData::EntityStorage* storage, agx::Index id) : agx::ReferencedPtr(storage, id) {}

    AGX_FORCE_INLINE RigidBodyPtr::RigidBodyPtr(const agxData::EntityPtr& ptr) : agx::ReferencedPtr(ptr)

    {

      agxAssertN(!ptr || ptr.isInstanceOf(RigidBodyModel::instance()),

        "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",

        EntityPtr::getModel()->fullPath().c_str(), RigidBodyModel::instance()->fullPath().c_str());

    }


    AGX_FORCE_INLINE RigidBodyPtr::RigidBodyPtr(const agxData::EntityInstance& instance) : agx::ReferencedPtr(instance)

    {

      agxAssertN(!instance || instance.isInstanceOf(RigidBodyModel::instance()),

        "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",

        EntityPtr::getModel()->fullPath().c_str(), RigidBodyModel::instance()->fullPath().c_str());

    }


    AGX_FORCE_INLINE RigidBodyPtr& RigidBodyPtr::operator= (const agxData::EntityPtr& ptr)

    {

      agxData::EntityPtr::operator= (ptr);

      agxAssertN(!ptr || ptr.isInstanceOf(RigidBodyModel::instance()),

        "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",

        EntityPtr::getModel()->fullPath().c_str(), RigidBodyModel::instance()->fullPath().c_str());

      return *this;

    }


    AGX_FORCE_INLINE RigidBodyPtr& RigidBodyPtr::operator= (const agxData::EntityInstance& instance)

    {

      agxData::EntityPtr::operator= (instance);

      agxAssertN(!instance || instance.isInstanceOf(RigidBodyModel::instance()),

        "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",

        EntityPtr::getModel()->fullPath().c_str(), RigidBodyModel::instance()->fullPath().c_str());

      return *this;

    }


    inline RigidBodyInstance RigidBodyPtr::instance() { return agxData::EntityPtr::instance(); }

    inline const RigidBodyInstance RigidBodyPtr::instance() const { return agxData::EntityPtr::instance(); }

    AGX_FORCE_INLINE RigidBodySemantics* RigidBodyPtr::operator->() { return (RigidBodySemantics* )this; }

    AGX_FORCE_INLINE const RigidBodySemantics* RigidBodyPtr::operator->() const { return (const RigidBodySemantics* )this; }

    AGX_FORCE_INLINE RigidBodyData* RigidBodyPtr::getData() { return static_cast<RigidBodyData* >(agxData::EntityPtr::getData()); }

    AGX_FORCE_INLINE const RigidBodyData* RigidBodyPtr::getData() const { return static_cast<const RigidBodyData* >(agxData::EntityPtr::getData()); }


    AGX_FORCE_INLINE agx::UInt32& RigidBodyPtr::id() { verifyIndex(); return getData()->id[calculateIndex()]; }

    AGX_FORCE_INLINE agx::UInt32 const& RigidBodyPtr::id() const { verifyIndex(); return getData()->id[calculateIndex()]; }


    AGX_FORCE_INLINE agx::RigidBodyState& RigidBodyPtr::state() { verifyIndex(); return getData()->state[calculateIndex()]; }

    AGX_FORCE_INLINE agx::RigidBodyState const& RigidBodyPtr::state() const { verifyIndex(); return getData()->state[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Name& RigidBodyPtr::name() { verifyIndex(); return getData()->name[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Name const& RigidBodyPtr::name() const { verifyIndex(); return getData()->name[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Real& RigidBodyPtr::mass() { verifyIndex(); return getData()->mass[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Real const& RigidBodyPtr::mass() const { verifyIndex(); return getData()->mass[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Real& RigidBodyPtr::invMass() { verifyIndex(); return getData()->invMass[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Real const& RigidBodyPtr::invMass() const { verifyIndex(); return getData()->invMass[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::effectiveMass() { verifyIndex(); return getData()->effectiveMass[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::effectiveMass() const { verifyIndex(); return getData()->effectiveMass[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::effectiveMassCoefficients() { verifyIndex(); return getData()->effectiveMassCoefficients[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::effectiveMassCoefficients() const { verifyIndex(); return getData()->effectiveMassCoefficients[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::effectiveMassTransformDiagonal() { verifyIndex(); return getData()->effectiveMassTransformDiagonal[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::effectiveMassTransformDiagonal() const { verifyIndex(); return getData()->effectiveMassTransformDiagonal[calculateIndex()]; }


    AGX_FORCE_INLINE agx::SPDMatrix3x3& RigidBodyPtr::inertia() { verifyIndex(); return getData()->inertia[calculateIndex()]; }

    AGX_FORCE_INLINE agx::SPDMatrix3x3 const& RigidBodyPtr::inertia() const { verifyIndex(); return getData()->inertia[calculateIndex()]; }


    AGX_FORCE_INLINE agx::SPDMatrix3x3& RigidBodyPtr::effectiveInertia() { verifyIndex(); return getData()->effectiveInertia[calculateIndex()]; }

    AGX_FORCE_INLINE agx::SPDMatrix3x3 const& RigidBodyPtr::effectiveInertia() const { verifyIndex(); return getData()->effectiveInertia[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::effectiveInertiaCoefficients() { verifyIndex(); return getData()->effectiveInertiaCoefficients[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::effectiveInertiaCoefficients() const { verifyIndex(); return getData()->effectiveInertiaCoefficients[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyPtr::worldMassMatrix() { verifyIndex(); return getData()->worldMassMatrix[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyPtr::worldMassMatrix() const { verifyIndex(); return getData()->worldMassMatrix[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyPtr::invWorldMassMatrix() { verifyIndex(); return getData()->invWorldMassMatrix[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyPtr::invWorldMassMatrix() const { verifyIndex(); return getData()->invWorldMassMatrix[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyPtr::effectiveWorldMassMatrix() { verifyIndex(); return getData()->effectiveWorldMassMatrix[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyPtr::effectiveWorldMassMatrix() const { verifyIndex(); return getData()->effectiveWorldMassMatrix[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyPtr::effectiveInvWorldMassMatrix() { verifyIndex(); return getData()->effectiveInvWorldMassMatrix[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyPtr::effectiveInvWorldMassMatrix() const { verifyIndex(); return getData()->effectiveInvWorldMassMatrix[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyPtr::worldInertia() { verifyIndex(); return getData()->worldInertia[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyPtr::worldInertia() const { verifyIndex(); return getData()->worldInertia[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyPtr::invWorldInertia() { verifyIndex(); return getData()->invWorldInertia[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyPtr::invWorldInertia() const { verifyIndex(); return getData()->invWorldInertia[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyPtr::effectiveWorldInertia() { verifyIndex(); return getData()->effectiveWorldInertia[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyPtr::effectiveWorldInertia() const { verifyIndex(); return getData()->effectiveWorldInertia[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyPtr::effectiveInvWorldInertia() { verifyIndex(); return getData()->effectiveInvWorldInertia[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyPtr::effectiveInvWorldInertia() const { verifyIndex(); return getData()->effectiveInvWorldInertia[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::force() { verifyIndex(); return getData()->force[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::force() const { verifyIndex(); return getData()->force[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::torque() { verifyIndex(); return getData()->torque[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::torque() const { verifyIndex(); return getData()->torque[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::lastForce() { verifyIndex(); return getData()->lastForce[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::lastForce() const { verifyIndex(); return getData()->lastForce[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::lastTorque() { verifyIndex(); return getData()->lastTorque[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::lastTorque() const { verifyIndex(); return getData()->lastTorque[calculateIndex()]; }


    AGX_FORCE_INLINE agx::AffineMatrix4x4& RigidBodyPtr::modelTransform() { verifyIndex(); return getData()->modelTransform[calculateIndex()]; }

    AGX_FORCE_INLINE agx::AffineMatrix4x4 const& RigidBodyPtr::modelTransform() const { verifyIndex(); return getData()->modelTransform[calculateIndex()]; }


    AGX_FORCE_INLINE agx::AffineMatrix4x4& RigidBodyPtr::localModelTransform() { verifyIndex(); return getData()->localModelTransform[calculateIndex()]; }

    AGX_FORCE_INLINE agx::AffineMatrix4x4 const& RigidBodyPtr::localModelTransform() const { verifyIndex(); return getData()->localModelTransform[calculateIndex()]; }


    AGX_FORCE_INLINE agx::AffineMatrix4x4& RigidBodyPtr::cmTransform() { verifyIndex(); return getData()->cmTransform[calculateIndex()]; }

    AGX_FORCE_INLINE agx::AffineMatrix4x4 const& RigidBodyPtr::cmTransform() const { verifyIndex(); return getData()->cmTransform[calculateIndex()]; }


    AGX_FORCE_INLINE agx::AffineMatrix4x4& RigidBodyPtr::localCmTransform() { verifyIndex(); return getData()->localCmTransform[calculateIndex()]; }

    AGX_FORCE_INLINE agx::AffineMatrix4x4 const& RigidBodyPtr::localCmTransform() const { verifyIndex(); return getData()->localCmTransform[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::velocity() { verifyIndex(); return getData()->velocity[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::velocity() const { verifyIndex(); return getData()->velocity[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::angularVelocity() { verifyIndex(); return getData()->angularVelocity[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::angularVelocity() const { verifyIndex(); return getData()->angularVelocity[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::linearAcceleration() { verifyIndex(); return getData()->linearAcceleration[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::linearAcceleration() const { verifyIndex(); return getData()->linearAcceleration[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyPtr::angularAcceleration() { verifyIndex(); return getData()->angularAcceleration[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyPtr::angularAcceleration() const { verifyIndex(); return getData()->angularAcceleration[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3f& RigidBodyPtr::linearVelocityDamping() { verifyIndex(); return getData()->linearVelocityDamping[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3f const& RigidBodyPtr::linearVelocityDamping() const { verifyIndex(); return getData()->linearVelocityDamping[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3f& RigidBodyPtr::angularVelocityDamping() { verifyIndex(); return getData()->angularVelocityDamping[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3f const& RigidBodyPtr::angularVelocityDamping() const { verifyIndex(); return getData()->angularVelocityDamping[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3f& RigidBodyPtr::linearVelocityZeroDamping() { verifyIndex(); return getData()->linearVelocityZeroDamping[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3f const& RigidBodyPtr::linearVelocityZeroDamping() const { verifyIndex(); return getData()->linearVelocityZeroDamping[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Vec3f& RigidBodyPtr::angularVelocityZeroDamping() { verifyIndex(); return getData()->angularVelocityZeroDamping[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Vec3f const& RigidBodyPtr::angularVelocityZeroDamping() const { verifyIndex(); return getData()->angularVelocityZeroDamping[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Physics::GeometryPtr& RigidBodyPtr::geometry() { verifyIndex(); return getData()->geometry[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Physics::GeometryPtr const& RigidBodyPtr::geometry() const { verifyIndex(); return getData()->geometry[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Physics::GraphNodePtr& RigidBodyPtr::graphNode() { verifyIndex(); return getData()->graphNode[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Physics::GraphNodePtr const& RigidBodyPtr::graphNode() const { verifyIndex(); return getData()->graphNode[calculateIndex()]; }


    AGX_FORCE_INLINE agx::Range6& RigidBodyPtr::velocityRanges() { verifyIndex(); return getData()->velocityRanges[calculateIndex()]; }

    AGX_FORCE_INLINE agx::Range6 const& RigidBodyPtr::velocityRanges() const { verifyIndex(); return getData()->velocityRanges[calculateIndex()]; }


    AGX_FORCE_INLINE agx::RigidBody*& RigidBodyPtr::model() { verifyIndex(); return getData()->model[calculateIndex()]; }

    AGX_FORCE_INLINE agx::RigidBody* const& RigidBodyPtr::model() const { verifyIndex(); return getData()->model[calculateIndex()]; }


    AGX_FORCE_INLINE agx::UInt32& RigidBodyPtr::solveIndex() { verifyIndex(); return getData()->solveIndex[calculateIndex()]; }

    AGX_FORCE_INLINE agx::UInt32 const& RigidBodyPtr::solveIndex() const { verifyIndex(); return getData()->solveIndex[calculateIndex()]; }


    AGX_FORCE_INLINE agx::UInt16& RigidBodyPtr::numConstraints() { verifyIndex(); return getData()->numConstraints[calculateIndex()]; }

    AGX_FORCE_INLINE agx::UInt16 const& RigidBodyPtr::numConstraints() const { verifyIndex(); return getData()->numConstraints[calculateIndex()]; }


    //-----------------------------------------------------------------------------------------------------

    AGX_FORCE_INLINE RigidBodyInstance::RigidBodyInstance() {}

    AGX_FORCE_INLINE RigidBodyInstance::RigidBodyInstance(RigidBodyData* data, agx::Index index) : agx::ReferencedInstance(data, index) {}

    AGX_FORCE_INLINE RigidBodyInstance::RigidBodyInstance(agxData::EntityStorage* storage, agx::Index index) : agx::ReferencedInstance(storage, index) {}

    AGX_FORCE_INLINE RigidBodyInstance::RigidBodyInstance(const agxData::EntityInstance& other) : agx::ReferencedInstance(other)

    {

      agxAssertN(!other || other.isInstanceOf(RigidBodyModel::instance()),

        "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",

        EntityInstance::getModel()->fullPath().c_str(), RigidBodyModel::instance()->fullPath().c_str());

    }


    AGX_FORCE_INLINE RigidBodyInstance::RigidBodyInstance(const agxData::EntityPtr& ptr) : agx::ReferencedInstance(ptr)

    {

      agxAssertN(!ptr || ptr.isInstanceOf(RigidBodyModel::instance()),

        "Entity type mismatch. Storage contains entity data for type \'%s\', instance pointer is of type \'%s\'",

        EntityInstance::getModel()->fullPath().c_str(), RigidBodyModel::instance()->fullPath().c_str());

    }


    AGX_FORCE_INLINE RigidBodyData* RigidBodyInstance::getData() { return static_cast<RigidBodyData* >(agxData::EntityInstance::getData()); }

    AGX_FORCE_INLINE const RigidBodyData* RigidBodyInstance::getData() const { return static_cast<const RigidBodyData* >(agxData::EntityInstance::getData()); }


    AGX_FORCE_INLINE agx::UInt32& RigidBodyInstance::id() { verifyIndex(); return getData()->id[getIndex()]; }

    AGX_FORCE_INLINE agx::UInt32 const& RigidBodyInstance::id() const { verifyIndex(); return getData()->id[getIndex()]; }


    AGX_FORCE_INLINE agx::RigidBodyState& RigidBodyInstance::state() { verifyIndex(); return getData()->state[getIndex()]; }

    AGX_FORCE_INLINE agx::RigidBodyState const& RigidBodyInstance::state() const { verifyIndex(); return getData()->state[getIndex()]; }


    AGX_FORCE_INLINE agx::Name& RigidBodyInstance::name() { verifyIndex(); return getData()->name[getIndex()]; }

    AGX_FORCE_INLINE agx::Name const& RigidBodyInstance::name() const { verifyIndex(); return getData()->name[getIndex()]; }


    AGX_FORCE_INLINE agx::Real& RigidBodyInstance::mass() { verifyIndex(); return getData()->mass[getIndex()]; }

    AGX_FORCE_INLINE agx::Real const& RigidBodyInstance::mass() const { verifyIndex(); return getData()->mass[getIndex()]; }


    AGX_FORCE_INLINE agx::Real& RigidBodyInstance::invMass() { verifyIndex(); return getData()->invMass[getIndex()]; }

    AGX_FORCE_INLINE agx::Real const& RigidBodyInstance::invMass() const { verifyIndex(); return getData()->invMass[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::effectiveMass() { verifyIndex(); return getData()->effectiveMass[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::effectiveMass() const { verifyIndex(); return getData()->effectiveMass[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::effectiveMassCoefficients() { verifyIndex(); return getData()->effectiveMassCoefficients[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::effectiveMassCoefficients() const { verifyIndex(); return getData()->effectiveMassCoefficients[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::effectiveMassTransformDiagonal() { verifyIndex(); return getData()->effectiveMassTransformDiagonal[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::effectiveMassTransformDiagonal() const { verifyIndex(); return getData()->effectiveMassTransformDiagonal[getIndex()]; }


    AGX_FORCE_INLINE agx::SPDMatrix3x3& RigidBodyInstance::inertia() { verifyIndex(); return getData()->inertia[getIndex()]; }

    AGX_FORCE_INLINE agx::SPDMatrix3x3 const& RigidBodyInstance::inertia() const { verifyIndex(); return getData()->inertia[getIndex()]; }


    AGX_FORCE_INLINE agx::SPDMatrix3x3& RigidBodyInstance::effectiveInertia() { verifyIndex(); return getData()->effectiveInertia[getIndex()]; }

    AGX_FORCE_INLINE agx::SPDMatrix3x3 const& RigidBodyInstance::effectiveInertia() const { verifyIndex(); return getData()->effectiveInertia[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::effectiveInertiaCoefficients() { verifyIndex(); return getData()->effectiveInertiaCoefficients[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::effectiveInertiaCoefficients() const { verifyIndex(); return getData()->effectiveInertiaCoefficients[getIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyInstance::worldMassMatrix() { verifyIndex(); return getData()->worldMassMatrix[getIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyInstance::worldMassMatrix() const { verifyIndex(); return getData()->worldMassMatrix[getIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyInstance::invWorldMassMatrix() { verifyIndex(); return getData()->invWorldMassMatrix[getIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyInstance::invWorldMassMatrix() const { verifyIndex(); return getData()->invWorldMassMatrix[getIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyInstance::effectiveWorldMassMatrix() { verifyIndex(); return getData()->effectiveWorldMassMatrix[getIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyInstance::effectiveWorldMassMatrix() const { verifyIndex(); return getData()->effectiveWorldMassMatrix[getIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyInstance::effectiveInvWorldMassMatrix() { verifyIndex(); return getData()->effectiveInvWorldMassMatrix[getIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyInstance::effectiveInvWorldMassMatrix() const { verifyIndex(); return getData()->effectiveInvWorldMassMatrix[getIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyInstance::worldInertia() { verifyIndex(); return getData()->worldInertia[getIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyInstance::worldInertia() const { verifyIndex(); return getData()->worldInertia[getIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyInstance::invWorldInertia() { verifyIndex(); return getData()->invWorldInertia[getIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyInstance::invWorldInertia() const { verifyIndex(); return getData()->invWorldInertia[getIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyInstance::effectiveWorldInertia() { verifyIndex(); return getData()->effectiveWorldInertia[getIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyInstance::effectiveWorldInertia() const { verifyIndex(); return getData()->effectiveWorldInertia[getIndex()]; }


    AGX_FORCE_INLINE agx::Matrix3x3& RigidBodyInstance::effectiveInvWorldInertia() { verifyIndex(); return getData()->effectiveInvWorldInertia[getIndex()]; }

    AGX_FORCE_INLINE agx::Matrix3x3 const& RigidBodyInstance::effectiveInvWorldInertia() const { verifyIndex(); return getData()->effectiveInvWorldInertia[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::force() { verifyIndex(); return getData()->force[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::force() const { verifyIndex(); return getData()->force[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::torque() { verifyIndex(); return getData()->torque[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::torque() const { verifyIndex(); return getData()->torque[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::lastForce() { verifyIndex(); return getData()->lastForce[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::lastForce() const { verifyIndex(); return getData()->lastForce[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::lastTorque() { verifyIndex(); return getData()->lastTorque[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::lastTorque() const { verifyIndex(); return getData()->lastTorque[getIndex()]; }


    AGX_FORCE_INLINE agx::AffineMatrix4x4& RigidBodyInstance::modelTransform() { verifyIndex(); return getData()->modelTransform[getIndex()]; }

    AGX_FORCE_INLINE agx::AffineMatrix4x4 const& RigidBodyInstance::modelTransform() const { verifyIndex(); return getData()->modelTransform[getIndex()]; }


    AGX_FORCE_INLINE agx::AffineMatrix4x4& RigidBodyInstance::localModelTransform() { verifyIndex(); return getData()->localModelTransform[getIndex()]; }

    AGX_FORCE_INLINE agx::AffineMatrix4x4 const& RigidBodyInstance::localModelTransform() const { verifyIndex(); return getData()->localModelTransform[getIndex()]; }


    AGX_FORCE_INLINE agx::AffineMatrix4x4& RigidBodyInstance::cmTransform() { verifyIndex(); return getData()->cmTransform[getIndex()]; }

    AGX_FORCE_INLINE agx::AffineMatrix4x4 const& RigidBodyInstance::cmTransform() const { verifyIndex(); return getData()->cmTransform[getIndex()]; }


    AGX_FORCE_INLINE agx::AffineMatrix4x4& RigidBodyInstance::localCmTransform() { verifyIndex(); return getData()->localCmTransform[getIndex()]; }

    AGX_FORCE_INLINE agx::AffineMatrix4x4 const& RigidBodyInstance::localCmTransform() const { verifyIndex(); return getData()->localCmTransform[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::velocity() { verifyIndex(); return getData()->velocity[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::velocity() const { verifyIndex(); return getData()->velocity[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::angularVelocity() { verifyIndex(); return getData()->angularVelocity[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::angularVelocity() const { verifyIndex(); return getData()->angularVelocity[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::linearAcceleration() { verifyIndex(); return getData()->linearAcceleration[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::linearAcceleration() const { verifyIndex(); return getData()->linearAcceleration[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3& RigidBodyInstance::angularAcceleration() { verifyIndex(); return getData()->angularAcceleration[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3 const& RigidBodyInstance::angularAcceleration() const { verifyIndex(); return getData()->angularAcceleration[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3f& RigidBodyInstance::linearVelocityDamping() { verifyIndex(); return getData()->linearVelocityDamping[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3f const& RigidBodyInstance::linearVelocityDamping() const { verifyIndex(); return getData()->linearVelocityDamping[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3f& RigidBodyInstance::angularVelocityDamping() { verifyIndex(); return getData()->angularVelocityDamping[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3f const& RigidBodyInstance::angularVelocityDamping() const { verifyIndex(); return getData()->angularVelocityDamping[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3f& RigidBodyInstance::linearVelocityZeroDamping() { verifyIndex(); return getData()->linearVelocityZeroDamping[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3f const& RigidBodyInstance::linearVelocityZeroDamping() const { verifyIndex(); return getData()->linearVelocityZeroDamping[getIndex()]; }


    AGX_FORCE_INLINE agx::Vec3f& RigidBodyInstance::angularVelocityZeroDamping() { verifyIndex(); return getData()->angularVelocityZeroDamping[getIndex()]; }

    AGX_FORCE_INLINE agx::Vec3f const& RigidBodyInstance::angularVelocityZeroDamping() const { verifyIndex(); return getData()->angularVelocityZeroDamping[getIndex()]; }


    AGX_FORCE_INLINE agx::Physics::GeometryPtr& RigidBodyInstance::geometry() { verifyIndex(); return getData()->geometry[getIndex()]; }

    AGX_FORCE_INLINE agx::Physics::GeometryPtr const& RigidBodyInstance::geometry() const { verifyIndex(); return getData()->geometry[getIndex()]; }


    AGX_FORCE_INLINE agx::Physics::GraphNodePtr& RigidBodyInstance::graphNode() { verifyIndex(); return getData()->graphNode[getIndex()]; }

    AGX_FORCE_INLINE agx::Physics::GraphNodePtr const& RigidBodyInstance::graphNode() const { verifyIndex(); return getData()->graphNode[getIndex()]; }


    AGX_FORCE_INLINE agx::Range6& RigidBodyInstance::velocityRanges() { verifyIndex(); return getData()->velocityRanges[getIndex()]; }

    AGX_FORCE_INLINE agx::Range6 const& RigidBodyInstance::velocityRanges() const { verifyIndex(); return getData()->velocityRanges[getIndex()]; }


    AGX_FORCE_INLINE agx::RigidBody*& RigidBodyInstance::model() { verifyIndex(); return getData()->model[getIndex()]; }

    AGX_FORCE_INLINE agx::RigidBody* const& RigidBodyInstance::model() const { verifyIndex(); return getData()->model[getIndex()]; }


    AGX_FORCE_INLINE agx::UInt32& RigidBodyInstance::solveIndex() { verifyIndex(); return getData()->solveIndex[getIndex()]; }

    AGX_FORCE_INLINE agx::UInt32 const& RigidBodyInstance::solveIndex() const { verifyIndex(); return getData()->solveIndex[getIndex()]; }


    AGX_FORCE_INLINE agx::UInt16& RigidBodyInstance::numConstraints() { verifyIndex(); return getData()->numConstraints[getIndex()]; }

    AGX_FORCE_INLINE agx::UInt16 const& RigidBodyInstance::numConstraints() const { verifyIndex(); return getData()->numConstraints[getIndex()]; }


    //-----------------------------------------------------------------------------------------------------

    AGX_FORCE_INLINE RigidBodySemantics::RigidBodySemantics() {}

    //-----------------------------------------------------------------------------------------------------

    DOXYGEN_END_INTERNAL_BLOCK()

  }

}


AGX_TYPE_BINDING(agx::Physics::RigidBodyPtr, "Physics.RigidBodyPtr")

AGX_TYPE_BINDING(agx::Physics::RigidBodyInstance, "Physics.RigidBodyInstance")


#ifdef _MSC_VER

# pragma warning(pop)

#endif


#undef AGX_ENTITY_WRAPPER

#undef AGX_ENTITY_NAMESPACE

#endif


AffineMatrix4x4.h

EntityInstance.h

EntityModel.h

EntityPtr.h

EntityRef.h

EntityStorage.h

GeometryEntity.h

GraphNodeEntity.h

Integer.h

Matrix3x3.h

Name.h

Range6.h

Real.h

ReferencedEntity.h

AGX_DECLARE_POINTER_TYPES
#define AGX_DECLARE_POINTER_TYPES(type)
Definition: Referenced.h:254

RigidBodyState.h

SPDMatrix3x3.h

AGX_TYPE_BINDING
#define AGX_TYPE_BINDING(_Type, _Name)
Definition: Type.h:179

AGXPHYSICS_EXPORT
#define AGXPHYSICS_EXPORT

Vec3.h

agxData::Array
Type-specific Array used for fast access into the data held by a Buffer.
Definition: Array.h:107

agxData::EntityInstance
Entity instance provides access to a single instance in an EntityStorage.
Definition: EntityInstance.h:43

agxData::EntityInstance::isInstanceOf
bool isInstanceOf(agxData::EntityModel *model) const
Definition: EntityStorage.h:829

agxData::EntityInstance::getData
agxData::EntityData * getData()
Definition: EntityInstance.h:148

agxData::EntityPtr
Accessor to a entity instance stored in a EntityStorage, to allow SOA (structure of arrays) data to b...
Definition: EntityPtr.h:52

agxData::EntityPtr::operator=
EntityPtr & operator=(const EntityPtr &other)=default

agxData::EntityPtr::isInstanceOf
bool isInstanceOf(agxData::EntityModel *model) const
Definition: EntityStorage.h:784

agxData::EntityPtr::getData
agxData::EntityData * getData()
Definition: EntityStorage.h:594

agxData::EntityPtr::instance
agxData::EntityInstance instance()
Definition: EntityPtr.h:269

agxData::EntityRef< RigidBodyPtr >

agxData::EntityStorage
Data storage for a collection of entity instances of a specified EntityModel.
Definition: EntityStorage.h:73

agxData::PointerAttributeT
Definition: Attribute.h:293

agxData::ScalarAttributeT< agx::UInt32 >

agx::AffineMatrix4x4T< Real >

agx::AgXString< std::string >

agx::Matrix3x3T< Real >

agx::Model::fullPath
agx::String fullPath() const

agx::Name
Representation of a name string.
Definition: Name.h:33

agx::Physics::GeometryPtr
Pointer to a entity instance of type Physics.Geometry.
Definition: GeometryEntity.h:270

agx::Physics::GraphNodePtr
Pointer to a entity instance of type Physics.GraphNode.
Definition: GraphNodeEntity.h:194

agx::Physics::RigidBodyModel
Abstract description of the data attributes for the Physics.RigidBody entity.
Definition: RigidBodyEntity.h:82

agx::Physics::RigidBodyModel::velocityAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * velocityAttribute
Definition: RigidBodyEntity.h:130

agx::Physics::RigidBodyModel::linearVelocityZeroDampingAttribute
static agxData::ScalarAttributeT< agx::Vec3f > * linearVelocityZeroDampingAttribute
Definition: RigidBodyEntity.h:136

agx::Physics::RigidBodyModel::cmTransformAttribute
static agxData::ScalarAttributeT< agx::AffineMatrix4x4 > * cmTransformAttribute
Definition: RigidBodyEntity.h:128

agx::Physics::RigidBodyModel::angularVelocityAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * angularVelocityAttribute
Definition: RigidBodyEntity.h:131

agx::Physics::RigidBodyModel::instance
static RigidBodyModel * instance()

agx::Physics::RigidBodyModel::RigidBodyModel
RigidBodyModel(const agx::String &name="RigidBody")

agx::Physics::RigidBodyModel::invWorldInertiaAttribute
static agxData::ScalarAttributeT< agx::Matrix3x3 > * invWorldInertiaAttribute
Definition: RigidBodyEntity.h:119

agx::Physics::RigidBodyModel::invWorldMassMatrixAttribute
static agxData::ScalarAttributeT< agx::Matrix3x3 > * invWorldMassMatrixAttribute
Definition: RigidBodyEntity.h:115

agx::Physics::RigidBodyModel::effectiveWorldInertiaAttribute
static agxData::ScalarAttributeT< agx::Matrix3x3 > * effectiveWorldInertiaAttribute
Definition: RigidBodyEntity.h:120

agx::Physics::RigidBodyModel::forceAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * forceAttribute
Definition: RigidBodyEntity.h:122

agx::Physics::RigidBodyModel::invMassAttribute
static agxData::ScalarAttributeT< agx::Real > * invMassAttribute
Definition: RigidBodyEntity.h:107

agx::Physics::RigidBodyModel::torqueAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * torqueAttribute
Definition: RigidBodyEntity.h:123

agx::Physics::RigidBodyModel::defaultStorage
static agxData::EntityStorage * defaultStorage()

agx::Physics::RigidBodyModel::initAttributeAccessors
virtual void initAttributeAccessors() override

agx::Physics::RigidBodyModel::velocityRangesAttribute
static agxData::ScalarAttributeT< agx::Range6 > * velocityRangesAttribute
Definition: RigidBodyEntity.h:140

agx::Physics::RigidBodyModel::worldMassMatrixAttribute
static agxData::ScalarAttributeT< agx::Matrix3x3 > * worldMassMatrixAttribute
Definition: RigidBodyEntity.h:114

agx::Physics::RigidBodyModel::modelAttribute
static agxData::PointerAttributeT< agx::RigidBody * > * modelAttribute
Definition: RigidBodyEntity.h:141

agx::Physics::RigidBodyModel::solveIndexAttribute
static agxData::ScalarAttributeT< agx::UInt32 > * solveIndexAttribute
Definition: RigidBodyEntity.h:142

agx::Physics::RigidBodyModel::~RigidBodyModel
virtual ~RigidBodyModel()

agx::Physics::RigidBodyModel::createData
virtual agxData::EntityData * createData(agxData::EntityStorage *storage) override

agx::Physics::RigidBodyModel::effectiveWorldMassMatrixAttribute
static agxData::ScalarAttributeT< agx::Matrix3x3 > * effectiveWorldMassMatrixAttribute
Definition: RigidBodyEntity.h:116

agx::Physics::RigidBodyModel::geometryAttribute
static agxData::ScalarAttributeT< agx::Physics::GeometryPtr > * geometryAttribute
Definition: RigidBodyEntity.h:138

agx::Physics::RigidBodyModel::construct
virtual void construct(agxData::EntityPtr instance) override

agx::Physics::RigidBodyModel::effectiveInvWorldInertiaAttribute
static agxData::ScalarAttributeT< agx::Matrix3x3 > * effectiveInvWorldInertiaAttribute
Definition: RigidBodyEntity.h:121

agx::Physics::RigidBodyModel::stateAttribute
static agxData::ScalarAttributeT< agx::RigidBodyState > * stateAttribute
Definition: RigidBodyEntity.h:104

agx::Physics::RigidBodyModel::angularVelocityDampingAttribute
static agxData::ScalarAttributeT< agx::Vec3f > * angularVelocityDampingAttribute
Definition: RigidBodyEntity.h:135

agx::Physics::RigidBodyModel::linearAccelerationAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * linearAccelerationAttribute
Definition: RigidBodyEntity.h:132

agx::Physics::RigidBodyModel::worldInertiaAttribute
static agxData::ScalarAttributeT< agx::Matrix3x3 > * worldInertiaAttribute
Definition: RigidBodyEntity.h:118

agx::Physics::RigidBodyModel::effectiveMassTransformDiagonalAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * effectiveMassTransformDiagonalAttribute
Definition: RigidBodyEntity.h:110

agx::Physics::RigidBodyModel::construct
void construct(agx::Physics::RigidBodyPtr rigidBody)

agx::Physics::RigidBodyModel::lastForceAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * lastForceAttribute
Definition: RigidBodyEntity.h:124

agx::Physics::RigidBodyModel::PtrT
RigidBodyPtr PtrT
Definition: RigidBodyEntity.h:84

agx::Physics::RigidBodyModel::nameAttribute
static agxData::ScalarAttributeT< agx::Name > * nameAttribute
Definition: RigidBodyEntity.h:105

agx::Physics::RigidBodyModel::angularAccelerationAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * angularAccelerationAttribute
Definition: RigidBodyEntity.h:133

agx::Physics::RigidBodyModel::effectiveInertiaCoefficientsAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * effectiveInertiaCoefficientsAttribute
Definition: RigidBodyEntity.h:113

agx::Physics::RigidBodyModel::configure
virtual void configure(agx::TiXmlElement *eEntity) override

agx::Physics::RigidBodyModel::idAttribute
static agxData::ScalarAttributeT< agx::UInt32 > * idAttribute
Definition: RigidBodyEntity.h:103

agx::Physics::RigidBodyModel::angularVelocityZeroDampingAttribute
static agxData::ScalarAttributeT< agx::Vec3f > * angularVelocityZeroDampingAttribute
Definition: RigidBodyEntity.h:137

agx::Physics::RigidBodyModel::createInstance
static RigidBodyPtr createInstance()
Create and return a pointer to a new instance in the default storage for this entity model.

agx::Physics::RigidBodyModel::numConstraintsAttribute
static agxData::ScalarAttributeT< agx::UInt16 > * numConstraintsAttribute
Definition: RigidBodyEntity.h:143

agx::Physics::RigidBodyModel::effectiveMassCoefficientsAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * effectiveMassCoefficientsAttribute
Definition: RigidBodyEntity.h:109

agx::Physics::RigidBodyModel::effectiveMassAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * effectiveMassAttribute
Definition: RigidBodyEntity.h:108

agx::Physics::RigidBodyModel::localModelTransformAttribute
static agxData::ScalarAttributeT< agx::AffineMatrix4x4 > * localModelTransformAttribute
Definition: RigidBodyEntity.h:127

agx::Physics::RigidBodyModel::shutdownCleanup
virtual void shutdownCleanup() override
This is part of internal cleanup and should not be called by users.

agx::Physics::RigidBodyModel::inertiaAttribute
static agxData::ScalarAttributeT< agx::SPDMatrix3x3 > * inertiaAttribute
Definition: RigidBodyEntity.h:111

agx::Physics::RigidBodyModel::lastTorqueAttribute
static agxData::ScalarAttributeT< agx::Vec3 > * lastTorqueAttribute
Definition: RigidBodyEntity.h:125

agx::Physics::RigidBodyModel::linearVelocityDampingAttribute
static agxData::ScalarAttributeT< agx::Vec3f > * linearVelocityDampingAttribute
Definition: RigidBodyEntity.h:134

agx::Physics::RigidBodyModel::massAttribute
static agxData::ScalarAttributeT< agx::Real > * massAttribute
Definition: RigidBodyEntity.h:106

agx::Physics::RigidBodyModel::localCmTransformAttribute
static agxData::ScalarAttributeT< agx::AffineMatrix4x4 > * localCmTransformAttribute
Definition: RigidBodyEntity.h:129

agx::Physics::RigidBodyModel::modelTransformAttribute
static agxData::ScalarAttributeT< agx::AffineMatrix4x4 > * modelTransformAttribute
Definition: RigidBodyEntity.h:126

agx::Physics::RigidBodyModel::graphNodeAttribute
static agxData::ScalarAttributeT< agx::Physics::GraphNodePtr > * graphNodeAttribute
Definition: RigidBodyEntity.h:139

agx::Physics::RigidBodyModel::effectiveInvWorldMassMatrixAttribute
static agxData::ScalarAttributeT< agx::Matrix3x3 > * effectiveInvWorldMassMatrixAttribute
Definition: RigidBodyEntity.h:117

agx::Physics::RigidBodyModel::effectiveInertiaAttribute
static agxData::ScalarAttributeT< agx::SPDMatrix3x3 > * effectiveInertiaAttribute
Definition: RigidBodyEntity.h:112

agx::Physics::RigidBodyPtr
Pointer to a entity instance of type Physics.RigidBody.
Definition: RigidBodyEntity.h:372

agx::Physics::RigidBodyPtr::model
AGXPHYSICS_EXPORT agx::RigidBody *& model()

agx::Physics::RigidBodyPtr::effectiveInertia
AGXPHYSICS_EXPORT agx::SPDMatrix3x3 const & effectiveInertia() const

agx::Physics::RigidBodyPtr::lastTorque
AGXPHYSICS_EXPORT agx::Vec3 const & lastTorque() const

agx::Physics::RigidBodyPtr::effectiveWorldInertia
AGXPHYSICS_EXPORT agx::Matrix3x3 & effectiveWorldInertia()

agx::Physics::RigidBodyPtr::velocityRanges
AGXPHYSICS_EXPORT agx::Range6 & velocityRanges()

agx::Physics::RigidBodyPtr::linearAcceleration
AGXPHYSICS_EXPORT agx::Vec3 const & linearAcceleration() const

agx::Physics::RigidBodyPtr::localModelTransform
AGXPHYSICS_EXPORT agx::AffineMatrix4x4 & localModelTransform()

agx::Physics::RigidBodyPtr::instance
AGXPHYSICS_EXPORT const RigidBodyInstance instance() const

agx::Physics::RigidBodyPtr::id
AGXPHYSICS_EXPORT agx::UInt32 & id()

agx::Physics::RigidBodyPtr::localCmTransform
AGXPHYSICS_EXPORT agx::AffineMatrix4x4 const & localCmTransform() const

agx::Physics::RigidBodyPtr::effectiveWorldMassMatrix
AGXPHYSICS_EXPORT agx::Matrix3x3 const & effectiveWorldMassMatrix() const

agx::Physics::RigidBodyPtr::angularVelocityDamping
AGXPHYSICS_EXPORT agx::Vec3f const & angularVelocityDamping() const

agx::Physics::RigidBodyPtr::operator->
AGXPHYSICS_EXPORT const RigidBodySemantics * operator->() const

agx::Physics::RigidBodyPtr::lastForce
AGXPHYSICS_EXPORT agx::Vec3 const & lastForce() const

agx::Physics::RigidBodyPtr::localModelTransform
AGXPHYSICS_EXPORT agx::AffineMatrix4x4 const & localModelTransform() const

agx::Physics::RigidBodyPtr::effectiveInvWorldInertia
AGXPHYSICS_EXPORT agx::Matrix3x3 const & effectiveInvWorldInertia() const

agx::Physics::RigidBodyPtr::worldMassMatrix
AGXPHYSICS_EXPORT agx::Matrix3x3 & worldMassMatrix()

agx::Physics::RigidBodyPtr::RigidBodyPtr
AGXPHYSICS_EXPORT RigidBodyPtr(agxData::EntityStorage *storage, agx::Index id)

agx::Physics::RigidBodyPtr::mass
AGXPHYSICS_EXPORT agx::Real & mass()

agx::Physics::RigidBodyPtr::linearVelocityDamping
AGXPHYSICS_EXPORT agx::Vec3f & linearVelocityDamping()

agx::Physics::RigidBodyPtr::angularVelocityZeroDamping
AGXPHYSICS_EXPORT agx::Vec3f const & angularVelocityZeroDamping() const

agx::Physics::RigidBodyPtr::numConstraints
AGXPHYSICS_EXPORT agx::UInt16 const & numConstraints() const

agx::Physics::RigidBodyPtr::angularVelocityZeroDamping
AGXPHYSICS_EXPORT agx::Vec3f & angularVelocityZeroDamping()

agx::Physics::RigidBodyPtr::velocity
AGXPHYSICS_EXPORT agx::Vec3 & velocity()

agx::Physics::RigidBodyPtr::linearVelocityDamping
AGXPHYSICS_EXPORT agx::Vec3f const & linearVelocityDamping() const

agx::Physics::RigidBodyPtr::geometry
AGXPHYSICS_EXPORT agx::Physics::GeometryPtr const & geometry() const

agx::Physics::RigidBodyPtr::model
AGXPHYSICS_EXPORT agx::RigidBody *const & model() const

agx::Physics::RigidBodyPtr::state
AGXPHYSICS_EXPORT agx::RigidBodyState const & state() const

agx::Physics::RigidBodyPtr::RigidBodyPtr
AGXPHYSICS_EXPORT RigidBodyPtr()

agx::Physics::RigidBodyPtr::mass
AGXPHYSICS_EXPORT agx::Real const & mass() const

agx::Physics::RigidBodyPtr::getData
const RigidBodyData * getData() const

agx::Physics::RigidBodyPtr::torque
AGXPHYSICS_EXPORT agx::Vec3 const & torque() const

agx::Physics::RigidBodyPtr::DataType
RigidBodyData DataType
Definition: RigidBodyEntity.h:375

agx::Physics::RigidBodyPtr::angularVelocityDamping
AGXPHYSICS_EXPORT agx::Vec3f & angularVelocityDamping()

agx::Physics::RigidBodyPtr::worldInertia
AGXPHYSICS_EXPORT agx::Matrix3x3 const & worldInertia() const

agx::Physics::RigidBodyPtr::effectiveInertiaCoefficients
AGXPHYSICS_EXPORT agx::Vec3 const & effectiveInertiaCoefficients() const

agx::Physics::RigidBodyPtr::modelTransform
AGXPHYSICS_EXPORT agx::AffineMatrix4x4 const & modelTransform() const

agx::Physics::RigidBodyPtr::angularVelocity
AGXPHYSICS_EXPORT agx::Vec3 const & angularVelocity() const

agx::Physics::RigidBodyPtr::localCmTransform
AGXPHYSICS_EXPORT agx::AffineMatrix4x4 & localCmTransform()

agx::Physics::RigidBodyPtr::invWorldInertia
AGXPHYSICS_EXPORT agx::Matrix3x3 & invWorldInertia()

agx::Physics::RigidBodyPtr::angularVelocity
AGXPHYSICS_EXPORT agx::Vec3 & angularVelocity()

agx::Physics::RigidBodyPtr::effectiveInertiaCoefficients
AGXPHYSICS_EXPORT agx::Vec3 & effectiveInertiaCoefficients()

agx::Physics::RigidBodyPtr::RigidBodyPtr
AGXPHYSICS_EXPORT RigidBodyPtr(const agxData::EntityInstance &instance)

agx::Physics::RigidBodyPtr::id
AGXPHYSICS_EXPORT agx::UInt32 const & id() const

agx::Physics::RigidBodyPtr::invMass
AGXPHYSICS_EXPORT agx::Real & invMass()

agx::Physics::RigidBodyPtr::effectiveMassTransformDiagonal
AGXPHYSICS_EXPORT agx::Vec3 & effectiveMassTransformDiagonal()

agx::Physics::RigidBodyPtr::lastTorque
AGXPHYSICS_EXPORT agx::Vec3 & lastTorque()

agx::Physics::RigidBodyPtr::solveIndex
AGXPHYSICS_EXPORT agx::UInt32 const & solveIndex() const

agx::Physics::RigidBodyPtr::effectiveMass
AGXPHYSICS_EXPORT agx::Vec3 & effectiveMass()

agx::Physics::RigidBodyPtr::linearVelocityZeroDamping
AGXPHYSICS_EXPORT agx::Vec3f & linearVelocityZeroDamping()

agx::Physics::RigidBodyPtr::getData
RigidBodyData * getData()

agx::Physics::RigidBodyPtr::name
AGXPHYSICS_EXPORT agx::Name & name()

agx::Physics::RigidBodyPtr::angularAcceleration
AGXPHYSICS_EXPORT agx::Vec3 const & angularAcceleration() const

agx::Physics::RigidBodyPtr::effectiveInertia
AGXPHYSICS_EXPORT agx::SPDMatrix3x3 & effectiveInertia()

agx::Physics::RigidBodyPtr::velocity
AGXPHYSICS_EXPORT agx::Vec3 const & velocity() const

agx::Physics::RigidBodyPtr::worldInertia
AGXPHYSICS_EXPORT agx::Matrix3x3 & worldInertia()

agx::Physics::RigidBodyPtr::inertia
AGXPHYSICS_EXPORT agx::SPDMatrix3x3 const & inertia() const

agx::Physics::RigidBodyPtr::RigidBodyPtr
AGXPHYSICS_EXPORT RigidBodyPtr(const agxData::EntityPtr &ptr)

agx::Physics::RigidBodyPtr::linearVelocityZeroDamping
AGXPHYSICS_EXPORT agx::Vec3f const & linearVelocityZeroDamping() const

agx::Physics::RigidBodyPtr::numConstraints
AGXPHYSICS_EXPORT agx::UInt16 & numConstraints()

agx::Physics::RigidBodyPtr::cmTransform
AGXPHYSICS_EXPORT agx::AffineMatrix4x4 const & cmTransform() const

agx::Physics::RigidBodyPtr::effectiveMassCoefficients
AGXPHYSICS_EXPORT agx::Vec3 & effectiveMassCoefficients()

agx::Physics::RigidBodyPtr::InstanceType
RigidBodyInstance InstanceType
Definition: RigidBodyEntity.h:376

agx::Physics::RigidBodyPtr::invMass
AGXPHYSICS_EXPORT agx::Real const & invMass() const

agx::Physics::RigidBodyPtr::effectiveWorldInertia
AGXPHYSICS_EXPORT agx::Matrix3x3 const & effectiveWorldInertia() const

agx::Physics::RigidBodyPtr::invWorldMassMatrix
AGXPHYSICS_EXPORT agx::Matrix3x3 const & invWorldMassMatrix() const

agx::Physics::RigidBodyPtr::torque
AGXPHYSICS_EXPORT agx::Vec3 & torque()

agx::Physics::RigidBodyPtr::worldMassMatrix
AGXPHYSICS_EXPORT agx::Matrix3x3 const & worldMassMatrix() const

agx::Physics::RigidBodyPtr::ModelType
RigidBodyModel ModelType
Definition: RigidBodyEntity.h:374

agx::Physics::RigidBodyPtr::effectiveMass
AGXPHYSICS_EXPORT agx::Vec3 const & effectiveMass() const

agx::Physics::RigidBodyPtr::effectiveMassTransformDiagonal
AGXPHYSICS_EXPORT agx::Vec3 const & effectiveMassTransformDiagonal() const

agx::Physics::RigidBodyPtr::effectiveInvWorldMassMatrix
AGXPHYSICS_EXPORT agx::Matrix3x3 & effectiveInvWorldMassMatrix()

agx::Physics::RigidBodyPtr::invWorldMassMatrix
AGXPHYSICS_EXPORT agx::Matrix3x3 & invWorldMassMatrix()

agx::Physics::RigidBodyPtr::lastForce
AGXPHYSICS_EXPORT agx::Vec3 & lastForce()

agx::Physics::RigidBodyPtr::state
AGXPHYSICS_EXPORT agx::RigidBodyState & state()

agx::Physics::RigidBodyPtr::modelTransform
AGXPHYSICS_EXPORT agx::AffineMatrix4x4 & modelTransform()

agx::Physics::RigidBodyPtr::instance
AGXPHYSICS_EXPORT RigidBodyInstance instance()

agx::Physics::RigidBodyPtr::inertia
AGXPHYSICS_EXPORT agx::SPDMatrix3x3 & inertia()

agx::Physics::RigidBodyPtr::linearAcceleration
AGXPHYSICS_EXPORT agx::Vec3 & linearAcceleration()

agx::Physics::RigidBodyPtr::effectiveInvWorldMassMatrix
AGXPHYSICS_EXPORT agx::Matrix3x3 const & effectiveInvWorldMassMatrix() const

agx::Physics::RigidBodyPtr::solveIndex
AGXPHYSICS_EXPORT agx::UInt32 & solveIndex()

agx::Physics::RigidBodyPtr::force
AGXPHYSICS_EXPORT agx::Vec3 & force()

agx::Physics::RigidBodyPtr::graphNode
AGXPHYSICS_EXPORT agx::Physics::GraphNodePtr const & graphNode() const

agx::Physics::RigidBodyPtr::force
AGXPHYSICS_EXPORT agx::Vec3 const & force() const

agx::Physics::RigidBodyPtr::name
AGXPHYSICS_EXPORT agx::Name const & name() const

agx::Physics::RigidBodyPtr::effectiveWorldMassMatrix
AGXPHYSICS_EXPORT agx::Matrix3x3 & effectiveWorldMassMatrix()

agx::Physics::RigidBodyPtr::velocityRanges
AGXPHYSICS_EXPORT agx::Range6 const & velocityRanges() const

agx::Physics::RigidBodyPtr::invWorldInertia
AGXPHYSICS_EXPORT agx::Matrix3x3 const & invWorldInertia() const

agx::Physics::RigidBodyPtr::angularAcceleration
AGXPHYSICS_EXPORT agx::Vec3 & angularAcceleration()

agx::Physics::RigidBodyPtr::effectiveInvWorldInertia
AGXPHYSICS_EXPORT agx::Matrix3x3 & effectiveInvWorldInertia()

agx::Physics::RigidBodyPtr::cmTransform
AGXPHYSICS_EXPORT agx::AffineMatrix4x4 & cmTransform()

agx::Physics::RigidBodyPtr::operator->
AGXPHYSICS_EXPORT RigidBodySemantics * operator->()

agx::Physics::RigidBodyPtr::geometry
AGXPHYSICS_EXPORT agx::Physics::GeometryPtr & geometry()

agx::Physics::RigidBodyPtr::graphNode
AGXPHYSICS_EXPORT agx::Physics::GraphNodePtr & graphNode()

agx::Physics::RigidBodyPtr::effectiveMassCoefficients
AGXPHYSICS_EXPORT agx::Vec3 const & effectiveMassCoefficients() const

agx::Range6T
Definition: Range6.h:28

agx::ReferencedModel
Abstract description of the data attributes for the Referenced entity.
Definition: ReferencedEntity.h:67

agx::ReferencedPtr
Pointer to a entity instance of type Referenced.
Definition: ReferencedEntity.h:167

agx::RigidBody
The rigid body class, combining a geometric model and a frame of reference.
Definition: RigidBody.h:49

agx::SPDMatrix3x3
Specialized type of matrices for holding symmetric positive definite matrices.
Definition: SPDMatrix3x3.h:48

agx::Vec3T< Real >

agx::VectorPOD
Vector containing 'raw' data.
Definition: agx/Vector.h:246

agxAssertN
#define agxAssertN(expr, format,...)
Definition: debug.h:145

macros.h

DOXYGEN_END_INTERNAL_BLOCK
#define DOXYGEN_END_INTERNAL_BLOCK()
Definition: macros.h:89

CALLABLE
#define CALLABLE
Definition: macros.h:72

DOXYGEN_START_INTERNAL_BLOCK
#define DOXYGEN_START_INTERNAL_BLOCK()
Definition: macros.h:88

AGX_FORCE_INLINE
#define AGX_FORCE_INLINE
Definition: macros.h:58

agxData
Contains classes for low level data storage for AGX.
Definition: Container.h:23

agx::Physics::RigidBodyRef
agxData::EntityRef< RigidBodyPtr > RigidBodyRef
Definition: RigidBodyEntity.h:603

agx
The agx namespace contains the dynamics/math part of the AGX Dynamics API.
Definition: AddedMassInteraction.h:23

agx::UInt16
uint16_t UInt16
Definition: Integer.h:31

agx::UInt32
uint32_t UInt32
Definition: Integer.h:32

agx::Real
double Real
Definition: Real.h:41

agx::getModel
AGXCORE_EXPORT Model * getModel(const Path &path, const Path &_namespace=Path())

agx::Index
UInt32 Index
Definition: Integer.h:44