SOFA API  df6198ac
Open source framework for multi-physics simuation
sofa::core Namespace Reference

Namespaces

 behavior
 For BaseMatrix.
 
 collision
 
 constraintparams
 
 execparams
 
 loader
 
 matrixaccumulator
 
 mechanicalparams
 
 objectmodel
 
 topology
 
 visual
 

Classes

class  State
 Component storing position and velocity vectors. More...
 
struct  AccumulationVecId
 Proxy class for accessing elements within an imaginary container that represents the cumulative sum of multiple other containers. Each individual container is represented by a VecId. The class maintains a list of VecIdDeriv objects, which defines the containers contributing to the final cumulative sum. This class provides a simplified interface for accessing elements within the cumulative container. It allows retrieving specific elements using the overloaded subscript operator (operator[]). When accessing an element at a particular index, the class delegates the retrieval to the appropriate container represented by the associated VecIdDeriv. In addition to element retrieval, the class supports dynamic management of the contributing containers. It offers functions to add and remove VecId objects from the list of containers that contribute to the cumulative sum. More...
 
class  MappingMatrixAccumulator
 
class  ListMappingMatrixAccumulator
 
class  GeometricStiffnessMatrix
 
class  BaseMapping
 
class  BaseMatrixAccumulatorComponent
 
struct  get_base_object_strong
 
class  BaseState
 Component storing position and velocity vectors. More...
 
class  BehaviorModel
 Abstract Interface of components defining the behavior of a simulated object. More...
 
class  CategoryLibrary
 An Generic Category of the Sofa Library. More...
 
class  BaseCollisionElementIterator
 Base class for reference to an collision element defined by its index More...
 
class  TCollisionElementIterator
 Reference to an collision element defined by its index inside a given collision model. More...
 
class  CollisionElementIterator
 Reference to an abstract collision element. More...
 
class  CollisionElementActiver
 
class  CollisionModel
 Abstract CollisionModel interface. More...
 
class  ComponentLibrary
 An Generic Component of the Sofa Library. More...
 
class  ComponentNameHelper
 
class  ConstraintParams
 
class  DataEngine
 from a set of Data inputs computes a set of Data outputs More...
 
struct  DataTracker
 
class  DataTrackerDDGNode
 A DDGNode with trackable input Data (containing a DataTracker) More...
 
class  DataTrackerCallback
 
class  DataTrackerFunctor
 
class  DerivativeMatrix
 
class  DevBaseMonitor
 A basic interface to define a Monitor capable to compute metrics. More...
 
class  ExecParams
 Class gathering parameters use by most components methods, and transmitted by all visitors. More...
 
struct  CleanupCheck
 
class  Mapping
 Specialized interface to convert a model state of type TIn to a model state of type TOut. This is basically a sofa::core::BaseMapping with given input and output types. More...
 
class  MatrixAccumulatorInterface
 
class  MatrixAccumulatorIndexChecker
 
class  ListMatrixAccumulator
 
class  MechanicalParams
 Class gathering parameters use by mechanical components methods, and transmitted by mechanical visitors. More...
 
class  MechanicalStatesMatrixAccumulators
 
class  Multi2Mapping
 Specialized interface to describe many to many mapping. The inputs can be of two different types, while all the outputs must be of the same type. More...
 
class  MultiMapping
 Specialized interface to describe many to many mapping. All the input must have the same type, and all the output must have the same type. See also class Multi2Mapping. More...
 
class  TMultiVecId
 
struct  StateVecAccessor
 Helper class to access vectors of a given type in a given State. More...
 
struct  StateVecAccessor< DataTypes, V_COORD, V_READ >
 
struct  StateVecAccessor< DataTypes, V_COORD, V_WRITE >
 
struct  StateVecAccessor< DataTypes, V_DERIV, V_READ >
 
struct  StateVecAccessor< DataTypes, V_DERIV, V_WRITE >
 
struct  StateVecAccessor< DataTypes, V_MATDERIV, V_READ >
 
struct  StateVecAccessor< DataTypes, V_MATDERIV, V_WRITE >
 
struct  StateVecAccessor< DataTypes, V_ALL, V_READ >
 
struct  StateVecAccessor< DataTypes, V_ALL, V_WRITE >
 
class  TMultiVecId< V_ALL, vaccess >
 
class  ObjectFactory
 
class  ObjectCreator
 Typed Creator class used to create instances of object type RealObject. More...
 
class  RegisterObject
 Helper class used to register a class in the ObjectFactory. More...
 
