|
| 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 | 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...
|
| |
| struct | MatricesFactors |
| |
| 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 > |
| |
| struct | ObjectRegistrationEntry |
| |
| class | ObjectFactory |
| |
| class | ObjectCreator |
| | Typed Creator class used to create instances of object type RealObject. More...
|
| |
| class | ObjectRegistrationData |
| | Helper class used to register a class in the ObjectFactory. More...
|
| |
| struct | ObjectFactoryJson |
| |
| 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 | StateType< DataTypes, core::V_MATDERIV > |
| |
| 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 > |
| |
|
| 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_READ > | ConstMultiVecCoordId |
| |
| typedef TMultiVecId< V_COORD, V_WRITE > | MultiVecCoordId |
| |
| typedef TMultiVecId< V_DERIV, V_READ > | ConstMultiVecDerivId |
| |
| typedef TMultiVecId< V_DERIV, V_WRITE > | MultiVecDerivId |
| |
| typedef TMultiVecId< V_MATDERIV, V_READ > | ConstMultiMatrixDerivId |
| |
| typedef TMultiVecId< V_MATDERIV, V_WRITE > | MultiMatrixDerivId |
| |
| typedef TMultiVecId< V_ALL, V_READ > | ConstMultiVecId |
| |
| typedef TMultiVecId< V_ALL, V_WRITE > | MultiVecId |
| |
| typedef struct sofa::core::ObjectRegistrationEntry | ObjectRegistrationEntry |
| |
| typedef std::function< void(sofa::core::objectmodel::Base *, sofa::core::objectmodel::BaseObjectDescription *)> | OnCreateCallback |
| |
| template<class T > |
| using | sptr = boost::intrusive_ptr< T > |
| |
| typedef TVecId< V_ALL, V_READ > | ConstVecId |
| |
| typedef TVecId< V_ALL, V_WRITE > | VecId |
| |
| typedef TVecId< V_COORD, V_READ > | ConstVecCoordId |
| | Typedefs for each type of state vectors. More...
|
| |
| typedef TVecId< V_COORD, V_WRITE > | VecCoordId |
| |
| typedef TVecId< V_DERIV, V_READ > | ConstVecDerivId |
| |
| typedef TVecId< V_DERIV, V_WRITE > | VecDerivId |
| |
| typedef TVecId< V_MATDERIV, V_READ > | ConstMatrixDerivId |
| |
| typedef TVecId< V_MATDERIV, V_WRITE > | MatrixDerivId |
| |
| 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 |
| |
|
| 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 class | VecType : uint8_t { V_ALL = 0
, V_COORD
, V_DERIV
, V_MATDERIV
} |
| | Types of vectors that can be stored in State. More...
|
| |
| enum class | VecAccess : uint8_t { V_READ =0
, V_WRITE
} |
| | Types of vectors that can be stored in State. More...
|
| |
| enum class | CoordState : uint8_t {
NULL_STATE
, POSITION
, REST_POSITION
, FREE_POSITION
,
RESET_POSITION
, DYNAMIC_INDEX
} |
| |
| enum class | DerivState : uint8_t {
NULL_STATE
, VELOCITY
, RESET_VELOCITY
, FREE_VELOCITY
,
NORMAL
, FORCE
, EXTERNAL_FORCE
, DX
,
DFORCE
, DYNAMIC_INDEX
} |
| |
| enum class | MatrixDerivState : uint8_t { NULL_STATE
, CONSTRAINT_JACOBIAN
, MAPPING_JACOBIAN
, DYNAMIC_INDEX
} |
| |
|
| 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::Base * | castToBase (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...
|
| |
| void | findTemplatedCreator (objectmodel::BaseContext *context, const ObjectFactory::Creator::SPtr &creator, const std::string &templateName, std::map< std::string, std::vector< std::string >> &creatorsErrors, std::vector< std::pair< std::string, ObjectFactory::Creator::SPtr > > &creators, objectmodel::BaseObjectDescription *arg) |
| |
| class | SOFA_ATTRIBUTE_DEPRECATED__REGISTEROBJECT () SOFA_CORE_API RegisterObject |
| |
| void | to_json (nlohmann::json &json, const sofa::core::ObjectFactory::Creator::SPtr &creator) |
| |
| void | to_json (nlohmann::json &json, const sofa::core::ObjectFactory::ClassEntry::SPtr &entry) |
| |
| std::ostream & | operator<< (std::ostream &out, const VecType &v) |
| |
| | SOFA_DEFINE_OPAQUE_FUNCTIONS_BETWEEN_BASE_AND (sofa::simulation::Node) |
| |
| | SOFA_DECLARE_OPAQUE_FUNCTION_BETWEEN_BASE_AND (sofa::simulation::Node) |
| |
|
| 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 |
| |
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 recommended 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.
1.9.1