agx-openplx 0.15.22__cp39-cp39-macosx_12_0_arm64.whl → 0.16.1__cp39-cp39-macosx_12_0_arm64.whl

openplx/Robotics.py

@@ -11432,19 +11432,19 @@ class Robotics_Signals_SensorValues_Vector(object):
 # Register Robotics_Signals_SensorValues_Vector in _RoboticsSwig:
 _RoboticsSwig.Robotics_Signals_SensorValues_Vector_swigregister(Robotics_Signals_SensorValues_Vector)
 
-class EndEffectors_VacuumSystem(openplx.Core.Object):
+class Robotics_EndEffectors_VacuumSystem(openplx.Core.Object):
     r"""Proxy of C++ openplx::Robotics::EndEffectors::VacuumSystem class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(EndEffectors_VacuumSystem self) -> EndEffectors_VacuumSystem"""
-        _RoboticsSwig.EndEffectors_VacuumSystem_swiginit(self, _RoboticsSwig.new_EndEffectors_VacuumSystem())
+        r"""__init__(Robotics_EndEffectors_VacuumSystem self) -> Robotics_EndEffectors_VacuumSystem"""
+        _RoboticsSwig.Robotics_EndEffectors_VacuumSystem_swiginit(self, _RoboticsSwig.new_Robotics_EndEffectors_VacuumSystem())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(EndEffectors_VacuumSystem self, std::string const & key, Any value)
+        setDynamic(Robotics_EndEffectors_VacuumSystem self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -11452,22 +11452,22 @@ class EndEffectors_VacuumSystem(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumSystem_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumSystem_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(EndEffectors_VacuumSystem self, std::string const & key) -> Any
+        getDynamic(Robotics_EndEffectors_VacuumSystem self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumSystem_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumSystem_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(EndEffectors_VacuumSystem self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_EndEffectors_VacuumSystem self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -11475,62 +11475,62 @@ class EndEffectors_VacuumSystem(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumSystem_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumSystem_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(EndEffectors_VacuumSystem self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_EndEffectors_VacuumSystem self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumSystem_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumSystem_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(EndEffectors_VacuumSystem self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_EndEffectors_VacuumSystem self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumSystem_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumSystem_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(EndEffectors_VacuumSystem self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_EndEffectors_VacuumSystem self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumSystem_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_EndEffectors_VacuumSystem
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumSystem_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_EndEffectors_VacuumSystem
 
-# Register EndEffectors_VacuumSystem in _RoboticsSwig:
-_RoboticsSwig.EndEffectors_VacuumSystem_swigregister(EndEffectors_VacuumSystem)
+# Register Robotics_EndEffectors_VacuumSystem in _RoboticsSwig:
+_RoboticsSwig.Robotics_EndEffectors_VacuumSystem_swigregister(Robotics_EndEffectors_VacuumSystem)
 
-class EndEffectors_ConstantVacuumSystem(EndEffectors_VacuumSystem):
+class Robotics_EndEffectors_ConstantVacuumSystem(Robotics_EndEffectors_VacuumSystem):
     r"""Proxy of C++ openplx::Robotics::EndEffectors::ConstantVacuumSystem class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(EndEffectors_ConstantVacuumSystem self) -> EndEffectors_ConstantVacuumSystem"""
-        _RoboticsSwig.EndEffectors_ConstantVacuumSystem_swiginit(self, _RoboticsSwig.new_EndEffectors_ConstantVacuumSystem())
+        r"""__init__(Robotics_EndEffectors_ConstantVacuumSystem self) -> Robotics_EndEffectors_ConstantVacuumSystem"""
+        _RoboticsSwig.Robotics_EndEffectors_ConstantVacuumSystem_swiginit(self, _RoboticsSwig.new_Robotics_EndEffectors_ConstantVacuumSystem())
 
     def vacuum_level(self):
-        r"""vacuum_level(EndEffectors_ConstantVacuumSystem self) -> double"""
-        return _RoboticsSwig.EndEffectors_ConstantVacuumSystem_vacuum_level(self)
+        r"""vacuum_level(Robotics_EndEffectors_ConstantVacuumSystem self) -> double"""
+        return _RoboticsSwig.Robotics_EndEffectors_ConstantVacuumSystem_vacuum_level(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(EndEffectors_ConstantVacuumSystem self, std::string const & key, Any value)
+        setDynamic(Robotics_EndEffectors_ConstantVacuumSystem self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -11538,22 +11538,22 @@ class EndEffectors_ConstantVacuumSystem(EndEffectors_VacuumSystem):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.EndEffectors_ConstantVacuumSystem_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_EndEffectors_ConstantVacuumSystem_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(EndEffectors_ConstantVacuumSystem self, std::string const & key) -> Any
+        getDynamic(Robotics_EndEffectors_ConstantVacuumSystem self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.EndEffectors_ConstantVacuumSystem_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_EndEffectors_ConstantVacuumSystem_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(EndEffectors_ConstantVacuumSystem self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_EndEffectors_ConstantVacuumSystem self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -11561,98 +11561,98 @@ class EndEffectors_ConstantVacuumSystem(EndEffectors_VacuumSystem):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.EndEffectors_ConstantVacuumSystem_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_EndEffectors_ConstantVacuumSystem_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(EndEffectors_ConstantVacuumSystem self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_EndEffectors_ConstantVacuumSystem self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_ConstantVacuumSystem_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_ConstantVacuumSystem_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(EndEffectors_ConstantVacuumSystem self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_EndEffectors_ConstantVacuumSystem self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_ConstantVacuumSystem_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_ConstantVacuumSystem_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(EndEffectors_ConstantVacuumSystem self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_EndEffectors_ConstantVacuumSystem self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.EndEffectors_ConstantVacuumSystem_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_EndEffectors_ConstantVacuumSystem
+        return _RoboticsSwig.Robotics_EndEffectors_ConstantVacuumSystem_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_EndEffectors_ConstantVacuumSystem
 
-# Register EndEffectors_ConstantVacuumSystem in _RoboticsSwig:
-_RoboticsSwig.EndEffectors_ConstantVacuumSystem_swigregister(EndEffectors_ConstantVacuumSystem)
+# Register Robotics_EndEffectors_ConstantVacuumSystem in _RoboticsSwig:
+_RoboticsSwig.Robotics_EndEffectors_ConstantVacuumSystem_swigregister(Robotics_EndEffectors_ConstantVacuumSystem)
 
-class EndEffectors_SuctionCup(openplx.Physics3D.StructuralComponent):
+class Robotics_EndEffectors_SuctionCup(openplx.Physics3D.Physics3D_StructuralComponent):
     r"""Proxy of C++ openplx::Robotics::EndEffectors::SuctionCup class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(EndEffectors_SuctionCup self) -> EndEffectors_SuctionCup"""
-        _RoboticsSwig.EndEffectors_SuctionCup_swiginit(self, _RoboticsSwig.new_EndEffectors_SuctionCup())
+        r"""__init__(Robotics_EndEffectors_SuctionCup self) -> Robotics_EndEffectors_SuctionCup"""
+        _RoboticsSwig.Robotics_EndEffectors_SuctionCup_swiginit(self, _RoboticsSwig.new_Robotics_EndEffectors_SuctionCup())
 
     def body(self):
-        r"""body(EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Physics3D::Bodies::RigidBody >"""
-        return _RoboticsSwig.EndEffectors_SuctionCup_body(self)
+        r"""body(Robotics_EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Physics3D::Bodies::RigidBody >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_body(self)
 
     def lip_radius(self):
-        r"""lip_radius(EndEffectors_SuctionCup self) -> double"""
-        return _RoboticsSwig.EndEffectors_SuctionCup_lip_radius(self)
+        r"""lip_radius(Robotics_EndEffectors_SuctionCup self) -> double"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_lip_radius(self)
 
     def mounting_radius(self):
-        r"""mounting_radius(EndEffectors_SuctionCup self) -> double"""
-        return _RoboticsSwig.EndEffectors_SuctionCup_mounting_radius(self)
+        r"""mounting_radius(Robotics_EndEffectors_SuctionCup self) -> double"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_mounting_radius(self)
 
     def resting_height(self):
-        r"""resting_height(EndEffectors_SuctionCup self) -> double"""
-        return _RoboticsSwig.EndEffectors_SuctionCup_resting_height(self)
+        r"""resting_height(Robotics_EndEffectors_SuctionCup self) -> double"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_resting_height(self)
 
     def collapsed_height(self):
-        r"""collapsed_height(EndEffectors_SuctionCup self) -> double"""
-        return _RoboticsSwig.EndEffectors_SuctionCup_collapsed_height(self)
+        r"""collapsed_height(Robotics_EndEffectors_SuctionCup self) -> double"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_collapsed_height(self)
 
     def lip_normal(self):
-        r"""lip_normal(EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Math::Vec3 >"""
-        return _RoboticsSwig.EndEffectors_SuctionCup_lip_normal(self)
+        r"""lip_normal(Robotics_EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Math::Vec3 >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_lip_normal(self)
 
     def gripper_connector(self):
-        r"""gripper_connector(EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Physics3D::Charges::RedirectedMateConnector >"""
-        return _RoboticsSwig.EndEffectors_SuctionCup_gripper_connector(self)
+        r"""gripper_connector(Robotics_EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Physics3D::Charges::RedirectedMateConnector >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_gripper_connector(self)
 
     def resting_mounting_connector(self):
-        r"""resting_mounting_connector(EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Physics3D::Charges::RedirectedMateConnector >"""
-        return _RoboticsSwig.EndEffectors_SuctionCup_resting_mounting_connector(self)
+        r"""resting_mounting_connector(Robotics_EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Physics3D::Charges::RedirectedMateConnector >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_resting_mounting_connector(self)
 
     def collapsed_mounting_connector(self):
-        r"""collapsed_mounting_connector(EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Physics3D::Charges::RedirectedMateConnector >"""
-        return _RoboticsSwig.EndEffectors_SuctionCup_collapsed_mounting_connector(self)
+        r"""collapsed_mounting_connector(Robotics_EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Physics3D::Charges::RedirectedMateConnector >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_collapsed_mounting_connector(self)
 
     def object_connector(self):
-        r"""object_connector(EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Physics3D::Charges::RedirectedMateConnector >"""
-        return _RoboticsSwig.EndEffectors_SuctionCup_object_connector(self)
+        r"""object_connector(Robotics_EndEffectors_SuctionCup self) -> std::shared_ptr< openplx::Physics3D::Charges::RedirectedMateConnector >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_object_connector(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(EndEffectors_SuctionCup self, std::string const & key, Any value)
+        setDynamic(Robotics_EndEffectors_SuctionCup self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -11660,22 +11660,22 @@ class EndEffectors_SuctionCup(openplx.Physics3D.StructuralComponent):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCup_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(EndEffectors_SuctionCup self, std::string const & key) -> Any
+        getDynamic(Robotics_EndEffectors_SuctionCup self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCup_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(EndEffectors_SuctionCup self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_EndEffectors_SuctionCup self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -11683,86 +11683,86 @@ class EndEffectors_SuctionCup(openplx.Physics3D.StructuralComponent):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCup_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(EndEffectors_SuctionCup self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_EndEffectors_SuctionCup self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCup_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(EndEffectors_SuctionCup self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_EndEffectors_SuctionCup self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCup_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(EndEffectors_SuctionCup self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_EndEffectors_SuctionCup self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCup_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_EndEffectors_SuctionCup
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCup_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_EndEffectors_SuctionCup
 
-# Register EndEffectors_SuctionCup in _RoboticsSwig:
-_RoboticsSwig.EndEffectors_SuctionCup_swigregister(EndEffectors_SuctionCup)
+# Register Robotics_EndEffectors_SuctionCup in _RoboticsSwig:
+_RoboticsSwig.Robotics_EndEffectors_SuctionCup_swigregister(Robotics_EndEffectors_SuctionCup)
 
-class EndEffectors_SixDofSuctionCup(EndEffectors_SuctionCup):
+class Robotics_EndEffectors_SixDofSuctionCup(Robotics_EndEffectors_SuctionCup):
     r"""Proxy of C++ openplx::Robotics::EndEffectors::SixDofSuctionCup class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(EndEffectors_SixDofSuctionCup self) -> EndEffectors_SixDofSuctionCup"""
-        _RoboticsSwig.EndEffectors_SixDofSuctionCup_swiginit(self, _RoboticsSwig.new_EndEffectors_SixDofSuctionCup())
+        r"""__init__(Robotics_EndEffectors_SixDofSuctionCup self) -> Robotics_EndEffectors_SixDofSuctionCup"""
+        _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_swiginit(self, _RoboticsSwig.new_Robotics_EndEffectors_SixDofSuctionCup())
 
     def geometry(self):
-        r"""geometry(EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Physics3D::Charges::ExternalTriMeshGeometry >"""
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_geometry(self)
+        r"""geometry(Robotics_EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Physics3D::Charges::ExternalTriMeshGeometry >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_geometry(self)
 
     def local_geometry_axis(self):
-        r"""local_geometry_axis(EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Math::Vec3 >"""
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_local_geometry_axis(self)
+        r"""local_geometry_axis(Robotics_EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Math::Vec3 >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_local_geometry_axis(self)
 
     def holder_relative_position(self):
-        r"""holder_relative_position(EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Math::Vec3 >"""
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_holder_relative_position(self)
+        r"""holder_relative_position(Robotics_EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Math::Vec3 >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_holder_relative_position(self)
 
     def collapsed_elasto_dynamics(self):
-        r"""collapsed_elasto_dynamics(EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Robotics::EndEffectors::SuctionCupElastoDynamics >"""
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_collapsed_elasto_dynamics(self)
+        r"""collapsed_elasto_dynamics(Robotics_EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Robotics::EndEffectors::SuctionCupElastoDynamics >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_collapsed_elasto_dynamics(self)
 
     def resting_elasto_dynamics(self):
-        r"""resting_elasto_dynamics(EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Robotics::EndEffectors::SuctionCupElastoDynamics >"""
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_resting_elasto_dynamics(self)
+        r"""resting_elasto_dynamics(Robotics_EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Robotics::EndEffectors::SuctionCupElastoDynamics >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_resting_elasto_dynamics(self)
 
     def collapsed_joint(self):
-        r"""collapsed_joint(EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Robotics::EndEffectors::SixDofSuctionCupJoint >"""
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_collapsed_joint(self)
+        r"""collapsed_joint(Robotics_EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Robotics::EndEffectors::SixDofSuctionCupJoint >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_collapsed_joint(self)
 
     def resting_joint(self):
-        r"""resting_joint(EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Robotics::EndEffectors::SixDofSuctionCupJoint >"""
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_resting_joint(self)
+        r"""resting_joint(Robotics_EndEffectors_SixDofSuctionCup self) -> std::shared_ptr< openplx::Robotics::EndEffectors::SixDofSuctionCupJoint >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_resting_joint(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(EndEffectors_SixDofSuctionCup self, std::string const & key, Any value)
+        setDynamic(Robotics_EndEffectors_SixDofSuctionCup self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -11770,22 +11770,22 @@ class EndEffectors_SixDofSuctionCup(EndEffectors_SuctionCup):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(EndEffectors_SixDofSuctionCup self, std::string const & key) -> Any
+        getDynamic(Robotics_EndEffectors_SixDofSuctionCup self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(EndEffectors_SixDofSuctionCup self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_EndEffectors_SixDofSuctionCup self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -11793,66 +11793,66 @@ class EndEffectors_SixDofSuctionCup(EndEffectors_SuctionCup):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(EndEffectors_SixDofSuctionCup self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_EndEffectors_SixDofSuctionCup self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(EndEffectors_SixDofSuctionCup self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_EndEffectors_SixDofSuctionCup self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(EndEffectors_SixDofSuctionCup self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_EndEffectors_SixDofSuctionCup self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCup_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_EndEffectors_SixDofSuctionCup
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_EndEffectors_SixDofSuctionCup
 
-# Register EndEffectors_SixDofSuctionCup in _RoboticsSwig:
-_RoboticsSwig.EndEffectors_SixDofSuctionCup_swigregister(EndEffectors_SixDofSuctionCup)
+# Register Robotics_EndEffectors_SixDofSuctionCup in _RoboticsSwig:
+_RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCup_swigregister(Robotics_EndEffectors_SixDofSuctionCup)
 
-class EndEffectors_SixDofSuctionCupJoint(openplx.Physics3D.Interactions_Lock):
+class Robotics_EndEffectors_SixDofSuctionCupJoint(openplx.Physics3D.Physics3D_Interactions_Lock):
     r"""Proxy of C++ openplx::Robotics::EndEffectors::SixDofSuctionCupJoint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(EndEffectors_SixDofSuctionCupJoint self) -> EndEffectors_SixDofSuctionCupJoint"""
-        _RoboticsSwig.EndEffectors_SixDofSuctionCupJoint_swiginit(self, _RoboticsSwig.new_EndEffectors_SixDofSuctionCupJoint())
+        r"""__init__(Robotics_EndEffectors_SixDofSuctionCupJoint self) -> Robotics_EndEffectors_SixDofSuctionCupJoint"""
+        _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCupJoint_swiginit(self, _RoboticsSwig.new_Robotics_EndEffectors_SixDofSuctionCupJoint())
 
     def flexibility(self):
-        r"""flexibility(EndEffectors_SixDofSuctionCupJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Flexibility::LinearElasticLockFlexibility >"""
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCupJoint_flexibility(self)
+        r"""flexibility(Robotics_EndEffectors_SixDofSuctionCupJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Flexibility::LinearElasticLockFlexibility >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCupJoint_flexibility(self)
 
     def dissipation(self):
-        r"""dissipation(EndEffectors_SixDofSuctionCupJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Dissipation::LockMechanicalDamping >"""
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCupJoint_dissipation(self)
+        r"""dissipation(Robotics_EndEffectors_SixDofSuctionCupJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Dissipation::LockMechanicalDamping >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCupJoint_dissipation(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(EndEffectors_SixDofSuctionCupJoint self, std::string const & key, Any value)
+        setDynamic(Robotics_EndEffectors_SixDofSuctionCupJoint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -11860,22 +11860,22 @@ class EndEffectors_SixDofSuctionCupJoint(openplx.Physics3D.Interactions_Lock):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCupJoint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCupJoint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(EndEffectors_SixDofSuctionCupJoint self, std::string const & key) -> Any
+        getDynamic(Robotics_EndEffectors_SixDofSuctionCupJoint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCupJoint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCupJoint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(EndEffectors_SixDofSuctionCupJoint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_EndEffectors_SixDofSuctionCupJoint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -11883,90 +11883,90 @@ class EndEffectors_SixDofSuctionCupJoint(openplx.Physics3D.Interactions_Lock):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCupJoint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCupJoint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(EndEffectors_SixDofSuctionCupJoint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_EndEffectors_SixDofSuctionCupJoint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCupJoint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCupJoint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(EndEffectors_SixDofSuctionCupJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_EndEffectors_SixDofSuctionCupJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCupJoint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCupJoint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(EndEffectors_SixDofSuctionCupJoint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_EndEffectors_SixDofSuctionCupJoint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.EndEffectors_SixDofSuctionCupJoint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_EndEffectors_SixDofSuctionCupJoint
+        return _RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCupJoint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_EndEffectors_SixDofSuctionCupJoint
 
-# Register EndEffectors_SixDofSuctionCupJoint in _RoboticsSwig:
-_RoboticsSwig.EndEffectors_SixDofSuctionCupJoint_swigregister(EndEffectors_SixDofSuctionCupJoint)
+# Register Robotics_EndEffectors_SixDofSuctionCupJoint in _RoboticsSwig:
+_RoboticsSwig.Robotics_EndEffectors_SixDofSuctionCupJoint_swigregister(Robotics_EndEffectors_SixDofSuctionCupJoint)
 
-class EndEffectors_SuctionCupElastoDynamics(openplx.Core.Object):
+class Robotics_EndEffectors_SuctionCupElastoDynamics(openplx.Core.Object):
     r"""Proxy of C++ openplx::Robotics::EndEffectors::SuctionCupElastoDynamics class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(EndEffectors_SuctionCupElastoDynamics self) -> EndEffectors_SuctionCupElastoDynamics"""
-        _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_swiginit(self, _RoboticsSwig.new_EndEffectors_SuctionCupElastoDynamics())
+        r"""__init__(Robotics_EndEffectors_SuctionCupElastoDynamics self) -> Robotics_EndEffectors_SuctionCupElastoDynamics"""
+        _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_swiginit(self, _RoboticsSwig.new_Robotics_EndEffectors_SuctionCupElastoDynamics())
 
     def lip_normal_flexibility(self):
-        r"""lip_normal_flexibility(EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::LinearElastic >"""
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_lip_normal_flexibility(self)
+        r"""lip_normal_flexibility(Robotics_EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::LinearElastic >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_lip_normal_flexibility(self)
 
     def radial_axis_flexibility(self):
-        r"""radial_axis_flexibility(EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::LinearElastic >"""
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_radial_axis_flexibility(self)
+        r"""radial_axis_flexibility(Robotics_EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::LinearElastic >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_radial_axis_flexibility(self)
 
     def around_lip_normal_flexibility(self):
-        r"""around_lip_normal_flexibility(EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::LinearElastic >"""
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_around_lip_normal_flexibility(self)
+        r"""around_lip_normal_flexibility(Robotics_EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::LinearElastic >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_around_lip_normal_flexibility(self)
 
     def around_radial_axis_flexibility(self):
-        r"""around_radial_axis_flexibility(EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::LinearElastic >"""
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_around_radial_axis_flexibility(self)
+        r"""around_radial_axis_flexibility(Robotics_EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::LinearElastic >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_around_radial_axis_flexibility(self)
 
     def lip_normal_dissipation(self):
-        r"""lip_normal_dissipation(EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::MechanicalDamping >"""
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_lip_normal_dissipation(self)
+        r"""lip_normal_dissipation(Robotics_EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::MechanicalDamping >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_lip_normal_dissipation(self)
 
     def radial_axis_dissipation(self):
-        r"""radial_axis_dissipation(EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::MechanicalDamping >"""
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_radial_axis_dissipation(self)
+        r"""radial_axis_dissipation(Robotics_EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::MechanicalDamping >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_radial_axis_dissipation(self)
 
     def around_lip_normal_dissipation(self):
-        r"""around_lip_normal_dissipation(EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::MechanicalDamping >"""
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_around_lip_normal_dissipation(self)
+        r"""around_lip_normal_dissipation(Robotics_EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::MechanicalDamping >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_around_lip_normal_dissipation(self)
 
     def around_radial_axis_dissipation(self):
-        r"""around_radial_axis_dissipation(EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::MechanicalDamping >"""
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_around_radial_axis_dissipation(self)
+        r"""around_radial_axis_dissipation(Robotics_EndEffectors_SuctionCupElastoDynamics self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::MechanicalDamping >"""
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_around_radial_axis_dissipation(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(EndEffectors_SuctionCupElastoDynamics self, std::string const & key, Any value)
+        setDynamic(Robotics_EndEffectors_SuctionCupElastoDynamics self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -11974,22 +11974,22 @@ class EndEffectors_SuctionCupElastoDynamics(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(EndEffectors_SuctionCupElastoDynamics self, std::string const & key) -> Any
+        getDynamic(Robotics_EndEffectors_SuctionCupElastoDynamics self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(EndEffectors_SuctionCupElastoDynamics self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_EndEffectors_SuctionCupElastoDynamics self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -11997,78 +11997,78 @@ class EndEffectors_SuctionCupElastoDynamics(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(EndEffectors_SuctionCupElastoDynamics self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_EndEffectors_SuctionCupElastoDynamics self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(EndEffectors_SuctionCupElastoDynamics self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_EndEffectors_SuctionCupElastoDynamics self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(EndEffectors_SuctionCupElastoDynamics self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_EndEffectors_SuctionCupElastoDynamics self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_EndEffectors_SuctionCupElastoDynamics
+        return _RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_EndEffectors_SuctionCupElastoDynamics
 
-# Register EndEffectors_SuctionCupElastoDynamics in _RoboticsSwig:
-_RoboticsSwig.EndEffectors_SuctionCupElastoDynamics_swigregister(EndEffectors_SuctionCupElastoDynamics)
+# Register Robotics_EndEffectors_SuctionCupElastoDynamics in _RoboticsSwig:
+_RoboticsSwig.Robotics_EndEffectors_SuctionCupElastoDynamics_swigregister(Robotics_EndEffectors_SuctionCupElastoDynamics)
 
-class EndEffectors_VacuumGripper(openplx.Core.Object, openplx.Physics.BoolInputTrait, openplx.Physics.BoolOutputTrait):
+class Robotics_EndEffectors_VacuumGripper(openplx.Core.Object, openplx.Physics.BoolInputTrait, openplx.Physics.BoolOutputTrait):
     r"""Proxy of C++ openplx::Robotics::EndEffectors::VacuumGripper class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(EndEffectors_VacuumGripper self) -> EndEffectors_VacuumGripper"""
-        _RoboticsSwig.EndEffectors_VacuumGripper_swiginit(self, _RoboticsSwig.new_EndEffectors_VacuumGripper())
+        r"""__init__(Robotics_EndEffectors_VacuumGripper self) -> Robotics_EndEffectors_VacuumGripper"""
+        _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_swiginit(self, _RoboticsSwig.new_Robotics_EndEffectors_VacuumGripper())
 
     def activated(self):
-        r"""activated(EndEffectors_VacuumGripper self) -> bool"""
-        return _RoboticsSwig.EndEffectors_VacuumGripper_activated(self)
+        r"""activated(Robotics_EndEffectors_VacuumGripper self) -> bool"""
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_activated(self)
 
     def suction_cups(self):
-        r"""suction_cups(EndEffectors_VacuumGripper self) -> Robotics_EndEffectors_SuctionCup_Vector"""
-        return _RoboticsSwig.EndEffectors_VacuumGripper_suction_cups(self)
+        r"""suction_cups(Robotics_EndEffectors_VacuumGripper self) -> Robotics_EndEffectors_SuctionCup_Vector"""
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_suction_cups(self)
 
     def vacuum_system(self):
-        r"""vacuum_system(EndEffectors_VacuumGripper self) -> std::shared_ptr< openplx::Robotics::EndEffectors::VacuumSystem >"""
-        return _RoboticsSwig.EndEffectors_VacuumGripper_vacuum_system(self)
+        r"""vacuum_system(Robotics_EndEffectors_VacuumGripper self) -> std::shared_ptr< openplx::Robotics::EndEffectors::VacuumSystem >"""
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_vacuum_system(self)
 
     def activate_input(self):
-        r"""activate_input(EndEffectors_VacuumGripper self) -> std::shared_ptr< openplx::Physics::Signals::ActivateInput >"""
-        return _RoboticsSwig.EndEffectors_VacuumGripper_activate_input(self)
+        r"""activate_input(Robotics_EndEffectors_VacuumGripper self) -> std::shared_ptr< openplx::Physics::Signals::ActivateInput >"""
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_activate_input(self)
 
     def activated_output(self):
-        r"""activated_output(EndEffectors_VacuumGripper self) -> std::shared_ptr< openplx::Physics::Signals::ActivatedOutput >"""
-        return _RoboticsSwig.EndEffectors_VacuumGripper_activated_output(self)
+        r"""activated_output(Robotics_EndEffectors_VacuumGripper self) -> std::shared_ptr< openplx::Physics::Signals::ActivatedOutput >"""
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_activated_output(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(EndEffectors_VacuumGripper self, std::string const & key, Any value)
+        setDynamic(Robotics_EndEffectors_VacuumGripper self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -12076,22 +12076,22 @@ class EndEffectors_VacuumGripper(openplx.Core.Object, openplx.Physics.BoolInputT
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumGripper_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(EndEffectors_VacuumGripper self, std::string const & key) -> Any
+        getDynamic(Robotics_EndEffectors_VacuumGripper self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumGripper_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(EndEffectors_VacuumGripper self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_EndEffectors_VacuumGripper self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -12099,66 +12099,66 @@ class EndEffectors_VacuumGripper(openplx.Core.Object, openplx.Physics.BoolInputT
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumGripper_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(EndEffectors_VacuumGripper self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_EndEffectors_VacuumGripper self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumGripper_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(EndEffectors_VacuumGripper self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_EndEffectors_VacuumGripper self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumGripper_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(EndEffectors_VacuumGripper self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_EndEffectors_VacuumGripper self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.EndEffectors_VacuumGripper_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_EndEffectors_VacuumGripper
+        return _RoboticsSwig.Robotics_EndEffectors_VacuumGripper_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_EndEffectors_VacuumGripper
 
-# Register EndEffectors_VacuumGripper in _RoboticsSwig:
-_RoboticsSwig.EndEffectors_VacuumGripper_swigregister(EndEffectors_VacuumGripper)
+# Register Robotics_EndEffectors_VacuumGripper in _RoboticsSwig:
+_RoboticsSwig.Robotics_EndEffectors_VacuumGripper_swigregister(Robotics_EndEffectors_VacuumGripper)
 
-class Joints_Joint(openplx.Physics3D.System):
+class Robotics_Joints_Joint(openplx.Physics3D.Physics3D_System):
     r"""Proxy of C++ openplx::Robotics::Joints::Joint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_Joint self) -> Joints_Joint"""
-        _RoboticsSwig.Joints_Joint_swiginit(self, _RoboticsSwig.new_Joints_Joint())
+        r"""__init__(Robotics_Joints_Joint self) -> Robotics_Joints_Joint"""
+        _RoboticsSwig.Robotics_Joints_Joint_swiginit(self, _RoboticsSwig.new_Robotics_Joints_Joint())
 
     def mate(self):
-        r"""mate(Joints_Joint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Mate >"""
-        return _RoboticsSwig.Joints_Joint_mate(self)
+        r"""mate(Robotics_Joints_Joint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Mate >"""
+        return _RoboticsSwig.Robotics_Joints_Joint_mate(self)
 
     def links(self):
-        r"""links(Joints_Joint self) -> Robotics_Links_RigidLink_Vector"""
-        return _RoboticsSwig.Joints_Joint_links(self)
+        r"""links(Robotics_Joints_Joint self) -> Robotics_Links_RigidLink_Vector"""
+        return _RoboticsSwig.Robotics_Joints_Joint_links(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_Joint self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_Joint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -12166,22 +12166,22 @@ class Joints_Joint(openplx.Physics3D.System):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_Joint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_Joint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_Joint self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_Joint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_Joint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_Joint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_Joint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_Joint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -12189,62 +12189,62 @@ class Joints_Joint(openplx.Physics3D.System):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_Joint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_Joint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_Joint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_Joint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_Joint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_Joint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_Joint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_Joint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_Joint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_Joint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_Joint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_Joint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_Joint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_Joint
+        return _RoboticsSwig.Robotics_Joints_Joint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_Joint
 
-# Register Joints_Joint in _RoboticsSwig:
-_RoboticsSwig.Joints_Joint_swigregister(Joints_Joint)
+# Register Robotics_Joints_Joint in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_Joint_swigregister(Robotics_Joints_Joint)
 
-class Joints_ActuatedJoint(Joints_Joint):
+class Robotics_Joints_ActuatedJoint(Robotics_Joints_Joint):
     r"""Proxy of C++ openplx::Robotics::Joints::ActuatedJoint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_ActuatedJoint self) -> Joints_ActuatedJoint"""
-        _RoboticsSwig.Joints_ActuatedJoint_swiginit(self, _RoboticsSwig.new_Joints_ActuatedJoint())
+        r"""__init__(Robotics_Joints_ActuatedJoint self) -> Robotics_Joints_ActuatedJoint"""
+        _RoboticsSwig.Robotics_Joints_ActuatedJoint_swiginit(self, _RoboticsSwig.new_Robotics_Joints_ActuatedJoint())
 
     def actuator(self):
-        r"""actuator(Joints_ActuatedJoint self) -> std::shared_ptr< openplx::Physics::Interactions::Interaction1DOF >"""
-        return _RoboticsSwig.Joints_ActuatedJoint_actuator(self)
+        r"""actuator(Robotics_Joints_ActuatedJoint self) -> std::shared_ptr< openplx::Physics::Interactions::Interaction1DOF >"""
+        return _RoboticsSwig.Robotics_Joints_ActuatedJoint_actuator(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_ActuatedJoint self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_ActuatedJoint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -12252,22 +12252,22 @@ class Joints_ActuatedJoint(Joints_Joint):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_ActuatedJoint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_ActuatedJoint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_ActuatedJoint self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_ActuatedJoint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_ActuatedJoint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_ActuatedJoint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_ActuatedJoint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_ActuatedJoint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -12275,74 +12275,74 @@ class Joints_ActuatedJoint(Joints_Joint):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_ActuatedJoint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_ActuatedJoint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_ActuatedJoint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_ActuatedJoint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_ActuatedJoint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_ActuatedJoint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_ActuatedJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_ActuatedJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_ActuatedJoint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_ActuatedJoint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_ActuatedJoint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_ActuatedJoint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_ActuatedJoint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_ActuatedJoint
+        return _RoboticsSwig.Robotics_Joints_ActuatedJoint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_ActuatedJoint
 
-# Register Joints_ActuatedJoint in _RoboticsSwig:
-_RoboticsSwig.Joints_ActuatedJoint_swigregister(Joints_ActuatedJoint)
+# Register Robotics_Joints_ActuatedJoint in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_ActuatedJoint_swigregister(Robotics_Joints_ActuatedJoint)
 
-class Joints_CoupledJointDriveTrain(openplx.Physics3D.System):
+class Robotics_Joints_CoupledJointDriveTrain(openplx.Physics3D.Physics3D_System):
     r"""Proxy of C++ openplx::Robotics::Joints::CoupledJointDriveTrain class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_CoupledJointDriveTrain self) -> Joints_CoupledJointDriveTrain"""
-        _RoboticsSwig.Joints_CoupledJointDriveTrain_swiginit(self, _RoboticsSwig.new_Joints_CoupledJointDriveTrain())
+        r"""__init__(Robotics_Joints_CoupledJointDriveTrain self) -> Robotics_Joints_CoupledJointDriveTrain"""
+        _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_swiginit(self, _RoboticsSwig.new_Robotics_Joints_CoupledJointDriveTrain())
 
     def shaft(self):
-        r"""shaft(Joints_CoupledJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
-        return _RoboticsSwig.Joints_CoupledJointDriveTrain_shaft(self)
+        r"""shaft(Robotics_Joints_CoupledJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
+        return _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_shaft(self)
 
     def sensor(self):
-        r"""sensor(Joints_CoupledJointDriveTrain self) -> std::shared_ptr< openplx::Robotics::Signals::Sensor >"""
-        return _RoboticsSwig.Joints_CoupledJointDriveTrain_sensor(self)
+        r"""sensor(Robotics_Joints_CoupledJointDriveTrain self) -> std::shared_ptr< openplx::Robotics::Signals::Sensor >"""
+        return _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_sensor(self)
 
     def primary_actuator(self):
-        r"""primary_actuator(Joints_CoupledJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Actuator >"""
-        return _RoboticsSwig.Joints_CoupledJointDriveTrain_primary_actuator(self)
+        r"""primary_actuator(Robotics_Joints_CoupledJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Actuator >"""
+        return _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_primary_actuator(self)
 
     def mimic_actuator(self):
-        r"""mimic_actuator(Joints_CoupledJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Actuator >"""
-        return _RoboticsSwig.Joints_CoupledJointDriveTrain_mimic_actuator(self)
+        r"""mimic_actuator(Robotics_Joints_CoupledJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Actuator >"""
+        return _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_mimic_actuator(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_CoupledJointDriveTrain self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_CoupledJointDriveTrain self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -12350,22 +12350,22 @@ class Joints_CoupledJointDriveTrain(openplx.Physics3D.System):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_CoupledJointDriveTrain_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_CoupledJointDriveTrain self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_CoupledJointDriveTrain self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_CoupledJointDriveTrain_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_CoupledJointDriveTrain self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_CoupledJointDriveTrain self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -12373,62 +12373,62 @@ class Joints_CoupledJointDriveTrain(openplx.Physics3D.System):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_CoupledJointDriveTrain_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_CoupledJointDriveTrain self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_CoupledJointDriveTrain self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_CoupledJointDriveTrain_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_CoupledJointDriveTrain self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_CoupledJointDriveTrain self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_CoupledJointDriveTrain_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_CoupledJointDriveTrain self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_CoupledJointDriveTrain self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_CoupledJointDriveTrain_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_CoupledJointDriveTrain
+        return _RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_CoupledJointDriveTrain
 
-# Register Joints_CoupledJointDriveTrain in _RoboticsSwig:
-_RoboticsSwig.Joints_CoupledJointDriveTrain_swigregister(Joints_CoupledJointDriveTrain)
+# Register Robotics_Joints_CoupledJointDriveTrain in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_CoupledJointDriveTrain_swigregister(Robotics_Joints_CoupledJointDriveTrain)
 
-class Joints_FixedJoint(Joints_Joint):
+class Robotics_Joints_FixedJoint(Robotics_Joints_Joint):
     r"""Proxy of C++ openplx::Robotics::Joints::FixedJoint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_FixedJoint self) -> Joints_FixedJoint"""
-        _RoboticsSwig.Joints_FixedJoint_swiginit(self, _RoboticsSwig.new_Joints_FixedJoint())
+        r"""__init__(Robotics_Joints_FixedJoint self) -> Robotics_Joints_FixedJoint"""
+        _RoboticsSwig.Robotics_Joints_FixedJoint_swiginit(self, _RoboticsSwig.new_Robotics_Joints_FixedJoint())
 
     def mate(self):
-        r"""mate(Joints_FixedJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Lock >"""
-        return _RoboticsSwig.Joints_FixedJoint_mate(self)
+        r"""mate(Robotics_Joints_FixedJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Lock >"""
+        return _RoboticsSwig.Robotics_Joints_FixedJoint_mate(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_FixedJoint self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_FixedJoint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -12436,22 +12436,22 @@ class Joints_FixedJoint(Joints_Joint):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_FixedJoint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_FixedJoint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_FixedJoint self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_FixedJoint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_FixedJoint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_FixedJoint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_FixedJoint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_FixedJoint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -12459,66 +12459,66 @@ class Joints_FixedJoint(Joints_Joint):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_FixedJoint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_FixedJoint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_FixedJoint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_FixedJoint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_FixedJoint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_FixedJoint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_FixedJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_FixedJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_FixedJoint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_FixedJoint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_FixedJoint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_FixedJoint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_FixedJoint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_FixedJoint
+        return _RoboticsSwig.Robotics_Joints_FixedJoint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_FixedJoint
 
-# Register Joints_FixedJoint in _RoboticsSwig:
-_RoboticsSwig.Joints_FixedJoint_swigregister(Joints_FixedJoint)
+# Register Robotics_Joints_FixedJoint in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_FixedJoint_swigregister(Robotics_Joints_FixedJoint)
 
-class Joints_HingeJoint(Joints_ActuatedJoint):
+class Robotics_Joints_HingeJoint(Robotics_Joints_ActuatedJoint):
     r"""Proxy of C++ openplx::Robotics::Joints::HingeJoint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_HingeJoint self) -> Joints_HingeJoint"""
-        _RoboticsSwig.Joints_HingeJoint_swiginit(self, _RoboticsSwig.new_Joints_HingeJoint())
+        r"""__init__(Robotics_Joints_HingeJoint self) -> Robotics_Joints_HingeJoint"""
+        _RoboticsSwig.Robotics_Joints_HingeJoint_swiginit(self, _RoboticsSwig.new_Robotics_Joints_HingeJoint())
 
     def mate(self):
-        r"""mate(Joints_HingeJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Hinge >"""
-        return _RoboticsSwig.Joints_HingeJoint_mate(self)
+        r"""mate(Robotics_Joints_HingeJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Hinge >"""
+        return _RoboticsSwig.Robotics_Joints_HingeJoint_mate(self)
 
     def range(self):
-        r"""range(Joints_HingeJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::RotationalRange >"""
-        return _RoboticsSwig.Joints_HingeJoint_range(self)
+        r"""range(Robotics_Joints_HingeJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::RotationalRange >"""
+        return _RoboticsSwig.Robotics_Joints_HingeJoint_range(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_HingeJoint self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_HingeJoint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -12526,22 +12526,22 @@ class Joints_HingeJoint(Joints_ActuatedJoint):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_HingeJoint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_HingeJoint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_HingeJoint self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_HingeJoint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_HingeJoint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_HingeJoint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_HingeJoint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_HingeJoint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -12549,44 +12549,44 @@ class Joints_HingeJoint(Joints_ActuatedJoint):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_HingeJoint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_HingeJoint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_HingeJoint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_HingeJoint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_HingeJoint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_HingeJoint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_HingeJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_HingeJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_HingeJoint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_HingeJoint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_HingeJoint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_HingeJoint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_HingeJoint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_HingeJoint
+        return _RoboticsSwig.Robotics_Joints_HingeJoint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_HingeJoint
 
-# Register Joints_HingeJoint in _RoboticsSwig:
-_RoboticsSwig.Joints_HingeJoint_swigregister(Joints_HingeJoint)
+# Register Robotics_Joints_HingeJoint in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_HingeJoint_swigregister(Robotics_Joints_HingeJoint)
 
 class FlexibleJointTrait(object):
     r"""Proxy of C++ openplx::Robotics::Joints::FlexibleJointTrait class."""
@@ -12605,27 +12605,27 @@ class FlexibleJointTrait(object):
 # Register FlexibleJointTrait in _RoboticsSwig:
 _RoboticsSwig.FlexibleJointTrait_swigregister(FlexibleJointTrait)
 
-class Joints_FlexibleAngularVelocityJoint(Joints_HingeJoint, FlexibleJointTrait):
+class Robotics_Joints_FlexibleAngularVelocityJoint(Robotics_Joints_HingeJoint, FlexibleJointTrait):
     r"""Proxy of C++ openplx::Robotics::Joints::FlexibleAngularVelocityJoint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_FlexibleAngularVelocityJoint self) -> Joints_FlexibleAngularVelocityJoint"""
-        _RoboticsSwig.Joints_FlexibleAngularVelocityJoint_swiginit(self, _RoboticsSwig.new_Joints_FlexibleAngularVelocityJoint())
+        r"""__init__(Robotics_Joints_FlexibleAngularVelocityJoint self) -> Robotics_Joints_FlexibleAngularVelocityJoint"""
+        _RoboticsSwig.Robotics_Joints_FlexibleAngularVelocityJoint_swiginit(self, _RoboticsSwig.new_Robotics_Joints_FlexibleAngularVelocityJoint())
 
     def drive_train(self):
-        r"""drive_train(Joints_FlexibleAngularVelocityJoint self) -> std::shared_ptr< openplx::Robotics::Joints::FlexibleJointDriveTrain >"""
-        return _RoboticsSwig.Joints_FlexibleAngularVelocityJoint_drive_train(self)
+        r"""drive_train(Robotics_Joints_FlexibleAngularVelocityJoint self) -> std::shared_ptr< openplx::Robotics::Joints::FlexibleJointDriveTrain >"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleAngularVelocityJoint_drive_train(self)
 
     def actuator(self):
-        r"""actuator(Joints_FlexibleAngularVelocityJoint self) -> std::shared_ptr< openplx::Physics1D::Interactions::RotationalVelocityMotor >"""
-        return _RoboticsSwig.Joints_FlexibleAngularVelocityJoint_actuator(self)
+        r"""actuator(Robotics_Joints_FlexibleAngularVelocityJoint self) -> std::shared_ptr< openplx::Physics1D::Interactions::RotationalVelocityMotor >"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleAngularVelocityJoint_actuator(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_FlexibleAngularVelocityJoint self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_FlexibleAngularVelocityJoint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -12633,22 +12633,22 @@ class Joints_FlexibleAngularVelocityJoint(Joints_HingeJoint, FlexibleJointTrait)
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_FlexibleAngularVelocityJoint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_FlexibleAngularVelocityJoint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_FlexibleAngularVelocityJoint self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_FlexibleAngularVelocityJoint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleAngularVelocityJoint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_FlexibleAngularVelocityJoint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_FlexibleAngularVelocityJoint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_FlexibleAngularVelocityJoint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -12656,58 +12656,58 @@ class Joints_FlexibleAngularVelocityJoint(Joints_HingeJoint, FlexibleJointTrait)
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleAngularVelocityJoint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_FlexibleAngularVelocityJoint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_FlexibleAngularVelocityJoint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_FlexibleAngularVelocityJoint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_FlexibleAngularVelocityJoint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_FlexibleAngularVelocityJoint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_FlexibleAngularVelocityJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_FlexibleAngularVelocityJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_FlexibleAngularVelocityJoint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_FlexibleAngularVelocityJoint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_FlexibleAngularVelocityJoint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_FlexibleAngularVelocityJoint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleAngularVelocityJoint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_FlexibleAngularVelocityJoint
+        return _RoboticsSwig.Robotics_Joints_FlexibleAngularVelocityJoint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_FlexibleAngularVelocityJoint
 
-# Register Joints_FlexibleAngularVelocityJoint in _RoboticsSwig:
-_RoboticsSwig.Joints_FlexibleAngularVelocityJoint_swigregister(Joints_FlexibleAngularVelocityJoint)
+# Register Robotics_Joints_FlexibleAngularVelocityJoint in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_FlexibleAngularVelocityJoint_swigregister(Robotics_Joints_FlexibleAngularVelocityJoint)
 
-class Joints_JointData(openplx.Core.Object):
+class Robotics_Joints_JointData(openplx.Core.Object):
     r"""Proxy of C++ openplx::Robotics::Joints::JointData class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_JointData self) -> Joints_JointData"""
-        _RoboticsSwig.Joints_JointData_swiginit(self, _RoboticsSwig.new_Joints_JointData())
+        r"""__init__(Robotics_Joints_JointData self) -> Robotics_Joints_JointData"""
+        _RoboticsSwig.Robotics_Joints_JointData_swiginit(self, _RoboticsSwig.new_Robotics_Joints_JointData())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_JointData self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_JointData self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -12715,22 +12715,22 @@ class Joints_JointData(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_JointData_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_JointData_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_JointData self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_JointData self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_JointData_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_JointData_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_JointData self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_JointData self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -12738,98 +12738,98 @@ class Joints_JointData(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_JointData_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_JointData_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_JointData self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_JointData self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_JointData_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_JointData_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_JointData self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_JointData self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_JointData_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_JointData_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_JointData self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_JointData self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_JointData_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_JointData
+        return _RoboticsSwig.Robotics_Joints_JointData_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_JointData
 
-# Register Joints_JointData in _RoboticsSwig:
-_RoboticsSwig.Joints_JointData_swigregister(Joints_JointData)
+# Register Robotics_Joints_JointData in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_JointData_swigregister(Robotics_Joints_JointData)
 
-class Joints_HingeJointData(Joints_JointData):
+class Robotics_Joints_HingeJointData(Robotics_Joints_JointData):
     r"""Proxy of C++ openplx::Robotics::Joints::HingeJointData class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_HingeJointData self) -> Joints_HingeJointData"""
-        _RoboticsSwig.Joints_HingeJointData_swiginit(self, _RoboticsSwig.new_Joints_HingeJointData())
+        r"""__init__(Robotics_Joints_HingeJointData self) -> Robotics_Joints_HingeJointData"""
+        _RoboticsSwig.Robotics_Joints_HingeJointData_swiginit(self, _RoboticsSwig.new_Robotics_Joints_HingeJointData())
 
     def stiffness_around_normal(self):
-        r"""stiffness_around_normal(Joints_HingeJointData self) -> double"""
-        return _RoboticsSwig.Joints_HingeJointData_stiffness_around_normal(self)
+        r"""stiffness_around_normal(Robotics_Joints_HingeJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_stiffness_around_normal(self)
 
     def stiffness_around_cross(self):
-        r"""stiffness_around_cross(Joints_HingeJointData self) -> double"""
-        return _RoboticsSwig.Joints_HingeJointData_stiffness_around_cross(self)
+        r"""stiffness_around_cross(Robotics_Joints_HingeJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_stiffness_around_cross(self)
 
     def stiffness_along_main(self):
-        r"""stiffness_along_main(Joints_HingeJointData self) -> double"""
-        return _RoboticsSwig.Joints_HingeJointData_stiffness_along_main(self)
+        r"""stiffness_along_main(Robotics_Joints_HingeJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_stiffness_along_main(self)
 
     def stiffness_along_normal(self):
-        r"""stiffness_along_normal(Joints_HingeJointData self) -> double"""
-        return _RoboticsSwig.Joints_HingeJointData_stiffness_along_normal(self)
+        r"""stiffness_along_normal(Robotics_Joints_HingeJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_stiffness_along_normal(self)
 
     def stiffness_along_cross(self):
-        r"""stiffness_along_cross(Joints_HingeJointData self) -> double"""
-        return _RoboticsSwig.Joints_HingeJointData_stiffness_along_cross(self)
+        r"""stiffness_along_cross(Robotics_Joints_HingeJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_stiffness_along_cross(self)
 
     def damping_around_normal(self):
-        r"""damping_around_normal(Joints_HingeJointData self) -> double"""
-        return _RoboticsSwig.Joints_HingeJointData_damping_around_normal(self)
+        r"""damping_around_normal(Robotics_Joints_HingeJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_damping_around_normal(self)
 
     def damping_around_cross(self):
-        r"""damping_around_cross(Joints_HingeJointData self) -> double"""
-        return _RoboticsSwig.Joints_HingeJointData_damping_around_cross(self)
+        r"""damping_around_cross(Robotics_Joints_HingeJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_damping_around_cross(self)
 
     def damping_along_main(self):
-        r"""damping_along_main(Joints_HingeJointData self) -> double"""
-        return _RoboticsSwig.Joints_HingeJointData_damping_along_main(self)
+        r"""damping_along_main(Robotics_Joints_HingeJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_damping_along_main(self)
 
     def damping_along_normal(self):
-        r"""damping_along_normal(Joints_HingeJointData self) -> double"""
-        return _RoboticsSwig.Joints_HingeJointData_damping_along_normal(self)
+        r"""damping_along_normal(Robotics_Joints_HingeJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_damping_along_normal(self)
 
     def damping_along_cross(self):
-        r"""damping_along_cross(Joints_HingeJointData self) -> double"""
-        return _RoboticsSwig.Joints_HingeJointData_damping_along_cross(self)
+        r"""damping_along_cross(Robotics_Joints_HingeJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_damping_along_cross(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_HingeJointData self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_HingeJointData self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -12837,22 +12837,22 @@ class Joints_HingeJointData(Joints_JointData):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_HingeJointData_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_HingeJointData self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_HingeJointData self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_HingeJointData_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_HingeJointData self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_HingeJointData self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -12860,82 +12860,82 @@ class Joints_HingeJointData(Joints_JointData):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_HingeJointData_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_HingeJointData self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_HingeJointData self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_HingeJointData_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_HingeJointData self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_HingeJointData self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_HingeJointData_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_HingeJointData self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_HingeJointData self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_HingeJointData_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_HingeJointData
+        return _RoboticsSwig.Robotics_Joints_HingeJointData_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_HingeJointData
 
-# Register Joints_HingeJointData in _RoboticsSwig:
-_RoboticsSwig.Joints_HingeJointData_swigregister(Joints_HingeJointData)
+# Register Robotics_Joints_HingeJointData in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_HingeJointData_swigregister(Robotics_Joints_HingeJointData)
 
-class Joints_FlexibleJointData(Joints_HingeJointData):
+class Robotics_Joints_FlexibleJointData(Robotics_Joints_HingeJointData):
     r"""Proxy of C++ openplx::Robotics::Joints::FlexibleJointData class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_FlexibleJointData self) -> Joints_FlexibleJointData"""
-        _RoboticsSwig.Joints_FlexibleJointData_swiginit(self, _RoboticsSwig.new_Joints_FlexibleJointData())
+        r"""__init__(Robotics_Joints_FlexibleJointData self) -> Robotics_Joints_FlexibleJointData"""
+        _RoboticsSwig.Robotics_Joints_FlexibleJointData_swiginit(self, _RoboticsSwig.new_Robotics_Joints_FlexibleJointData())
 
     def motor_damping(self):
-        r"""motor_damping(Joints_FlexibleJointData self) -> double"""
-        return _RoboticsSwig.Joints_FlexibleJointData_motor_damping(self)
+        r"""motor_damping(Robotics_Joints_FlexibleJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_motor_damping(self)
 
     def motor_inertia(self):
-        r"""motor_inertia(Joints_FlexibleJointData self) -> double"""
-        return _RoboticsSwig.Joints_FlexibleJointData_motor_inertia(self)
+        r"""motor_inertia(Robotics_Joints_FlexibleJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_motor_inertia(self)
 
     def motor_stiffness(self):
-        r"""motor_stiffness(Joints_FlexibleJointData self) -> double"""
-        return _RoboticsSwig.Joints_FlexibleJointData_motor_stiffness(self)
+        r"""motor_stiffness(Robotics_Joints_FlexibleJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_motor_stiffness(self)
 
     def gear_inertia(self):
-        r"""gear_inertia(Joints_FlexibleJointData self) -> double"""
-        return _RoboticsSwig.Joints_FlexibleJointData_gear_inertia(self)
+        r"""gear_inertia(Robotics_Joints_FlexibleJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_gear_inertia(self)
 
     def gear_ratio(self):
-        r"""gear_ratio(Joints_FlexibleJointData self) -> double"""
-        return _RoboticsSwig.Joints_FlexibleJointData_gear_ratio(self)
+        r"""gear_ratio(Robotics_Joints_FlexibleJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_gear_ratio(self)
 
     def max_motor_torque(self):
-        r"""max_motor_torque(Joints_FlexibleJointData self) -> double"""
-        return _RoboticsSwig.Joints_FlexibleJointData_max_motor_torque(self)
+        r"""max_motor_torque(Robotics_Joints_FlexibleJointData self) -> double"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_max_motor_torque(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_FlexibleJointData self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_FlexibleJointData self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -12943,22 +12943,22 @@ class Joints_FlexibleJointData(Joints_HingeJointData):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointData_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_FlexibleJointData self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_FlexibleJointData self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointData_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_FlexibleJointData self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_FlexibleJointData self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -12966,78 +12966,78 @@ class Joints_FlexibleJointData(Joints_HingeJointData):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointData_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_FlexibleJointData self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_FlexibleJointData self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointData_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_FlexibleJointData self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_FlexibleJointData self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointData_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_FlexibleJointData self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_FlexibleJointData self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointData_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_FlexibleJointData
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointData_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_FlexibleJointData
 
-# Register Joints_FlexibleJointData in _RoboticsSwig:
-_RoboticsSwig.Joints_FlexibleJointData_swigregister(Joints_FlexibleJointData)
+# Register Robotics_Joints_FlexibleJointData in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_FlexibleJointData_swigregister(Robotics_Joints_FlexibleJointData)
 
-class Joints_FlexibleJointDriveTrain(openplx.Physics3D.System):
+class Robotics_Joints_FlexibleJointDriveTrain(openplx.Physics3D.Physics3D_System):
     r"""Proxy of C++ openplx::Robotics::Joints::FlexibleJointDriveTrain class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_FlexibleJointDriveTrain self) -> Joints_FlexibleJointDriveTrain"""
-        _RoboticsSwig.Joints_FlexibleJointDriveTrain_swiginit(self, _RoboticsSwig.new_Joints_FlexibleJointDriveTrain())
+        r"""__init__(Robotics_Joints_FlexibleJointDriveTrain self) -> Robotics_Joints_FlexibleJointDriveTrain"""
+        _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_swiginit(self, _RoboticsSwig.new_Robotics_Joints_FlexibleJointDriveTrain())
 
     def motor_shaft(self):
-        r"""motor_shaft(Joints_FlexibleJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_motor_shaft(self)
+        r"""motor_shaft(Robotics_Joints_FlexibleJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_motor_shaft(self)
 
     def gear(self):
-        r"""gear(Joints_FlexibleJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Gear >"""
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_gear(self)
+        r"""gear(Robotics_Joints_FlexibleJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Gear >"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_gear(self)
 
     def gear_shaft(self):
-        r"""gear_shaft(Joints_FlexibleJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_gear_shaft(self)
+        r"""gear_shaft(Robotics_Joints_FlexibleJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_gear_shaft(self)
 
     def sensor(self):
-        r"""sensor(Joints_FlexibleJointDriveTrain self) -> std::shared_ptr< openplx::Robotics::Signals::Sensor >"""
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_sensor(self)
+        r"""sensor(Robotics_Joints_FlexibleJointDriveTrain self) -> std::shared_ptr< openplx::Robotics::Signals::Sensor >"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_sensor(self)
 
     def hinge_actuator(self):
-        r"""hinge_actuator(Joints_FlexibleJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::HingeActuator >"""
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_hinge_actuator(self)
+        r"""hinge_actuator(Robotics_Joints_FlexibleJointDriveTrain self) -> std::shared_ptr< openplx::DriveTrain::HingeActuator >"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_hinge_actuator(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_FlexibleJointDriveTrain self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_FlexibleJointDriveTrain self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13045,22 +13045,22 @@ class Joints_FlexibleJointDriveTrain(openplx.Physics3D.System):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_FlexibleJointDriveTrain self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_FlexibleJointDriveTrain self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_FlexibleJointDriveTrain self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_FlexibleJointDriveTrain self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13068,66 +13068,66 @@ class Joints_FlexibleJointDriveTrain(openplx.Physics3D.System):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_FlexibleJointDriveTrain self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_FlexibleJointDriveTrain self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_FlexibleJointDriveTrain self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_FlexibleJointDriveTrain self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_FlexibleJointDriveTrain self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_FlexibleJointDriveTrain self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleJointDriveTrain_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_FlexibleJointDriveTrain
+        return _RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_FlexibleJointDriveTrain
 
-# Register Joints_FlexibleJointDriveTrain in _RoboticsSwig:
-_RoboticsSwig.Joints_FlexibleJointDriveTrain_swigregister(Joints_FlexibleJointDriveTrain)
+# Register Robotics_Joints_FlexibleJointDriveTrain in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_FlexibleJointDriveTrain_swigregister(Robotics_Joints_FlexibleJointDriveTrain)
 
-class Joints_FlexibleTorqueJoint(Joints_HingeJoint, FlexibleJointTrait):
+class Robotics_Joints_FlexibleTorqueJoint(Robotics_Joints_HingeJoint, FlexibleJointTrait):
     r"""Proxy of C++ openplx::Robotics::Joints::FlexibleTorqueJoint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_FlexibleTorqueJoint self) -> Joints_FlexibleTorqueJoint"""
-        _RoboticsSwig.Joints_FlexibleTorqueJoint_swiginit(self, _RoboticsSwig.new_Joints_FlexibleTorqueJoint())
+        r"""__init__(Robotics_Joints_FlexibleTorqueJoint self) -> Robotics_Joints_FlexibleTorqueJoint"""
+        _RoboticsSwig.Robotics_Joints_FlexibleTorqueJoint_swiginit(self, _RoboticsSwig.new_Robotics_Joints_FlexibleTorqueJoint())
 
     def drive_train(self):
-        r"""drive_train(Joints_FlexibleTorqueJoint self) -> std::shared_ptr< openplx::Robotics::Joints::FlexibleJointDriveTrain >"""
-        return _RoboticsSwig.Joints_FlexibleTorqueJoint_drive_train(self)
+        r"""drive_train(Robotics_Joints_FlexibleTorqueJoint self) -> std::shared_ptr< openplx::Robotics::Joints::FlexibleJointDriveTrain >"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleTorqueJoint_drive_train(self)
 
     def actuator(self):
-        r"""actuator(Joints_FlexibleTorqueJoint self) -> std::shared_ptr< openplx::DriveTrain::TorqueMotor >"""
-        return _RoboticsSwig.Joints_FlexibleTorqueJoint_actuator(self)
+        r"""actuator(Robotics_Joints_FlexibleTorqueJoint self) -> std::shared_ptr< openplx::DriveTrain::TorqueMotor >"""
+        return _RoboticsSwig.Robotics_Joints_FlexibleTorqueJoint_actuator(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_FlexibleTorqueJoint self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_FlexibleTorqueJoint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13135,22 +13135,22 @@ class Joints_FlexibleTorqueJoint(Joints_HingeJoint, FlexibleJointTrait):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_FlexibleTorqueJoint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_FlexibleTorqueJoint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_FlexibleTorqueJoint self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_FlexibleTorqueJoint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleTorqueJoint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_FlexibleTorqueJoint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_FlexibleTorqueJoint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_FlexibleTorqueJoint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13158,62 +13158,62 @@ class Joints_FlexibleTorqueJoint(Joints_HingeJoint, FlexibleJointTrait):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleTorqueJoint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_FlexibleTorqueJoint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_FlexibleTorqueJoint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_FlexibleTorqueJoint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_FlexibleTorqueJoint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_FlexibleTorqueJoint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_FlexibleTorqueJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_FlexibleTorqueJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_FlexibleTorqueJoint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_FlexibleTorqueJoint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_FlexibleTorqueJoint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_FlexibleTorqueJoint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_FlexibleTorqueJoint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_FlexibleTorqueJoint
+        return _RoboticsSwig.Robotics_Joints_FlexibleTorqueJoint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_FlexibleTorqueJoint
 
-# Register Joints_FlexibleTorqueJoint in _RoboticsSwig:
-_RoboticsSwig.Joints_FlexibleTorqueJoint_swigregister(Joints_FlexibleTorqueJoint)
+# Register Robotics_Joints_FlexibleTorqueJoint in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_FlexibleTorqueJoint_swigregister(Robotics_Joints_FlexibleTorqueJoint)
 
-class Joints_PositionHingeJoint(Joints_HingeJoint):
+class Robotics_Joints_PositionHingeJoint(Robotics_Joints_HingeJoint):
     r"""Proxy of C++ openplx::Robotics::Joints::PositionHingeJoint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_PositionHingeJoint self) -> Joints_PositionHingeJoint"""
-        _RoboticsSwig.Joints_PositionHingeJoint_swiginit(self, _RoboticsSwig.new_Joints_PositionHingeJoint())
+        r"""__init__(Robotics_Joints_PositionHingeJoint self) -> Robotics_Joints_PositionHingeJoint"""
+        _RoboticsSwig.Robotics_Joints_PositionHingeJoint_swiginit(self, _RoboticsSwig.new_Robotics_Joints_PositionHingeJoint())
 
     def actuator(self):
-        r"""actuator(Joints_PositionHingeJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::TorsionSpring >"""
-        return _RoboticsSwig.Joints_PositionHingeJoint_actuator(self)
+        r"""actuator(Robotics_Joints_PositionHingeJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::TorsionSpring >"""
+        return _RoboticsSwig.Robotics_Joints_PositionHingeJoint_actuator(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_PositionHingeJoint self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_PositionHingeJoint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13221,22 +13221,22 @@ class Joints_PositionHingeJoint(Joints_HingeJoint):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_PositionHingeJoint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_PositionHingeJoint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_PositionHingeJoint self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_PositionHingeJoint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_PositionHingeJoint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_PositionHingeJoint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_PositionHingeJoint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_PositionHingeJoint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13244,66 +13244,66 @@ class Joints_PositionHingeJoint(Joints_HingeJoint):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_PositionHingeJoint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_PositionHingeJoint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_PositionHingeJoint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_PositionHingeJoint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_PositionHingeJoint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_PositionHingeJoint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_PositionHingeJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_PositionHingeJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_PositionHingeJoint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_PositionHingeJoint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_PositionHingeJoint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_PositionHingeJoint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_PositionHingeJoint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_PositionHingeJoint
+        return _RoboticsSwig.Robotics_Joints_PositionHingeJoint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_PositionHingeJoint
 
-# Register Joints_PositionHingeJoint in _RoboticsSwig:
-_RoboticsSwig.Joints_PositionHingeJoint_swigregister(Joints_PositionHingeJoint)
+# Register Robotics_Joints_PositionHingeJoint in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_PositionHingeJoint_swigregister(Robotics_Joints_PositionHingeJoint)
 
-class Joints_PrismaticJoint(Joints_ActuatedJoint):
+class Robotics_Joints_PrismaticJoint(Robotics_Joints_ActuatedJoint):
     r"""Proxy of C++ openplx::Robotics::Joints::PrismaticJoint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_PrismaticJoint self) -> Joints_PrismaticJoint"""
-        _RoboticsSwig.Joints_PrismaticJoint_swiginit(self, _RoboticsSwig.new_Joints_PrismaticJoint())
+        r"""__init__(Robotics_Joints_PrismaticJoint self) -> Robotics_Joints_PrismaticJoint"""
+        _RoboticsSwig.Robotics_Joints_PrismaticJoint_swiginit(self, _RoboticsSwig.new_Robotics_Joints_PrismaticJoint())
 
     def mate(self):
-        r"""mate(Joints_PrismaticJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Prismatic >"""
-        return _RoboticsSwig.Joints_PrismaticJoint_mate(self)
+        r"""mate(Robotics_Joints_PrismaticJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::Prismatic >"""
+        return _RoboticsSwig.Robotics_Joints_PrismaticJoint_mate(self)
 
     def range(self):
-        r"""range(Joints_PrismaticJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::LinearRange >"""
-        return _RoboticsSwig.Joints_PrismaticJoint_range(self)
+        r"""range(Robotics_Joints_PrismaticJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::LinearRange >"""
+        return _RoboticsSwig.Robotics_Joints_PrismaticJoint_range(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_PrismaticJoint self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_PrismaticJoint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13311,22 +13311,22 @@ class Joints_PrismaticJoint(Joints_ActuatedJoint):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_PrismaticJoint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_PrismaticJoint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_PrismaticJoint self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_PrismaticJoint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_PrismaticJoint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_PrismaticJoint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_PrismaticJoint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_PrismaticJoint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13334,62 +13334,62 @@ class Joints_PrismaticJoint(Joints_ActuatedJoint):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_PrismaticJoint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_PrismaticJoint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_PrismaticJoint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_PrismaticJoint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_PrismaticJoint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_PrismaticJoint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_PrismaticJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_PrismaticJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_PrismaticJoint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_PrismaticJoint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_PrismaticJoint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_PrismaticJoint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_PrismaticJoint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_PrismaticJoint
+        return _RoboticsSwig.Robotics_Joints_PrismaticJoint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_PrismaticJoint
 
-# Register Joints_PrismaticJoint in _RoboticsSwig:
-_RoboticsSwig.Joints_PrismaticJoint_swigregister(Joints_PrismaticJoint)
+# Register Robotics_Joints_PrismaticJoint in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_PrismaticJoint_swigregister(Robotics_Joints_PrismaticJoint)
 
-class Joints_TorqueHingeJoint(Joints_HingeJoint):
+class Robotics_Joints_TorqueHingeJoint(Robotics_Joints_HingeJoint):
     r"""Proxy of C++ openplx::Robotics::Joints::TorqueHingeJoint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_TorqueHingeJoint self) -> Joints_TorqueHingeJoint"""
-        _RoboticsSwig.Joints_TorqueHingeJoint_swiginit(self, _RoboticsSwig.new_Joints_TorqueHingeJoint())
+        r"""__init__(Robotics_Joints_TorqueHingeJoint self) -> Robotics_Joints_TorqueHingeJoint"""
+        _RoboticsSwig.Robotics_Joints_TorqueHingeJoint_swiginit(self, _RoboticsSwig.new_Robotics_Joints_TorqueHingeJoint())
 
     def actuator(self):
-        r"""actuator(Joints_TorqueHingeJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::TorqueMotor >"""
-        return _RoboticsSwig.Joints_TorqueHingeJoint_actuator(self)
+        r"""actuator(Robotics_Joints_TorqueHingeJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::TorqueMotor >"""
+        return _RoboticsSwig.Robotics_Joints_TorqueHingeJoint_actuator(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_TorqueHingeJoint self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_TorqueHingeJoint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13397,22 +13397,22 @@ class Joints_TorqueHingeJoint(Joints_HingeJoint):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_TorqueHingeJoint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_TorqueHingeJoint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_TorqueHingeJoint self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_TorqueHingeJoint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_TorqueHingeJoint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_TorqueHingeJoint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_TorqueHingeJoint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_TorqueHingeJoint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13420,62 +13420,62 @@ class Joints_TorqueHingeJoint(Joints_HingeJoint):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_TorqueHingeJoint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_TorqueHingeJoint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_TorqueHingeJoint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_TorqueHingeJoint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_TorqueHingeJoint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_TorqueHingeJoint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_TorqueHingeJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_TorqueHingeJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_TorqueHingeJoint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_TorqueHingeJoint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_TorqueHingeJoint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_TorqueHingeJoint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_TorqueHingeJoint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_TorqueHingeJoint
+        return _RoboticsSwig.Robotics_Joints_TorqueHingeJoint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_TorqueHingeJoint
 
-# Register Joints_TorqueHingeJoint in _RoboticsSwig:
-_RoboticsSwig.Joints_TorqueHingeJoint_swigregister(Joints_TorqueHingeJoint)
+# Register Robotics_Joints_TorqueHingeJoint in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_TorqueHingeJoint_swigregister(Robotics_Joints_TorqueHingeJoint)
 
-class Joints_VelocityHingeJoint(Joints_HingeJoint):
+class Robotics_Joints_VelocityHingeJoint(Robotics_Joints_HingeJoint):
     r"""Proxy of C++ openplx::Robotics::Joints::VelocityHingeJoint class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Joints_VelocityHingeJoint self) -> Joints_VelocityHingeJoint"""
-        _RoboticsSwig.Joints_VelocityHingeJoint_swiginit(self, _RoboticsSwig.new_Joints_VelocityHingeJoint())
+        r"""__init__(Robotics_Joints_VelocityHingeJoint self) -> Robotics_Joints_VelocityHingeJoint"""
+        _RoboticsSwig.Robotics_Joints_VelocityHingeJoint_swiginit(self, _RoboticsSwig.new_Robotics_Joints_VelocityHingeJoint())
 
     def actuator(self):
-        r"""actuator(Joints_VelocityHingeJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::RotationalVelocityMotor >"""
-        return _RoboticsSwig.Joints_VelocityHingeJoint_actuator(self)
+        r"""actuator(Robotics_Joints_VelocityHingeJoint self) -> std::shared_ptr< openplx::Physics3D::Interactions::RotationalVelocityMotor >"""
+        return _RoboticsSwig.Robotics_Joints_VelocityHingeJoint_actuator(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Joints_VelocityHingeJoint self, std::string const & key, Any value)
+        setDynamic(Robotics_Joints_VelocityHingeJoint self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13483,22 +13483,22 @@ class Joints_VelocityHingeJoint(Joints_HingeJoint):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Joints_VelocityHingeJoint_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Joints_VelocityHingeJoint_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Joints_VelocityHingeJoint self, std::string const & key) -> Any
+        getDynamic(Robotics_Joints_VelocityHingeJoint self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Joints_VelocityHingeJoint_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Joints_VelocityHingeJoint_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Joints_VelocityHingeJoint self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Joints_VelocityHingeJoint self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13506,86 +13506,86 @@ class Joints_VelocityHingeJoint(Joints_HingeJoint):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Joints_VelocityHingeJoint_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Joints_VelocityHingeJoint_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Joints_VelocityHingeJoint self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Joints_VelocityHingeJoint self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Joints_VelocityHingeJoint_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_VelocityHingeJoint_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Joints_VelocityHingeJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Joints_VelocityHingeJoint self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Joints_VelocityHingeJoint_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Joints_VelocityHingeJoint_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Joints_VelocityHingeJoint self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Joints_VelocityHingeJoint self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Joints_VelocityHingeJoint_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Joints_VelocityHingeJoint
+        return _RoboticsSwig.Robotics_Joints_VelocityHingeJoint_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Joints_VelocityHingeJoint
 
-# Register Joints_VelocityHingeJoint in _RoboticsSwig:
-_RoboticsSwig.Joints_VelocityHingeJoint_swigregister(Joints_VelocityHingeJoint)
+# Register Robotics_Joints_VelocityHingeJoint in _RoboticsSwig:
+_RoboticsSwig.Robotics_Joints_VelocityHingeJoint_swigregister(Robotics_Joints_VelocityHingeJoint)
 
-class Links_LinkData(openplx.Core.Object):
+class Robotics_Links_LinkData(openplx.Core.Object):
     r"""Proxy of C++ openplx::Robotics::Links::LinkData class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Links_LinkData self) -> Links_LinkData"""
-        _RoboticsSwig.Links_LinkData_swiginit(self, _RoboticsSwig.new_Links_LinkData())
+        r"""__init__(Robotics_Links_LinkData self) -> Robotics_Links_LinkData"""
+        _RoboticsSwig.Robotics_Links_LinkData_swiginit(self, _RoboticsSwig.new_Robotics_Links_LinkData())
 
     def inertia(self):
-        r"""inertia(Links_LinkData self) -> std::shared_ptr< openplx::Physics3D::Bodies::Inertia >"""
-        return _RoboticsSwig.Links_LinkData_inertia(self)
+        r"""inertia(Robotics_Links_LinkData self) -> std::shared_ptr< openplx::Physics3D::Bodies::Inertia >"""
+        return _RoboticsSwig.Robotics_Links_LinkData_inertia(self)
 
     def start_position(self):
-        r"""start_position(Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
-        return _RoboticsSwig.Links_LinkData_start_position(self)
+        r"""start_position(Robotics_Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
+        return _RoboticsSwig.Robotics_Links_LinkData_start_position(self)
 
     def start_main_axis(self):
-        r"""start_main_axis(Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
-        return _RoboticsSwig.Links_LinkData_start_main_axis(self)
+        r"""start_main_axis(Robotics_Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
+        return _RoboticsSwig.Robotics_Links_LinkData_start_main_axis(self)
 
     def start_normal(self):
-        r"""start_normal(Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
-        return _RoboticsSwig.Links_LinkData_start_normal(self)
+        r"""start_normal(Robotics_Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
+        return _RoboticsSwig.Robotics_Links_LinkData_start_normal(self)
 
     def end_position(self):
-        r"""end_position(Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
-        return _RoboticsSwig.Links_LinkData_end_position(self)
+        r"""end_position(Robotics_Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
+        return _RoboticsSwig.Robotics_Links_LinkData_end_position(self)
 
     def end_main_axis(self):
-        r"""end_main_axis(Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
-        return _RoboticsSwig.Links_LinkData_end_main_axis(self)
+        r"""end_main_axis(Robotics_Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
+        return _RoboticsSwig.Robotics_Links_LinkData_end_main_axis(self)
 
     def end_normal(self):
-        r"""end_normal(Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
-        return _RoboticsSwig.Links_LinkData_end_normal(self)
+        r"""end_normal(Robotics_Links_LinkData self) -> std::shared_ptr< openplx::Math::Vec3 >"""
+        return _RoboticsSwig.Robotics_Links_LinkData_end_normal(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Links_LinkData self, std::string const & key, Any value)
+        setDynamic(Robotics_Links_LinkData self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13593,22 +13593,22 @@ class Links_LinkData(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Links_LinkData_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Links_LinkData_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Links_LinkData self, std::string const & key) -> Any
+        getDynamic(Robotics_Links_LinkData self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Links_LinkData_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Links_LinkData_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Links_LinkData self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Links_LinkData self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13616,70 +13616,70 @@ class Links_LinkData(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Links_LinkData_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Links_LinkData_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Links_LinkData self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Links_LinkData self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Links_LinkData_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Links_LinkData_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Links_LinkData self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Links_LinkData self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Links_LinkData_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Links_LinkData_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Links_LinkData self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Links_LinkData self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Links_LinkData_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Links_LinkData
+        return _RoboticsSwig.Robotics_Links_LinkData_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Links_LinkData
 
-# Register Links_LinkData in _RoboticsSwig:
-_RoboticsSwig.Links_LinkData_swigregister(Links_LinkData)
+# Register Robotics_Links_LinkData in _RoboticsSwig:
+_RoboticsSwig.Robotics_Links_LinkData_swigregister(Robotics_Links_LinkData)
 
-class Links_RigidLink(openplx.Physics3D.Bodies_RigidBody):
+class Robotics_Links_RigidLink(openplx.Physics3D.Physics3D_Bodies_RigidBody):
     r"""Proxy of C++ openplx::Robotics::Links::RigidLink class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Links_RigidLink self) -> Links_RigidLink"""
-        _RoboticsSwig.Links_RigidLink_swiginit(self, _RoboticsSwig.new_Links_RigidLink())
+        r"""__init__(Robotics_Links_RigidLink self) -> Robotics_Links_RigidLink"""
+        _RoboticsSwig.Robotics_Links_RigidLink_swiginit(self, _RoboticsSwig.new_Robotics_Links_RigidLink())
 
     def start(self):
-        r"""start(Links_RigidLink self) -> std::shared_ptr< openplx::Physics3D::Charges::MateConnector >"""
-        return _RoboticsSwig.Links_RigidLink_start(self)
+        r"""start(Robotics_Links_RigidLink self) -> std::shared_ptr< openplx::Physics3D::Charges::MateConnector >"""
+        return _RoboticsSwig.Robotics_Links_RigidLink_start(self)
 
     def end(self):
-        r"""end(Links_RigidLink self) -> std::shared_ptr< openplx::Physics3D::Charges::MateConnector >"""
-        return _RoboticsSwig.Links_RigidLink_end(self)
+        r"""end(Robotics_Links_RigidLink self) -> std::shared_ptr< openplx::Physics3D::Charges::MateConnector >"""
+        return _RoboticsSwig.Robotics_Links_RigidLink_end(self)
 
     def contact_geometry(self):
-        r"""contact_geometry(Links_RigidLink self) -> std::shared_ptr< openplx::Physics3D::Charges::ContactGeometry >"""
-        return _RoboticsSwig.Links_RigidLink_contact_geometry(self)
+        r"""contact_geometry(Robotics_Links_RigidLink self) -> std::shared_ptr< openplx::Physics3D::Charges::ContactGeometry >"""
+        return _RoboticsSwig.Robotics_Links_RigidLink_contact_geometry(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Links_RigidLink self, std::string const & key, Any value)
+        setDynamic(Robotics_Links_RigidLink self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13687,22 +13687,22 @@ class Links_RigidLink(openplx.Physics3D.Bodies_RigidBody):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Links_RigidLink_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Links_RigidLink_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Links_RigidLink self, std::string const & key) -> Any
+        getDynamic(Robotics_Links_RigidLink self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Links_RigidLink_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Links_RigidLink_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Links_RigidLink self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Links_RigidLink self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13710,66 +13710,66 @@ class Links_RigidLink(openplx.Physics3D.Bodies_RigidBody):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Links_RigidLink_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Links_RigidLink_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Links_RigidLink self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Links_RigidLink self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Links_RigidLink_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Links_RigidLink_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Links_RigidLink self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Links_RigidLink self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Links_RigidLink_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Links_RigidLink_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Links_RigidLink self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Links_RigidLink self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Links_RigidLink_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Links_RigidLink
+        return _RoboticsSwig.Robotics_Links_RigidLink_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Links_RigidLink
 
-# Register Links_RigidLink in _RoboticsSwig:
-_RoboticsSwig.Links_RigidLink_swigregister(Links_RigidLink)
+# Register Robotics_Links_RigidLink in _RoboticsSwig:
+_RoboticsSwig.Robotics_Links_RigidLink_swigregister(Robotics_Links_RigidLink)
 
-class Links_RigidBoxLink(Links_RigidLink):
+class Robotics_Links_RigidBoxLink(Robotics_Links_RigidLink):
     r"""Proxy of C++ openplx::Robotics::Links::RigidBoxLink class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Links_RigidBoxLink self) -> Links_RigidBoxLink"""
-        _RoboticsSwig.Links_RigidBoxLink_swiginit(self, _RoboticsSwig.new_Links_RigidBoxLink())
+        r"""__init__(Robotics_Links_RigidBoxLink self) -> Robotics_Links_RigidBoxLink"""
+        _RoboticsSwig.Robotics_Links_RigidBoxLink_swiginit(self, _RoboticsSwig.new_Robotics_Links_RigidBoxLink())
 
     def geometry(self):
-        r"""geometry(Links_RigidBoxLink self) -> std::shared_ptr< openplx::Physics3D::Charges::Box >"""
-        return _RoboticsSwig.Links_RigidBoxLink_geometry(self)
+        r"""geometry(Robotics_Links_RigidBoxLink self) -> std::shared_ptr< openplx::Physics3D::Charges::Box >"""
+        return _RoboticsSwig.Robotics_Links_RigidBoxLink_geometry(self)
 
     def arrow(self):
-        r"""arrow(Links_RigidBoxLink self) -> std::shared_ptr< openplx::Physics3D::Charges::Box >"""
-        return _RoboticsSwig.Links_RigidBoxLink_arrow(self)
+        r"""arrow(Robotics_Links_RigidBoxLink self) -> std::shared_ptr< openplx::Physics3D::Charges::Box >"""
+        return _RoboticsSwig.Robotics_Links_RigidBoxLink_arrow(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Links_RigidBoxLink self, std::string const & key, Any value)
+        setDynamic(Robotics_Links_RigidBoxLink self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13777,22 +13777,22 @@ class Links_RigidBoxLink(Links_RigidLink):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Links_RigidBoxLink_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Links_RigidBoxLink_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Links_RigidBoxLink self, std::string const & key) -> Any
+        getDynamic(Robotics_Links_RigidBoxLink self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Links_RigidBoxLink_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Links_RigidBoxLink_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Links_RigidBoxLink self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Links_RigidBoxLink self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13800,62 +13800,62 @@ class Links_RigidBoxLink(Links_RigidLink):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Links_RigidBoxLink_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Links_RigidBoxLink_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Links_RigidBoxLink self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Links_RigidBoxLink self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Links_RigidBoxLink_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Links_RigidBoxLink_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Links_RigidBoxLink self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Links_RigidBoxLink self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Links_RigidBoxLink_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Links_RigidBoxLink_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Links_RigidBoxLink self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Links_RigidBoxLink self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Links_RigidBoxLink_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Links_RigidBoxLink
+        return _RoboticsSwig.Robotics_Links_RigidBoxLink_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Links_RigidBoxLink
 
-# Register Links_RigidBoxLink in _RoboticsSwig:
-_RoboticsSwig.Links_RigidBoxLink_swigregister(Links_RigidBoxLink)
+# Register Robotics_Links_RigidBoxLink in _RoboticsSwig:
+_RoboticsSwig.Robotics_Links_RigidBoxLink_swigregister(Robotics_Links_RigidBoxLink)
 
-class Links_RigidTriMeshLink(Links_RigidLink):
+class Robotics_Links_RigidTriMeshLink(Robotics_Links_RigidLink):
     r"""Proxy of C++ openplx::Robotics::Links::RigidTriMeshLink class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Links_RigidTriMeshLink self) -> Links_RigidTriMeshLink"""
-        _RoboticsSwig.Links_RigidTriMeshLink_swiginit(self, _RoboticsSwig.new_Links_RigidTriMeshLink())
+        r"""__init__(Robotics_Links_RigidTriMeshLink self) -> Robotics_Links_RigidTriMeshLink"""
+        _RoboticsSwig.Robotics_Links_RigidTriMeshLink_swiginit(self, _RoboticsSwig.new_Robotics_Links_RigidTriMeshLink())
 
     def contact_geometry(self):
-        r"""contact_geometry(Links_RigidTriMeshLink self) -> std::shared_ptr< openplx::Physics3D::Charges::ExternalTriMeshGeometry >"""
-        return _RoboticsSwig.Links_RigidTriMeshLink_contact_geometry(self)
+        r"""contact_geometry(Robotics_Links_RigidTriMeshLink self) -> std::shared_ptr< openplx::Physics3D::Charges::ExternalTriMeshGeometry >"""
+        return _RoboticsSwig.Robotics_Links_RigidTriMeshLink_contact_geometry(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Links_RigidTriMeshLink self, std::string const & key, Any value)
+        setDynamic(Robotics_Links_RigidTriMeshLink self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13863,22 +13863,22 @@ class Links_RigidTriMeshLink(Links_RigidLink):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Links_RigidTriMeshLink_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Links_RigidTriMeshLink_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Links_RigidTriMeshLink self, std::string const & key) -> Any
+        getDynamic(Robotics_Links_RigidTriMeshLink self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Links_RigidTriMeshLink_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Links_RigidTriMeshLink_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Links_RigidTriMeshLink self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Links_RigidTriMeshLink self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13886,58 +13886,58 @@ class Links_RigidTriMeshLink(Links_RigidLink):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Links_RigidTriMeshLink_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Links_RigidTriMeshLink_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Links_RigidTriMeshLink self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Links_RigidTriMeshLink self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Links_RigidTriMeshLink_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Links_RigidTriMeshLink_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Links_RigidTriMeshLink self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Links_RigidTriMeshLink self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Links_RigidTriMeshLink_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Links_RigidTriMeshLink_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Links_RigidTriMeshLink self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Links_RigidTriMeshLink self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Links_RigidTriMeshLink_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Links_RigidTriMeshLink
+        return _RoboticsSwig.Robotics_Links_RigidTriMeshLink_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Links_RigidTriMeshLink
 
-# Register Links_RigidTriMeshLink in _RoboticsSwig:
-_RoboticsSwig.Links_RigidTriMeshLink_swigregister(Links_RigidTriMeshLink)
+# Register Robotics_Links_RigidTriMeshLink in _RoboticsSwig:
+_RoboticsSwig.Robotics_Links_RigidTriMeshLink_swigregister(Robotics_Links_RigidTriMeshLink)
 
-class Robots_Robot(openplx.Physics3D.System):
+class Robotics_Robots_Robot(openplx.Physics3D.Physics3D_System):
     r"""Proxy of C++ openplx::Robotics::Robots::Robot class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Robots_Robot self) -> Robots_Robot"""
-        _RoboticsSwig.Robots_Robot_swiginit(self, _RoboticsSwig.new_Robots_Robot())
+        r"""__init__(Robotics_Robots_Robot self) -> Robotics_Robots_Robot"""
+        _RoboticsSwig.Robotics_Robots_Robot_swiginit(self, _RoboticsSwig.new_Robotics_Robots_Robot())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Robots_Robot self, std::string const & key, Any value)
+        setDynamic(Robotics_Robots_Robot self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -13945,22 +13945,22 @@ class Robots_Robot(openplx.Physics3D.System):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Robots_Robot_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Robots_Robot_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Robots_Robot self, std::string const & key) -> Any
+        getDynamic(Robotics_Robots_Robot self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Robots_Robot_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Robots_Robot_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Robots_Robot self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Robots_Robot self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -13968,66 +13968,66 @@ class Robots_Robot(openplx.Physics3D.System):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Robots_Robot_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Robots_Robot_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Robots_Robot self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Robots_Robot self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Robots_Robot_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Robots_Robot_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Robots_Robot self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Robots_Robot self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Robots_Robot_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Robots_Robot_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Robots_Robot self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Robots_Robot self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Robots_Robot_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Robots_Robot
+        return _RoboticsSwig.Robotics_Robots_Robot_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Robots_Robot
 
-# Register Robots_Robot in _RoboticsSwig:
-_RoboticsSwig.Robots_Robot_swigregister(Robots_Robot)
+# Register Robotics_Robots_Robot in _RoboticsSwig:
+_RoboticsSwig.Robotics_Robots_Robot_swigregister(Robotics_Robots_Robot)
 
-class Robots_SerialManipulatorData(openplx.Core.Object):
+class Robotics_Robots_SerialManipulatorData(openplx.Core.Object):
     r"""Proxy of C++ openplx::Robotics::Robots::SerialManipulatorData class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Robots_SerialManipulatorData self) -> Robots_SerialManipulatorData"""
-        _RoboticsSwig.Robots_SerialManipulatorData_swiginit(self, _RoboticsSwig.new_Robots_SerialManipulatorData())
+        r"""__init__(Robotics_Robots_SerialManipulatorData self) -> Robotics_Robots_SerialManipulatorData"""
+        _RoboticsSwig.Robotics_Robots_SerialManipulatorData_swiginit(self, _RoboticsSwig.new_Robotics_Robots_SerialManipulatorData())
 
     def link_data(self):
-        r"""link_data(Robots_SerialManipulatorData self) -> Robotics_Links_LinkData_Vector"""
-        return _RoboticsSwig.Robots_SerialManipulatorData_link_data(self)
+        r"""link_data(Robotics_Robots_SerialManipulatorData self) -> Robotics_Links_LinkData_Vector"""
+        return _RoboticsSwig.Robotics_Robots_SerialManipulatorData_link_data(self)
 
     def hinge_data(self):
-        r"""hinge_data(Robots_SerialManipulatorData self) -> Robotics_Joints_HingeJointData_Vector"""
-        return _RoboticsSwig.Robots_SerialManipulatorData_hinge_data(self)
+        r"""hinge_data(Robotics_Robots_SerialManipulatorData self) -> Robotics_Joints_HingeJointData_Vector"""
+        return _RoboticsSwig.Robotics_Robots_SerialManipulatorData_hinge_data(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Robots_SerialManipulatorData self, std::string const & key, Any value)
+        setDynamic(Robotics_Robots_SerialManipulatorData self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -14035,22 +14035,22 @@ class Robots_SerialManipulatorData(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Robots_SerialManipulatorData_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Robots_SerialManipulatorData_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Robots_SerialManipulatorData self, std::string const & key) -> Any
+        getDynamic(Robotics_Robots_SerialManipulatorData self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Robots_SerialManipulatorData_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Robots_SerialManipulatorData_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Robots_SerialManipulatorData self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Robots_SerialManipulatorData self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -14058,110 +14058,110 @@ class Robots_SerialManipulatorData(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Robots_SerialManipulatorData_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Robots_SerialManipulatorData_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Robots_SerialManipulatorData self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Robots_SerialManipulatorData self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Robots_SerialManipulatorData_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Robots_SerialManipulatorData_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Robots_SerialManipulatorData self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Robots_SerialManipulatorData self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Robots_SerialManipulatorData_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Robots_SerialManipulatorData_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Robots_SerialManipulatorData self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Robots_SerialManipulatorData self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Robots_SerialManipulatorData_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Robots_SerialManipulatorData
+        return _RoboticsSwig.Robotics_Robots_SerialManipulatorData_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Robots_SerialManipulatorData
 
-# Register Robots_SerialManipulatorData in _RoboticsSwig:
-_RoboticsSwig.Robots_SerialManipulatorData_swigregister(Robots_SerialManipulatorData)
+# Register Robotics_Robots_SerialManipulatorData in _RoboticsSwig:
+_RoboticsSwig.Robotics_Robots_SerialManipulatorData_swigregister(Robotics_Robots_SerialManipulatorData)
 
-class Robots_SixAxisSerialManipulator(Robots_Robot):
+class Robotics_Robots_SixAxisSerialManipulator(Robotics_Robots_Robot):
     r"""Proxy of C++ openplx::Robotics::Robots::SixAxisSerialManipulator class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Robots_SixAxisSerialManipulator self) -> Robots_SixAxisSerialManipulator"""
-        _RoboticsSwig.Robots_SixAxisSerialManipulator_swiginit(self, _RoboticsSwig.new_Robots_SixAxisSerialManipulator())
+        r"""__init__(Robotics_Robots_SixAxisSerialManipulator self) -> Robotics_Robots_SixAxisSerialManipulator"""
+        _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_swiginit(self, _RoboticsSwig.new_Robotics_Robots_SixAxisSerialManipulator())
 
     def data(self):
-        r"""data(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Robots::SerialManipulatorData >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_data(self)
+        r"""data(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Robots::SerialManipulatorData >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_data(self)
 
     def link1(self):
-        r"""link1(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_link1(self)
+        r"""link1(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_link1(self)
 
     def link2(self):
-        r"""link2(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_link2(self)
+        r"""link2(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_link2(self)
 
     def link3(self):
-        r"""link3(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_link3(self)
+        r"""link3(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_link3(self)
 
     def link4(self):
-        r"""link4(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_link4(self)
+        r"""link4(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_link4(self)
 
     def link5(self):
-        r"""link5(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_link5(self)
+        r"""link5(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_link5(self)
 
     def link6(self):
-        r"""link6(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_link6(self)
+        r"""link6(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Links::RigidLink >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_link6(self)
 
     def joint1(self):
-        r"""joint1(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_joint1(self)
+        r"""joint1(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_joint1(self)
 
     def joint2(self):
-        r"""joint2(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_joint2(self)
+        r"""joint2(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_joint2(self)
 
     def joint3(self):
-        r"""joint3(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_joint3(self)
+        r"""joint3(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_joint3(self)
 
     def joint4(self):
-        r"""joint4(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_joint4(self)
+        r"""joint4(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_joint4(self)
 
     def joint5(self):
-        r"""joint5(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_joint5(self)
+        r"""joint5(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_joint5(self)
 
     def joint6(self):
-        r"""joint6(Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_joint6(self)
+        r"""joint6(Robotics_Robots_SixAxisSerialManipulator self) -> std::shared_ptr< openplx::Robotics::Joints::HingeJoint >"""
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_joint6(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Robots_SixAxisSerialManipulator self, std::string const & key, Any value)
+        setDynamic(Robotics_Robots_SixAxisSerialManipulator self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -14169,22 +14169,22 @@ class Robots_SixAxisSerialManipulator(Robots_Robot):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Robots_SixAxisSerialManipulator self, std::string const & key) -> Any
+        getDynamic(Robotics_Robots_SixAxisSerialManipulator self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Robots_SixAxisSerialManipulator self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Robots_SixAxisSerialManipulator self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -14192,73 +14192,73 @@ class Robots_SixAxisSerialManipulator(Robots_Robot):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Robots_SixAxisSerialManipulator self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Robots_SixAxisSerialManipulator self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Robots_SixAxisSerialManipulator self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Robots_SixAxisSerialManipulator self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Robots_SixAxisSerialManipulator self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Robots_SixAxisSerialManipulator self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Robots_SixAxisSerialManipulator_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Robots_SixAxisSerialManipulator
+        return _RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Robots_SixAxisSerialManipulator
 
-# Register Robots_SixAxisSerialManipulator in _RoboticsSwig:
-_RoboticsSwig.Robots_SixAxisSerialManipulator_swigregister(Robots_SixAxisSerialManipulator)
+# Register Robotics_Robots_SixAxisSerialManipulator in _RoboticsSwig:
+_RoboticsSwig.Robotics_Robots_SixAxisSerialManipulator_swigregister(Robotics_Robots_SixAxisSerialManipulator)
 
-class Signals_RobotInput(openplx.Physics.Signals_Input):
+class Robotics_Signals_RobotInput(openplx.Physics.Physics_Signals_Input):
     r"""Proxy of C++ openplx::Robotics::Signals::RobotInput class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Signals_RobotInput self) -> Signals_RobotInput"""
-        _RoboticsSwig.Signals_RobotInput_swiginit(self, _RoboticsSwig.new_Signals_RobotInput())
+        r"""__init__(Robotics_Signals_RobotInput self) -> Robotics_Signals_RobotInput"""
+        _RoboticsSwig.Robotics_Signals_RobotInput_swiginit(self, _RoboticsSwig.new_Robotics_Signals_RobotInput())
 
     def targets(self):
-        r"""targets(Signals_RobotInput self) -> Physics_Signals_Input_Vector"""
-        return _RoboticsSwig.Signals_RobotInput_targets(self)
+        r"""targets(Robotics_Signals_RobotInput self) -> Physics_Signals_Input_Vector"""
+        return _RoboticsSwig.Robotics_Signals_RobotInput_targets(self)
 
     def process(self, signal):
         r"""
-        process(Signals_RobotInput self, std::shared_ptr< openplx::Physics::Signals::InputSignal > signal) -> Physics_Signals_InputSignal_Vector
+        process(Robotics_Signals_RobotInput self, std::shared_ptr< openplx::Physics::Signals::InputSignal > signal) -> Physics_Signals_InputSignal_Vector
 
         Parameters
         ----------
         signal: std::shared_ptr< openplx::Physics::Signals::InputSignal >
 
         """
-        return _RoboticsSwig.Signals_RobotInput_process(self, signal)
+        return _RoboticsSwig.Robotics_Signals_RobotInput_process(self, signal)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Signals_RobotInput self, std::string const & key, Any value)
+        setDynamic(Robotics_Signals_RobotInput self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -14266,22 +14266,22 @@ class Signals_RobotInput(openplx.Physics.Signals_Input):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Signals_RobotInput_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Signals_RobotInput_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Signals_RobotInput self, std::string const & key) -> Any
+        getDynamic(Robotics_Signals_RobotInput self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Signals_RobotInput_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Signals_RobotInput_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Signals_RobotInput self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Signals_RobotInput self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -14289,62 +14289,62 @@ class Signals_RobotInput(openplx.Physics.Signals_Input):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Signals_RobotInput_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Signals_RobotInput_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Signals_RobotInput self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Signals_RobotInput self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Signals_RobotInput_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_RobotInput_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Signals_RobotInput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Signals_RobotInput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Signals_RobotInput_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_RobotInput_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Signals_RobotInput self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Signals_RobotInput self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Signals_RobotInput_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Signals_RobotInput
+        return _RoboticsSwig.Robotics_Signals_RobotInput_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Signals_RobotInput
 
-# Register Signals_RobotInput in _RoboticsSwig:
-_RoboticsSwig.Signals_RobotInput_swigregister(Signals_RobotInput)
+# Register Robotics_Signals_RobotInput in _RoboticsSwig:
+_RoboticsSwig.Robotics_Signals_RobotInput_swigregister(Robotics_Signals_RobotInput)
 
-class Signals_RobotInputSignal(openplx.Physics.Signals_InputSignal):
+class Robotics_Signals_RobotInputSignal(openplx.Physics.Physics_Signals_InputSignal):
     r"""Proxy of C++ openplx::Robotics::Signals::RobotInputSignal class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Signals_RobotInputSignal self) -> Signals_RobotInputSignal"""
-        _RoboticsSwig.Signals_RobotInputSignal_swiginit(self, _RoboticsSwig.new_Signals_RobotInputSignal())
+        r"""__init__(Robotics_Signals_RobotInputSignal self) -> Robotics_Signals_RobotInputSignal"""
+        _RoboticsSwig.Robotics_Signals_RobotInputSignal_swiginit(self, _RoboticsSwig.new_Robotics_Signals_RobotInputSignal())
 
     def values(self):
-        r"""values(Signals_RobotInputSignal self) -> Physics_Signals_RealValue_Vector"""
-        return _RoboticsSwig.Signals_RobotInputSignal_values(self)
+        r"""values(Robotics_Signals_RobotInputSignal self) -> Physics_Signals_RealValue_Vector"""
+        return _RoboticsSwig.Robotics_Signals_RobotInputSignal_values(self)
 
     def control_events(self):
-        r"""control_events(Signals_RobotInputSignal self) -> BoolVector"""
-        return _RoboticsSwig.Signals_RobotInputSignal_control_events(self)
+        r"""control_events(Robotics_Signals_RobotInputSignal self) -> BoolVector"""
+        return _RoboticsSwig.Robotics_Signals_RobotInputSignal_control_events(self)
 
     @staticmethod
     def create(values, control_events, target):
@@ -14358,7 +14358,7 @@ class Signals_RobotInputSignal(openplx.Physics.Signals_InputSignal):
         target: std::shared_ptr< openplx::Physics::Signals::Input >
 
         """
-        return _RoboticsSwig.Signals_RobotInputSignal_create(values, control_events, target)
+        return _RoboticsSwig.Robotics_Signals_RobotInputSignal_create(values, control_events, target)
 
     @staticmethod
     def from_values(values, control_events, target):
@@ -14372,11 +14372,11 @@ class Signals_RobotInputSignal(openplx.Physics.Signals_InputSignal):
         target: std::shared_ptr< openplx::Physics::Signals::Input >
 
         """
-        return _RoboticsSwig.Signals_RobotInputSignal_from_values(values, control_events, target)
+        return _RoboticsSwig.Robotics_Signals_RobotInputSignal_from_values(values, control_events, target)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Signals_RobotInputSignal self, std::string const & key, Any value)
+        setDynamic(Robotics_Signals_RobotInputSignal self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -14384,22 +14384,22 @@ class Signals_RobotInputSignal(openplx.Physics.Signals_InputSignal):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Signals_RobotInputSignal_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Signals_RobotInputSignal_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Signals_RobotInputSignal self, std::string const & key) -> Any
+        getDynamic(Robotics_Signals_RobotInputSignal self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Signals_RobotInputSignal_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Signals_RobotInputSignal_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Signals_RobotInputSignal self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Signals_RobotInputSignal self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -14407,48 +14407,48 @@ class Signals_RobotInputSignal(openplx.Physics.Signals_InputSignal):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Signals_RobotInputSignal_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Signals_RobotInputSignal_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Signals_RobotInputSignal self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Signals_RobotInputSignal self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Signals_RobotInputSignal_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_RobotInputSignal_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Signals_RobotInputSignal self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Signals_RobotInputSignal self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Signals_RobotInputSignal_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_RobotInputSignal_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Signals_RobotInputSignal self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Signals_RobotInputSignal self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Signals_RobotInputSignal_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Signals_RobotInputSignal
+        return _RoboticsSwig.Robotics_Signals_RobotInputSignal_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Signals_RobotInputSignal
 
-# Register Signals_RobotInputSignal in _RoboticsSwig:
-_RoboticsSwig.Signals_RobotInputSignal_swigregister(Signals_RobotInputSignal)
+# Register Robotics_Signals_RobotInputSignal in _RoboticsSwig:
+_RoboticsSwig.Robotics_Signals_RobotInputSignal_swigregister(Robotics_Signals_RobotInputSignal)
 
-def Signals_RobotInputSignal_create(values, control_events, target):
+def Robotics_Signals_RobotInputSignal_create(values, control_events, target):
     r"""
-    Signals_RobotInputSignal_create(DoubleVector values, BoolVector control_events, std::shared_ptr< openplx::Physics::Signals::Input > target) -> std::shared_ptr< openplx::Robotics::Signals::RobotInputSignal >
+    Robotics_Signals_RobotInputSignal_create(DoubleVector values, BoolVector control_events, std::shared_ptr< openplx::Physics::Signals::Input > target) -> std::shared_ptr< openplx::Robotics::Signals::RobotInputSignal >
 
     Parameters
     ----------
@@ -14457,11 +14457,11 @@ def Signals_RobotInputSignal_create(values, control_events, target):
     target: std::shared_ptr< openplx::Physics::Signals::Input >
 
     """
-    return _RoboticsSwig.Signals_RobotInputSignal_create(values, control_events, target)
+    return _RoboticsSwig.Robotics_Signals_RobotInputSignal_create(values, control_events, target)
 
-def Signals_RobotInputSignal_from_values(values, control_events, target):
+def Robotics_Signals_RobotInputSignal_from_values(values, control_events, target):
     r"""
-    Signals_RobotInputSignal_from_values(Physics_Signals_RealValue_Vector values, BoolVector control_events, std::shared_ptr< openplx::Physics::Signals::Input > target) -> std::shared_ptr< openplx::Robotics::Signals::RobotInputSignal >
+    Robotics_Signals_RobotInputSignal_from_values(Physics_Signals_RealValue_Vector values, BoolVector control_events, std::shared_ptr< openplx::Physics::Signals::Input > target) -> std::shared_ptr< openplx::Robotics::Signals::RobotInputSignal >
 
     Parameters
     ----------
@@ -14470,33 +14470,33 @@ def Signals_RobotInputSignal_from_values(values, control_events, target):
     target: std::shared_ptr< openplx::Physics::Signals::Input >
 
     """
-    return _RoboticsSwig.Signals_RobotInputSignal_from_values(values, control_events, target)
+    return _RoboticsSwig.Robotics_Signals_RobotInputSignal_from_values(values, control_events, target)
 
-class Signals_RobotOutput(openplx.Physics.Signals_Output):
+class Robotics_Signals_RobotOutput(openplx.Physics.Physics_Signals_Output):
     r"""Proxy of C++ openplx::Robotics::Signals::RobotOutput class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Signals_RobotOutput self) -> Signals_RobotOutput"""
-        _RoboticsSwig.Signals_RobotOutput_swiginit(self, _RoboticsSwig.new_Signals_RobotOutput())
+        r"""__init__(Robotics_Signals_RobotOutput self) -> Robotics_Signals_RobotOutput"""
+        _RoboticsSwig.Robotics_Signals_RobotOutput_swiginit(self, _RoboticsSwig.new_Robotics_Signals_RobotOutput())
 
     def joint_sources(self):
-        r"""joint_sources(Signals_RobotOutput self) -> Physics_Signals_Output_Vector"""
-        return _RoboticsSwig.Signals_RobotOutput_joint_sources(self)
+        r"""joint_sources(Robotics_Signals_RobotOutput self) -> Physics_Signals_Output_Vector"""
+        return _RoboticsSwig.Robotics_Signals_RobotOutput_joint_sources(self)
 
     def object_sources(self):
-        r"""object_sources(Signals_RobotOutput self) -> Physics_Signals_Output_Vector"""
-        return _RoboticsSwig.Signals_RobotOutput_object_sources(self)
+        r"""object_sources(Robotics_Signals_RobotOutput self) -> Physics_Signals_Output_Vector"""
+        return _RoboticsSwig.Robotics_Signals_RobotOutput_object_sources(self)
 
     def sensors(self):
-        r"""sensors(Signals_RobotOutput self) -> Robotics_Signals_Sensor_Vector"""
-        return _RoboticsSwig.Signals_RobotOutput_sensors(self)
+        r"""sensors(Robotics_Signals_RobotOutput self) -> Robotics_Signals_Sensor_Vector"""
+        return _RoboticsSwig.Robotics_Signals_RobotOutput_sensors(self)
 
     def process(self, output, signals):
         r"""
-        process(Signals_RobotOutput self, std::shared_ptr< openplx::Physics::Signals::Output > output, Physics_Signals_OutputSignal_Vector signals) -> std::shared_ptr< openplx::Physics::Signals::OutputSignal >
+        process(Robotics_Signals_RobotOutput self, std::shared_ptr< openplx::Physics::Signals::Output > output, Physics_Signals_OutputSignal_Vector signals) -> std::shared_ptr< openplx::Physics::Signals::OutputSignal >
 
         Parameters
         ----------
@@ -14504,11 +14504,11 @@ class Signals_RobotOutput(openplx.Physics.Signals_Output):
         signals: std::vector< std::shared_ptr< openplx::Physics::Signals::OutputSignal >,std::allocator< std::shared_ptr< openplx::Physics::Signals::OutputSignal > > >
 
         """
-        return _RoboticsSwig.Signals_RobotOutput_process(self, output, signals)
+        return _RoboticsSwig.Robotics_Signals_RobotOutput_process(self, output, signals)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Signals_RobotOutput self, std::string const & key, Any value)
+        setDynamic(Robotics_Signals_RobotOutput self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -14516,22 +14516,22 @@ class Signals_RobotOutput(openplx.Physics.Signals_Output):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Signals_RobotOutput_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Signals_RobotOutput_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Signals_RobotOutput self, std::string const & key) -> Any
+        getDynamic(Robotics_Signals_RobotOutput self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Signals_RobotOutput_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Signals_RobotOutput_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Signals_RobotOutput self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Signals_RobotOutput self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -14539,74 +14539,74 @@ class Signals_RobotOutput(openplx.Physics.Signals_Output):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Signals_RobotOutput_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Signals_RobotOutput_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Signals_RobotOutput self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Signals_RobotOutput self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Signals_RobotOutput_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_RobotOutput_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Signals_RobotOutput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Signals_RobotOutput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Signals_RobotOutput_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_RobotOutput_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Signals_RobotOutput self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Signals_RobotOutput self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Signals_RobotOutput_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Signals_RobotOutput
+        return _RoboticsSwig.Robotics_Signals_RobotOutput_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Signals_RobotOutput
 
-# Register Signals_RobotOutput in _RoboticsSwig:
-_RoboticsSwig.Signals_RobotOutput_swigregister(Signals_RobotOutput)
+# Register Robotics_Signals_RobotOutput in _RoboticsSwig:
+_RoboticsSwig.Robotics_Signals_RobotOutput_swigregister(Robotics_Signals_RobotOutput)
 
-class Signals_RobotOutputSignal(openplx.Physics.Signals_OutputSignal):
+class Robotics_Signals_RobotOutputSignal(openplx.Physics.Physics_Signals_OutputSignal):
     r"""Proxy of C++ openplx::Robotics::Signals::RobotOutputSignal class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Signals_RobotOutputSignal self) -> Signals_RobotOutputSignal"""
-        _RoboticsSwig.Signals_RobotOutputSignal_swiginit(self, _RoboticsSwig.new_Signals_RobotOutputSignal())
+        r"""__init__(Robotics_Signals_RobotOutputSignal self) -> Robotics_Signals_RobotOutputSignal"""
+        _RoboticsSwig.Robotics_Signals_RobotOutputSignal_swiginit(self, _RoboticsSwig.new_Robotics_Signals_RobotOutputSignal())
 
     def sensor_values(self):
-        r"""sensor_values(Signals_RobotOutputSignal self) -> Robotics_Signals_SensorValues_Vector"""
-        return _RoboticsSwig.Signals_RobotOutputSignal_sensor_values(self)
+        r"""sensor_values(Robotics_Signals_RobotOutputSignal self) -> Robotics_Signals_SensorValues_Vector"""
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_sensor_values(self)
 
     def angles(self):
-        r"""angles(Signals_RobotOutputSignal self) -> DoubleVector"""
-        return _RoboticsSwig.Signals_RobotOutputSignal_angles(self)
+        r"""angles(Robotics_Signals_RobotOutputSignal self) -> DoubleVector"""
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_angles(self)
 
     def angular_velocities(self):
-        r"""angular_velocities(Signals_RobotOutputSignal self) -> DoubleVector"""
-        return _RoboticsSwig.Signals_RobotOutputSignal_angular_velocities(self)
+        r"""angular_velocities(Robotics_Signals_RobotOutputSignal self) -> DoubleVector"""
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_angular_velocities(self)
 
     def torques(self):
-        r"""torques(Signals_RobotOutputSignal self) -> DoubleVector"""
-        return _RoboticsSwig.Signals_RobotOutputSignal_torques(self)
+        r"""torques(Robotics_Signals_RobotOutputSignal self) -> DoubleVector"""
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_torques(self)
 
     def object_values(self):
-        r"""object_values(Signals_RobotOutputSignal self) -> Physics_Signals_Value_Vector"""
-        return _RoboticsSwig.Signals_RobotOutputSignal_object_values(self)
+        r"""object_values(Robotics_Signals_RobotOutputSignal self) -> Physics_Signals_Value_Vector"""
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_object_values(self)
 
     @staticmethod
     def create(source_angle_signals, source_angular_velocity_signals, source_torque_signals, object_values, sensor_values, source):
@@ -14623,11 +14623,11 @@ class Signals_RobotOutputSignal(openplx.Physics.Signals_OutputSignal):
         source: std::shared_ptr< openplx::Physics::Signals::Output >
 
         """
-        return _RoboticsSwig.Signals_RobotOutputSignal_create(source_angle_signals, source_angular_velocity_signals, source_torque_signals, object_values, sensor_values, source)
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_create(source_angle_signals, source_angular_velocity_signals, source_torque_signals, object_values, sensor_values, source)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Signals_RobotOutputSignal self, std::string const & key, Any value)
+        setDynamic(Robotics_Signals_RobotOutputSignal self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -14635,22 +14635,22 @@ class Signals_RobotOutputSignal(openplx.Physics.Signals_OutputSignal):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Signals_RobotOutputSignal_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Signals_RobotOutputSignal self, std::string const & key) -> Any
+        getDynamic(Robotics_Signals_RobotOutputSignal self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Signals_RobotOutputSignal_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Signals_RobotOutputSignal self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Signals_RobotOutputSignal self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -14658,48 +14658,48 @@ class Signals_RobotOutputSignal(openplx.Physics.Signals_OutputSignal):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Signals_RobotOutputSignal_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Signals_RobotOutputSignal self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Signals_RobotOutputSignal self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Signals_RobotOutputSignal_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Signals_RobotOutputSignal self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Signals_RobotOutputSignal self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Signals_RobotOutputSignal_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Signals_RobotOutputSignal self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Signals_RobotOutputSignal self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Signals_RobotOutputSignal_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Signals_RobotOutputSignal
+        return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Signals_RobotOutputSignal
 
-# Register Signals_RobotOutputSignal in _RoboticsSwig:
-_RoboticsSwig.Signals_RobotOutputSignal_swigregister(Signals_RobotOutputSignal)
+# Register Robotics_Signals_RobotOutputSignal in _RoboticsSwig:
+_RoboticsSwig.Robotics_Signals_RobotOutputSignal_swigregister(Robotics_Signals_RobotOutputSignal)
 
-def Signals_RobotOutputSignal_create(source_angle_signals, source_angular_velocity_signals, source_torque_signals, object_values, sensor_values, source):
+def Robotics_Signals_RobotOutputSignal_create(source_angle_signals, source_angular_velocity_signals, source_torque_signals, object_values, sensor_values, source):
     r"""
-    Signals_RobotOutputSignal_create(Physics_Signals_ValueOutputSignal_Vector source_angle_signals, Physics_Signals_ValueOutputSignal_Vector source_angular_velocity_signals, Physics_Signals_ValueOutputSignal_Vector source_torque_signals, Physics_Signals_Value_Vector object_values, Robotics_Signals_SensorValues_Vector sensor_values, std::shared_ptr< openplx::Physics::Signals::Output > source) -> std::shared_ptr< openplx::Robotics::Signals::RobotOutputSignal >
+    Robotics_Signals_RobotOutputSignal_create(Physics_Signals_ValueOutputSignal_Vector source_angle_signals, Physics_Signals_ValueOutputSignal_Vector source_angular_velocity_signals, Physics_Signals_ValueOutputSignal_Vector source_torque_signals, Physics_Signals_Value_Vector object_values, Robotics_Signals_SensorValues_Vector sensor_values, std::shared_ptr< openplx::Physics::Signals::Output > source) -> std::shared_ptr< openplx::Robotics::Signals::RobotOutputSignal >
 
     Parameters
     ----------
@@ -14711,29 +14711,29 @@ def Signals_RobotOutputSignal_create(source_angle_signals, source_angular_veloci
     source: std::shared_ptr< openplx::Physics::Signals::Output >
 
     """
-    return _RoboticsSwig.Signals_RobotOutputSignal_create(source_angle_signals, source_angular_velocity_signals, source_torque_signals, object_values, sensor_values, source)
+    return _RoboticsSwig.Robotics_Signals_RobotOutputSignal_create(source_angle_signals, source_angular_velocity_signals, source_torque_signals, object_values, sensor_values, source)
 
-class Signals_Sensor(openplx.Core.Object):
+class Robotics_Signals_Sensor(openplx.Core.Object):
     r"""Proxy of C++ openplx::Robotics::Signals::Sensor class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Signals_Sensor self) -> Signals_Sensor"""
-        _RoboticsSwig.Signals_Sensor_swiginit(self, _RoboticsSwig.new_Signals_Sensor())
+        r"""__init__(Robotics_Signals_Sensor self) -> Robotics_Signals_Sensor"""
+        _RoboticsSwig.Robotics_Signals_Sensor_swiginit(self, _RoboticsSwig.new_Robotics_Signals_Sensor())
 
     def outputs(self):
-        r"""outputs(Signals_Sensor self) -> Physics_Signals_Output_Vector"""
-        return _RoboticsSwig.Signals_Sensor_outputs(self)
+        r"""outputs(Robotics_Signals_Sensor self) -> Physics_Signals_Output_Vector"""
+        return _RoboticsSwig.Robotics_Signals_Sensor_outputs(self)
 
     def reference_id(self):
-        r"""reference_id(Signals_Sensor self) -> std::string"""
-        return _RoboticsSwig.Signals_Sensor_reference_id(self)
+        r"""reference_id(Robotics_Signals_Sensor self) -> std::string"""
+        return _RoboticsSwig.Robotics_Signals_Sensor_reference_id(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Signals_Sensor self, std::string const & key, Any value)
+        setDynamic(Robotics_Signals_Sensor self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -14741,22 +14741,22 @@ class Signals_Sensor(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Signals_Sensor_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Signals_Sensor_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Signals_Sensor self, std::string const & key) -> Any
+        getDynamic(Robotics_Signals_Sensor self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Signals_Sensor_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Signals_Sensor_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Signals_Sensor self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Signals_Sensor self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -14764,62 +14764,62 @@ class Signals_Sensor(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Signals_Sensor_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Signals_Sensor_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Signals_Sensor self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Signals_Sensor self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Signals_Sensor_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_Sensor_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Signals_Sensor self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Signals_Sensor self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Signals_Sensor_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_Sensor_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Signals_Sensor self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Signals_Sensor self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Signals_Sensor_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Signals_Sensor
+        return _RoboticsSwig.Robotics_Signals_Sensor_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Signals_Sensor
 
-# Register Signals_Sensor in _RoboticsSwig:
-_RoboticsSwig.Signals_Sensor_swigregister(Signals_Sensor)
+# Register Robotics_Signals_Sensor in _RoboticsSwig:
+_RoboticsSwig.Robotics_Signals_Sensor_swigregister(Robotics_Signals_Sensor)
 
-class Signals_SensorValues(openplx.Core.Object):
+class Robotics_Signals_SensorValues(openplx.Core.Object):
     r"""Proxy of C++ openplx::Robotics::Signals::SensorValues class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Signals_SensorValues self) -> Signals_SensorValues"""
-        _RoboticsSwig.Signals_SensorValues_swiginit(self, _RoboticsSwig.new_Signals_SensorValues())
+        r"""__init__(Robotics_Signals_SensorValues self) -> Robotics_Signals_SensorValues"""
+        _RoboticsSwig.Robotics_Signals_SensorValues_swiginit(self, _RoboticsSwig.new_Robotics_Signals_SensorValues())
 
     def name(self):
-        r"""name(Signals_SensorValues self) -> std::string"""
-        return _RoboticsSwig.Signals_SensorValues_name(self)
+        r"""name(Robotics_Signals_SensorValues self) -> std::string"""
+        return _RoboticsSwig.Robotics_Signals_SensorValues_name(self)
 
     def values(self):
-        r"""values(Signals_SensorValues self) -> Physics_Signals_Value_Vector"""
-        return _RoboticsSwig.Signals_SensorValues_values(self)
+        r"""values(Robotics_Signals_SensorValues self) -> Physics_Signals_Value_Vector"""
+        return _RoboticsSwig.Robotics_Signals_SensorValues_values(self)
 
     @staticmethod
     def create(name, values):
@@ -14832,11 +14832,11 @@ class Signals_SensorValues(openplx.Core.Object):
         values: std::vector< std::shared_ptr< openplx::Physics::Signals::Value >,std::allocator< std::shared_ptr< openplx::Physics::Signals::Value > > >
 
         """
-        return _RoboticsSwig.Signals_SensorValues_create(name, values)
+        return _RoboticsSwig.Robotics_Signals_SensorValues_create(name, values)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Signals_SensorValues self, std::string const & key, Any value)
+        setDynamic(Robotics_Signals_SensorValues self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -14844,22 +14844,22 @@ class Signals_SensorValues(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _RoboticsSwig.Signals_SensorValues_setDynamic(self, key, value)
+        return _RoboticsSwig.Robotics_Signals_SensorValues_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Signals_SensorValues self, std::string const & key) -> Any
+        getDynamic(Robotics_Signals_SensorValues self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _RoboticsSwig.Signals_SensorValues_getDynamic(self, key)
+        return _RoboticsSwig.Robotics_Signals_SensorValues_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Signals_SensorValues self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Robotics_Signals_SensorValues self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -14867,48 +14867,48 @@ class Signals_SensorValues(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _RoboticsSwig.Signals_SensorValues_callDynamic(self, key, args)
+        return _RoboticsSwig.Robotics_Signals_SensorValues_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Signals_SensorValues self, ObjectVector output)
+        extractObjectFieldsTo(Robotics_Signals_SensorValues self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _RoboticsSwig.Signals_SensorValues_extractObjectFieldsTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_SensorValues_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Signals_SensorValues self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Robotics_Signals_SensorValues self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _RoboticsSwig.Signals_SensorValues_extractEntriesTo(self, output)
+        return _RoboticsSwig.Robotics_Signals_SensorValues_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Signals_SensorValues self, openplx::RuntimeContext const & context)
+        triggerOnInit(Robotics_Signals_SensorValues self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _RoboticsSwig.Signals_SensorValues_triggerOnInit(self, context)
-    __swig_destroy__ = _RoboticsSwig.delete_Signals_SensorValues
+        return _RoboticsSwig.Robotics_Signals_SensorValues_triggerOnInit(self, context)
+    __swig_destroy__ = _RoboticsSwig.delete_Robotics_Signals_SensorValues
 
-# Register Signals_SensorValues in _RoboticsSwig:
-_RoboticsSwig.Signals_SensorValues_swigregister(Signals_SensorValues)
+# Register Robotics_Signals_SensorValues in _RoboticsSwig:
+_RoboticsSwig.Robotics_Signals_SensorValues_swigregister(Robotics_Signals_SensorValues)
 
-def Signals_SensorValues_create(name, values):
+def Robotics_Signals_SensorValues_create(name, values):
     r"""
-    Signals_SensorValues_create(std::string name, Physics_Signals_Value_Vector values) -> std::shared_ptr< openplx::Robotics::Signals::SensorValues >
+    Robotics_Signals_SensorValues_create(std::string name, Physics_Signals_Value_Vector values) -> std::shared_ptr< openplx::Robotics::Signals::SensorValues >
 
     Parameters
     ----------
@@ -14916,7 +14916,7 @@ def Signals_SensorValues_create(name, values):
     values: std::vector< std::shared_ptr< openplx::Physics::Signals::Value >,std::allocator< std::shared_ptr< openplx::Physics::Signals::Value > > >
 
     """
-    return _RoboticsSwig.Signals_SensorValues_create(name, values)
+    return _RoboticsSwig.Robotics_Signals_SensorValues_create(name, values)