class  PathResolver
 This class exposes an API to query a context to find Base* or a BaseData*. More...
 
class  SofaLibrary
 An Generic Library. More...
 
class  TVecId
 
class  TStandardVec
 
class  TStandardVec< V_COORD, vaccess >
 
class  TStandardVec< V_DERIV, vaccess >
 
class  TStandardVec< V_MATDERIV, vaccess >
 
class  TStandardVec< V_ALL, vaccess >
 
class  BaseVecId
 
class  VecIdAlignFix
 
struct  VecIdProperties
 
class  TVecId< V_ALL, vaccess >
 Identify any vector stored in State. More...
 
struct  StateType
 
struct  StateType< DataTypes, core::V_COORD >
 
struct  StateType< DataTypes, core::V_DERIV >
 
struct  StateTypeSize
 
struct  StateTypeSize< DataTypes, core::V_COORD >
 
struct  StateTypeSize< DataTypes, core::V_DERIV >
 
struct  StateVecType
 
struct  StateVecType< DataTypes, core::V_COORD >
 
struct  StateVecType< DataTypes, core::V_DERIV >
 

Typedefs

template<matrixaccumulator::Contribution c>
using get_base_object_strong_type = typename get_base_object_strong< c >::type
 Helper alias. More...
 
typedef sofa::core::ObjectFactory::Creator Creator
 
typedef sofa::core::ObjectFactory::ClassEntry ClassEntry
 
typedef TMultiVecId< V_COORD, V_READConstMultiVecCoordId
 
typedef TMultiVecId< V_COORD, V_WRITEMultiVecCoordId
 
typedef TMultiVecId< V_DERIV, V_READConstMultiVecDerivId
 
typedef TMultiVecId< V_DERIV, V_WRITEMultiVecDerivId
 
typedef TMultiVecId< V_MATDERIV, V_READConstMultiMatrixDerivId
 
typedef TMultiVecId< V_MATDERIV, V_WRITEMultiMatrixDerivId
 
typedef TMultiVecId< V_ALL, V_READConstMultiVecId
 
typedef TMultiVecId< V_ALL, V_WRITEMultiVecId
 
typedef std::function< void(sofa::core::objectmodel::Base *, sofa::core::objectmodel::BaseObjectDescription *)> OnCreateCallback
 Main class used to register and dynamically create objects. More...
 
template<class T >
using sptr = boost::intrusive_ptr< T >
 
typedef TVecId< V_ALL, V_READConstVecId
 
typedef TVecId< V_ALL, V_WRITEVecId
 
typedef TVecId< V_COORD, V_READConstVecCoordId
 Typedefs for each type of state vectors. More...
 
typedef TVecId< V_COORD, V_WRITEVecCoordId
 
typedef TVecId< V_DERIV, V_READConstVecDerivId
 
typedef TVecId< V_DERIV, V_WRITEVecDerivId
 
typedef TVecId< V_MATDERIV, V_READConstMatrixDerivId
 
typedef TVecId< V_MATDERIV, V_WRITEMatrixDerivId
 
template<class DataTypes , core::VecType vtype>
using StateType_t = typename StateType< DataTypes, vtype >::type
 
template<class DataTypes , core::VecType vtype>
using StateVecType_t = typename StateVecType< DataTypes, vtype >::type
 

Enumerations

enum class  ConstraintOrder { POS = 0 , VEL , ACC , POS_AND_VEL }
 Description of the order of the constraint. More...
 
enum  { SOFA_DATA_MAX_ASPECTS = 1 }
 
enum  VecType { V_ALL = 0 , V_COORD , V_DERIV , V_MATDERIV }
 Types of vectors that can be stored in State. More...
 
enum  VecAccess { V_READ =0 , V_WRITE }
 Types of vectors that can be stored in State. More...
 

Functions

std::string caseInsensitive (const std::string &text)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::BaseState)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::BaseMapping)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::BehaviorModel)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::CollisionModel)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::objectmodel::BaseObject)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::objectmodel::ContextObject)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::objectmodel::ConfigurationSetting)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::behavior::BaseAnimationLoop)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::behavior::BaseMass)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::behavior::OdeSolver)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::behavior::ConstraintSolver)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::behavior::BaseLinearSolver)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::behavior::BaseMechanicalState)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::behavior::BaseForceField)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::behavior::BaseInteractionForceField)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::behavior::BaseProjectiveConstraintSet)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::behavior::BaseConstraintSet)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::topology::Topology)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::topology::BaseMeshTopology)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::topology::BaseTopologyObject)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::collision::Pipeline)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::visual::VisualLoop)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::visual::Shader)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::visual::VisualModel)
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::core::visual::VisualManager)
 
template<class Source >
sofa::core::objectmodel::BasecastToBase (Source *b)
 Dynamic cast from the type parameter B* into Base*. More...
 
template<class Dest >
Dest castTo (sofa::core::objectmodel::Base *base)
 Dynamic cast from Base* into the type parameter Dest. More...
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::BaseState)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::BaseMapping)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::BehaviorModel)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::CollisionModel)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::objectmodel::BaseObject)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::objectmodel::ContextObject)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::objectmodel::ConfigurationSetting)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::behavior::BaseAnimationLoop)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::behavior::BaseMass)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::behavior::OdeSolver)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::behavior::ConstraintSolver)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::behavior::BaseLinearSolver)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::behavior::BaseMechanicalState)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::behavior::BaseForceField)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::behavior::BaseInteractionForceField)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::behavior::BaseProjectiveConstraintSet)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::behavior::BaseConstraintSet)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::topology::Topology)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::topology::BaseMeshTopology)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::topology::BaseTopologyObject)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::collision::Pipeline)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::visual::VisualLoop)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::visual::Shader)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::visual::VisualModel)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::core::visual::VisualManager)
 
SOFA_CORE_API void init ()
 Initialize the SofaCore library, as well as its dependencies: SofaDefaultType, SofaHelper. More...
 
SOFA_CORE_API bool isInitialized ()
 Return true if and only if the SofaCore library has been initialized. More...
 
SOFA_CORE_API void cleanup ()
 Clean up the resources used by the SofaCore library, as well as its dependencies: SofaDefaultType, SofaHelper. More...
 
SOFA_CORE_API bool isCleanedUp ()
 Return true if and only if the SofaCore library has been cleaned up. More...
 
 SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::simulation::Node)
 
 SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::simulation::Node)
 

Variables

template class SOFA_CORE_API Multi2Mapping< Vec1Types, Rigid3Types, Rigid3Types >
 
template class SOFA_CORE_API Multi2Mapping< Vec3Types, Rigid3Types, Vec3Types >
 
template class SOFA_CORE_API Multi2Mapping< Vec3Types, Rigid3Types, Rigid3Types >
 
template class SOFA_CORE_API Multi2Mapping< Vec3Types, Vec3Types, Vec3Types >
 
template class SOFA_CORE_API Multi2Mapping< Vec3Types, Vec1Types, Vec3Types >
 
template class SOFA_CORE_API Multi2Mapping< Vec1Types, Vec3Types, Rigid3Types >
 
template class SOFA_CORE_API Multi2Mapping< Vec1Types, Rigid3Types, Vec3Types >
 
template class SOFA_CORE_API Multi2Mapping< Vec1Types, Vec1Types, Rigid3Types >
 
class SOFA_CORE_API BaseState
 
template class SOFA_CORE_API State< Vec3dTypes >
 
template class SOFA_CORE_API State< Vec2Types >
 
template class SOFA_CORE_API State< Vec1Types >
 
template class SOFA_CORE_API State< Vec6Types >
 
template class SOFA_CORE_API State< Rigid3Types >
 
template class SOFA_CORE_API State< Rigid2Types >
 
template class SOFA_CORE_API State< Vec3fTypes >
 
SOFA_CORE_API const std::unordered_map< VecType, std::string > VecTypeLabels
 
template<class DataTypes , core::VecType vtype>
constexpr sofa::Size StateTypeSize_v = StateTypeSize<DataTypes, vtype>::total_size
 

Typedef Documentation

◆ ClassEntry

◆ ConstMatrixDerivId

◆ ConstMultiMatrixDerivId

◆ ConstMultiVecCoordId

◆ ConstMultiVecDerivId

◆ ConstMultiVecId

◆ ConstVecCoordId

Typedefs for each type of state vectors.

◆ ConstVecDerivId

◆ ConstVecId

Identify one vector stored in State A ConstVecId only provides a read-only access to the underlying vector.

◆ Creator

◆ get_base_object_strong_type

template<matrixaccumulator::Contribution c>
using sofa::core::get_base_object_strong_type = typedef typename get_base_object_strong<c>::type

Helper alias.

◆ MatrixDerivId

◆ MultiMatrixDerivId

◆ MultiVecCoordId

◆ MultiVecDerivId

◆ MultiVecId

◆ OnCreateCallback

Main class used to register and dynamically create objects.

It uses the Factory design pattern, where each class is registered in a map, and dynamically retrieved given the type name.

It also stores metainformation on each classes, such as description, authors, license, and available template types.

See also
RegisterObject for how new classes should be registered.

◆ sptr

template<class T >
using sofa::core::sptr = typedef boost::intrusive_ptr<T>

◆ StateType_t

template<class DataTypes , core::VecType vtype>
using sofa::core::StateType_t = typedef typename StateType<DataTypes, vtype>::type

◆ StateVecType_t

template<class DataTypes , core::VecType vtype>
using sofa::core::StateVecType_t = typedef typename StateVecType<DataTypes, vtype>::type

◆ VecCoordId

◆ VecDerivId

◆ VecId

Identify one vector stored in State A VecId provides a read-write access to the underlying vector.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
SOFA_DATA_MAX_ASPECTS 

◆ ConstraintOrder

Description of the order of the constraint.

Enumerator
POS 
VEL 
ACC 
POS_AND_VEL 

◆ VecAccess

Types of vectors that can be stored in State.

Enumerator
V_READ 
V_WRITE 

◆ VecType

Types of vectors that can be stored in State.

Enumerator
V_ALL 
V_COORD 
V_DERIV 
V_MATDERIV 

Function Documentation

◆ caseInsensitive()

std::string sofa::core::caseInsensitive ( const std::string &  text)

◆ castTo()

template<class Dest >
Dest sofa::core::castTo ( sofa::core::objectmodel::Base base)

Dynamic cast from Base* into the type parameter Dest.

◆ castToBase()

template<class Source >
sofa::core::objectmodel::Base* sofa::core::castToBase ( Source *  b)

Dynamic cast from the type parameter B* into Base*.

CORE::OPAQUE FUNCTION /////////////////////////////////////////////////

CORE::OPAQUE function are a groupe of function that make "opaque" some of the common sofa behaviors.

Core::Opaque functions are:

These functions are called "opaque" as they work with only forward declaration of the involved types in comparison to class methods the requires the full class declaration to be used.

It is highly recommanded to use as much as possible opaque function in header files as this allow to reduce the dependency tree.

Opaque function may be slower at runtime (by one function call) but this is true only if LTO isn't able to optimize them properly. If you have experience/feedback with LTO please join the discussion in https://github.com/sofa-framework/sofa/discussions/1822 Defines the baseline functions for a type all the types in-herit from Base. These are non-opaque function that needs to be specialized in order to implement an opaque version for a given type.

◆ cleanup()

SOFA_CORE_API void sofa::core::cleanup ( )

Clean up the resources used by the SofaCore library, as well as its dependencies: SofaDefaultType, SofaHelper.

◆ init()

SOFA_CORE_API void sofa::core::init ( )

Initialize the SofaCore library, as well as its dependencies: SofaDefaultType, SofaHelper.

◆ isCleanedUp()

SOFA_CORE_API bool sofa::core::isCleanedUp ( )

Return true if and only if the SofaCore library has been cleaned up.

◆ isInitialized()

SOFA_CORE_API bool sofa::core::isInitialized ( )

Return true if and only if the SofaCore library has been initialized.

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [1/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::BaseMapping  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [2/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::BaseState  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [3/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::behavior::BaseAnimationLoop  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [4/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::behavior::BaseConstraintSet  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [5/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::behavior::BaseForceField  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [6/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::behavior::BaseInteractionForceField  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [7/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::behavior::BaseLinearSolver  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [8/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::behavior::BaseMass  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [9/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::behavior::BaseMechanicalState  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [10/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::behavior::BaseProjectiveConstraintSet  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [11/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::behavior::ConstraintSolver  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [12/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::behavior::OdeSolver  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [13/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::BehaviorModel  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [14/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::collision::Pipeline  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [15/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::CollisionModel  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [16/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::objectmodel::BaseObject  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [17/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::objectmodel::ConfigurationSetting  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [18/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::objectmodel::ContextObject  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [19/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::topology::BaseMeshTopology  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [20/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::topology::BaseTopologyObject  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [21/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::topology::Topology  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [22/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::visual::Shader  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [23/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::visual::VisualLoop  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [24/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::visual::VisualManager  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [25/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::core::visual::VisualModel  )

◆ SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND() [26/26]

sofa::core::SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND ( sofa::simulation::Node  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [1/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::BaseMapping  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [2/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::BaseState  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [3/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::behavior::BaseAnimationLoop  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [4/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::behavior::BaseConstraintSet  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [5/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::behavior::BaseForceField  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [6/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::behavior::BaseInteractionForceField  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [7/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::behavior::BaseLinearSolver  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [8/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::behavior::BaseMass  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [9/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::behavior::BaseMechanicalState  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [10/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::behavior::BaseProjectiveConstraintSet  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [11/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::behavior::ConstraintSolver  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [12/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::behavior::OdeSolver  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [13/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::BehaviorModel  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [14/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::collision::Pipeline  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [15/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::CollisionModel  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [16/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::objectmodel::BaseObject  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [17/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::objectmodel::ConfigurationSetting  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [18/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::objectmodel::ContextObject  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [19/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::topology::BaseMeshTopology  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [20/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::topology::BaseTopologyObject  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [21/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::topology::Topology  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [22/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::visual::Shader  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [23/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::visual::VisualLoop  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [24/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::visual::VisualManager  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [25/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::core::visual::VisualModel  )

◆ SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND() [26/26]

sofa::core::SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND ( sofa::simulation::Node  )

Variable Documentation

◆ BaseState

class SOFA_CORE_API sofa::core::BaseState

◆ Multi2Mapping< Vec1Types, Rigid3Types, Rigid3Types >

template class SOFA_CORE_API sofa::core::Multi2Mapping< Vec1Types, Rigid3Types, Rigid3Types >

◆ Multi2Mapping< Vec1Types, Rigid3Types, Vec3Types >

template class SOFA_CORE_API sofa::core::Multi2Mapping< Vec1Types, Rigid3Types, Vec3Types >

◆ Multi2Mapping< Vec1Types, Vec1Types, Rigid3Types >

template class SOFA_CORE_API sofa::core::Multi2Mapping< Vec1Types, Vec1Types, Rigid3Types >

◆ Multi2Mapping< Vec1Types, Vec3Types, Rigid3Types >

template class SOFA_CORE_API sofa::core::Multi2Mapping< Vec1Types, Vec3Types, Rigid3Types >

◆ Multi2Mapping< Vec3Types, Rigid3Types, Rigid3Types >

template class SOFA_CORE_API sofa::core::Multi2Mapping< Vec3Types, Rigid3Types, Rigid3Types >

◆ Multi2Mapping< Vec3Types, Rigid3Types, Vec3Types >

template class SOFA_CORE_API sofa::core::Multi2Mapping< Vec3Types, Rigid3Types, Vec3Types >

◆ Multi2Mapping< Vec3Types, Vec1Types, Vec3Types >

template class SOFA_CORE_API sofa::core::Multi2Mapping< Vec3Types, Vec1Types, Vec3Types >

◆ Multi2Mapping< Vec3Types, Vec3Types, Vec3Types >

template class SOFA_CORE_API sofa::core::Multi2Mapping< Vec3Types, Vec3Types, Vec3Types >

◆ State< Rigid2Types >

template class SOFA_CORE_API sofa::core::State< Rigid2Types >

◆ State< Rigid3Types >

template class SOFA_CORE_API sofa::core::State< Rigid3Types >

◆ State< Vec1Types >

template class SOFA_CORE_API sofa::core::State< Vec1Types >

◆ State< Vec2Types >

template class SOFA_CORE_API sofa::core::State< Vec2Types >

◆ State< Vec3dTypes >

template class SOFA_CORE_API sofa::core::State< Vec3dTypes >

◆ State< Vec3fTypes >

template class SOFA_CORE_API sofa::core::State< Vec3fTypes >

◆ State< Vec6Types >

template class SOFA_CORE_API sofa::core::State< Vec6Types >

◆ StateTypeSize_v

template<class DataTypes , core::VecType vtype>
constexpr sofa::Size sofa::core::StateTypeSize_v = StateTypeSize<DataTypes, vtype>::total_size
inlineconstexpr

◆ VecTypeLabels

SOFA_CORE_API const std::unordered_map< VecType, std::string > sofa::core::VecTypeLabels
Initial value:
{
{V_ALL, "(V_ALL)"},
{V_COORD, "(V_COORD)"},
{V_DERIV, "(V_DERIV)"},
{V_MATDERIV, "(V_MATDERIV)"}
}
@ V_DERIV
Definition: VecId.h:39
@ V_MATDERIV
Definition: VecId.h:40
@ V_ALL
Definition: VecId.h:37
@ V_COORD
Definition: VecId.h:38