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

openplx/Terrain.py

@@ -3109,23 +3109,23 @@ class Terrain_TerrainMaterial_Vector(object):
 # Register Terrain_TerrainMaterial_Vector in _TerrainSwig:
 _TerrainSwig.Terrain_TerrainMaterial_Vector_swigregister(Terrain_TerrainMaterial_Vector)
 
-class TerrainMaterial(openplx.Physics.Charges_Material):
+class Terrain_TerrainMaterial(openplx.Physics.Physics_Charges_Material):
     r"""Proxy of C++ openplx::Terrain::TerrainMaterial 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__(TerrainMaterial self) -> TerrainMaterial"""
-        _TerrainSwig.TerrainMaterial_swiginit(self, _TerrainSwig.new_TerrainMaterial())
+        r"""__init__(Terrain_TerrainMaterial self) -> Terrain_TerrainMaterial"""
+        _TerrainSwig.Terrain_TerrainMaterial_swiginit(self, _TerrainSwig.new_Terrain_TerrainMaterial())
 
     def is_default_terrain_material(self):
-        r"""is_default_terrain_material(TerrainMaterial self) -> bool"""
-        return _TerrainSwig.TerrainMaterial_is_default_terrain_material(self)
+        r"""is_default_terrain_material(Terrain_TerrainMaterial self) -> bool"""
+        return _TerrainSwig.Terrain_TerrainMaterial_is_default_terrain_material(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(TerrainMaterial self, std::string const & key, Any value)
+        setDynamic(Terrain_TerrainMaterial self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -3133,22 +3133,22 @@ class TerrainMaterial(openplx.Physics.Charges_Material):
         value: openplx::Core::Any &&
 
         """
-        return _TerrainSwig.TerrainMaterial_setDynamic(self, key, value)
+        return _TerrainSwig.Terrain_TerrainMaterial_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(TerrainMaterial self, std::string const & key) -> Any
+        getDynamic(Terrain_TerrainMaterial self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _TerrainSwig.TerrainMaterial_getDynamic(self, key)
+        return _TerrainSwig.Terrain_TerrainMaterial_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(TerrainMaterial self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Terrain_TerrainMaterial self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -3156,58 +3156,58 @@ class TerrainMaterial(openplx.Physics.Charges_Material):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _TerrainSwig.TerrainMaterial_callDynamic(self, key, args)
+        return _TerrainSwig.Terrain_TerrainMaterial_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(TerrainMaterial self, ObjectVector output)
+        extractObjectFieldsTo(Terrain_TerrainMaterial self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _TerrainSwig.TerrainMaterial_extractObjectFieldsTo(self, output)
+        return _TerrainSwig.Terrain_TerrainMaterial_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(TerrainMaterial self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Terrain_TerrainMaterial 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 _TerrainSwig.TerrainMaterial_extractEntriesTo(self, output)
+        return _TerrainSwig.Terrain_TerrainMaterial_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(TerrainMaterial self, openplx::RuntimeContext const & context)
+        triggerOnInit(Terrain_TerrainMaterial self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _TerrainSwig.TerrainMaterial_triggerOnInit(self, context)
-    __swig_destroy__ = _TerrainSwig.delete_TerrainMaterial
+        return _TerrainSwig.Terrain_TerrainMaterial_triggerOnInit(self, context)
+    __swig_destroy__ = _TerrainSwig.delete_Terrain_TerrainMaterial
 
-# Register TerrainMaterial in _TerrainSwig:
-_TerrainSwig.TerrainMaterial_swigregister(TerrainMaterial)
+# Register Terrain_TerrainMaterial in _TerrainSwig:
+_TerrainSwig.Terrain_TerrainMaterial_swigregister(Terrain_TerrainMaterial)
 
-class MaterialLibrary_defaultTerrainMaterial(TerrainMaterial):
+class Terrain_MaterialLibrary_defaultTerrainMaterial(Terrain_TerrainMaterial):
     r"""Proxy of C++ openplx::Terrain::MaterialLibrary::defaultTerrainMaterial 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__(MaterialLibrary_defaultTerrainMaterial self) -> MaterialLibrary_defaultTerrainMaterial"""
-        _TerrainSwig.MaterialLibrary_defaultTerrainMaterial_swiginit(self, _TerrainSwig.new_MaterialLibrary_defaultTerrainMaterial())
+        r"""__init__(Terrain_MaterialLibrary_defaultTerrainMaterial self) -> Terrain_MaterialLibrary_defaultTerrainMaterial"""
+        _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_defaultTerrainMaterial())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(MaterialLibrary_defaultTerrainMaterial self, std::string const & key, Any value)
+        setDynamic(Terrain_MaterialLibrary_defaultTerrainMaterial self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -3215,22 +3215,22 @@ class MaterialLibrary_defaultTerrainMaterial(TerrainMaterial):
         value: openplx::Core::Any &&
 
         """
-        return _TerrainSwig.MaterialLibrary_defaultTerrainMaterial_setDynamic(self, key, value)
+        return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(MaterialLibrary_defaultTerrainMaterial self, std::string const & key) -> Any
+        getDynamic(Terrain_MaterialLibrary_defaultTerrainMaterial self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _TerrainSwig.MaterialLibrary_defaultTerrainMaterial_getDynamic(self, key)
+        return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(MaterialLibrary_defaultTerrainMaterial self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Terrain_MaterialLibrary_defaultTerrainMaterial self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -3238,58 +3238,58 @@ class MaterialLibrary_defaultTerrainMaterial(TerrainMaterial):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _TerrainSwig.MaterialLibrary_defaultTerrainMaterial_callDynamic(self, key, args)
+        return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(MaterialLibrary_defaultTerrainMaterial self, ObjectVector output)
+        extractObjectFieldsTo(Terrain_MaterialLibrary_defaultTerrainMaterial self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _TerrainSwig.MaterialLibrary_defaultTerrainMaterial_extractObjectFieldsTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(MaterialLibrary_defaultTerrainMaterial self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Terrain_MaterialLibrary_defaultTerrainMaterial 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 _TerrainSwig.MaterialLibrary_defaultTerrainMaterial_extractEntriesTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(MaterialLibrary_defaultTerrainMaterial self, openplx::RuntimeContext const & context)
+        triggerOnInit(Terrain_MaterialLibrary_defaultTerrainMaterial self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _TerrainSwig.MaterialLibrary_defaultTerrainMaterial_triggerOnInit(self, context)
-    __swig_destroy__ = _TerrainSwig.delete_MaterialLibrary_defaultTerrainMaterial
+        return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_triggerOnInit(self, context)
+    __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_defaultTerrainMaterial
 
-# Register MaterialLibrary_defaultTerrainMaterial in _TerrainSwig:
-_TerrainSwig.MaterialLibrary_defaultTerrainMaterial_swigregister(MaterialLibrary_defaultTerrainMaterial)
+# Register Terrain_MaterialLibrary_defaultTerrainMaterial in _TerrainSwig:
+_TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_swigregister(Terrain_MaterialLibrary_defaultTerrainMaterial)
 
-class MaterialLibrary_dirt_1(TerrainMaterial):
+class Terrain_MaterialLibrary_dirt_1(Terrain_TerrainMaterial):
     r"""Proxy of C++ openplx::Terrain::MaterialLibrary::dirt_1 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__(MaterialLibrary_dirt_1 self) -> MaterialLibrary_dirt_1"""
-        _TerrainSwig.MaterialLibrary_dirt_1_swiginit(self, _TerrainSwig.new_MaterialLibrary_dirt_1())
+        r"""__init__(Terrain_MaterialLibrary_dirt_1 self) -> Terrain_MaterialLibrary_dirt_1"""
+        _TerrainSwig.Terrain_MaterialLibrary_dirt_1_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_dirt_1())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(MaterialLibrary_dirt_1 self, std::string const & key, Any value)
+        setDynamic(Terrain_MaterialLibrary_dirt_1 self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -3297,22 +3297,22 @@ class MaterialLibrary_dirt_1(TerrainMaterial):
         value: openplx::Core::Any &&
 
         """
-        return _TerrainSwig.MaterialLibrary_dirt_1_setDynamic(self, key, value)
+        return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(MaterialLibrary_dirt_1 self, std::string const & key) -> Any
+        getDynamic(Terrain_MaterialLibrary_dirt_1 self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _TerrainSwig.MaterialLibrary_dirt_1_getDynamic(self, key)
+        return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(MaterialLibrary_dirt_1 self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Terrain_MaterialLibrary_dirt_1 self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -3320,58 +3320,58 @@ class MaterialLibrary_dirt_1(TerrainMaterial):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _TerrainSwig.MaterialLibrary_dirt_1_callDynamic(self, key, args)
+        return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(MaterialLibrary_dirt_1 self, ObjectVector output)
+        extractObjectFieldsTo(Terrain_MaterialLibrary_dirt_1 self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _TerrainSwig.MaterialLibrary_dirt_1_extractObjectFieldsTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(MaterialLibrary_dirt_1 self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Terrain_MaterialLibrary_dirt_1 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 _TerrainSwig.MaterialLibrary_dirt_1_extractEntriesTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(MaterialLibrary_dirt_1 self, openplx::RuntimeContext const & context)
+        triggerOnInit(Terrain_MaterialLibrary_dirt_1 self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _TerrainSwig.MaterialLibrary_dirt_1_triggerOnInit(self, context)
-    __swig_destroy__ = _TerrainSwig.delete_MaterialLibrary_dirt_1
+        return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_triggerOnInit(self, context)
+    __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_dirt_1
 
-# Register MaterialLibrary_dirt_1 in _TerrainSwig:
-_TerrainSwig.MaterialLibrary_dirt_1_swigregister(MaterialLibrary_dirt_1)
+# Register Terrain_MaterialLibrary_dirt_1 in _TerrainSwig:
+_TerrainSwig.Terrain_MaterialLibrary_dirt_1_swigregister(Terrain_MaterialLibrary_dirt_1)
 
-class MaterialLibrary_gravel_1(TerrainMaterial):
+class Terrain_MaterialLibrary_gravel_1(Terrain_TerrainMaterial):
     r"""Proxy of C++ openplx::Terrain::MaterialLibrary::gravel_1 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__(MaterialLibrary_gravel_1 self) -> MaterialLibrary_gravel_1"""
-        _TerrainSwig.MaterialLibrary_gravel_1_swiginit(self, _TerrainSwig.new_MaterialLibrary_gravel_1())
+        r"""__init__(Terrain_MaterialLibrary_gravel_1 self) -> Terrain_MaterialLibrary_gravel_1"""
+        _TerrainSwig.Terrain_MaterialLibrary_gravel_1_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_gravel_1())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(MaterialLibrary_gravel_1 self, std::string const & key, Any value)
+        setDynamic(Terrain_MaterialLibrary_gravel_1 self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -3379,22 +3379,22 @@ class MaterialLibrary_gravel_1(TerrainMaterial):
         value: openplx::Core::Any &&
 
         """
-        return _TerrainSwig.MaterialLibrary_gravel_1_setDynamic(self, key, value)
+        return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(MaterialLibrary_gravel_1 self, std::string const & key) -> Any
+        getDynamic(Terrain_MaterialLibrary_gravel_1 self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _TerrainSwig.MaterialLibrary_gravel_1_getDynamic(self, key)
+        return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(MaterialLibrary_gravel_1 self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Terrain_MaterialLibrary_gravel_1 self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -3402,58 +3402,58 @@ class MaterialLibrary_gravel_1(TerrainMaterial):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _TerrainSwig.MaterialLibrary_gravel_1_callDynamic(self, key, args)
+        return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(MaterialLibrary_gravel_1 self, ObjectVector output)
+        extractObjectFieldsTo(Terrain_MaterialLibrary_gravel_1 self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _TerrainSwig.MaterialLibrary_gravel_1_extractObjectFieldsTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(MaterialLibrary_gravel_1 self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Terrain_MaterialLibrary_gravel_1 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 _TerrainSwig.MaterialLibrary_gravel_1_extractEntriesTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(MaterialLibrary_gravel_1 self, openplx::RuntimeContext const & context)
+        triggerOnInit(Terrain_MaterialLibrary_gravel_1 self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _TerrainSwig.MaterialLibrary_gravel_1_triggerOnInit(self, context)
-    __swig_destroy__ = _TerrainSwig.delete_MaterialLibrary_gravel_1
+        return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_triggerOnInit(self, context)
+    __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_gravel_1
 
-# Register MaterialLibrary_gravel_1 in _TerrainSwig:
-_TerrainSwig.MaterialLibrary_gravel_1_swigregister(MaterialLibrary_gravel_1)
+# Register Terrain_MaterialLibrary_gravel_1 in _TerrainSwig:
+_TerrainSwig.Terrain_MaterialLibrary_gravel_1_swigregister(Terrain_MaterialLibrary_gravel_1)
 
-class MaterialLibrary_iron_pellets(TerrainMaterial):
+class Terrain_MaterialLibrary_iron_pellets(Terrain_TerrainMaterial):
     r"""Proxy of C++ openplx::Terrain::MaterialLibrary::iron_pellets 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__(MaterialLibrary_iron_pellets self) -> MaterialLibrary_iron_pellets"""
-        _TerrainSwig.MaterialLibrary_iron_pellets_swiginit(self, _TerrainSwig.new_MaterialLibrary_iron_pellets())
+        r"""__init__(Terrain_MaterialLibrary_iron_pellets self) -> Terrain_MaterialLibrary_iron_pellets"""
+        _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_iron_pellets())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(MaterialLibrary_iron_pellets self, std::string const & key, Any value)
+        setDynamic(Terrain_MaterialLibrary_iron_pellets self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -3461,22 +3461,22 @@ class MaterialLibrary_iron_pellets(TerrainMaterial):
         value: openplx::Core::Any &&
 
         """
-        return _TerrainSwig.MaterialLibrary_iron_pellets_setDynamic(self, key, value)
+        return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(MaterialLibrary_iron_pellets self, std::string const & key) -> Any
+        getDynamic(Terrain_MaterialLibrary_iron_pellets self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _TerrainSwig.MaterialLibrary_iron_pellets_getDynamic(self, key)
+        return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(MaterialLibrary_iron_pellets self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Terrain_MaterialLibrary_iron_pellets self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -3484,58 +3484,58 @@ class MaterialLibrary_iron_pellets(TerrainMaterial):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _TerrainSwig.MaterialLibrary_iron_pellets_callDynamic(self, key, args)
+        return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(MaterialLibrary_iron_pellets self, ObjectVector output)
+        extractObjectFieldsTo(Terrain_MaterialLibrary_iron_pellets self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _TerrainSwig.MaterialLibrary_iron_pellets_extractObjectFieldsTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(MaterialLibrary_iron_pellets self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Terrain_MaterialLibrary_iron_pellets 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 _TerrainSwig.MaterialLibrary_iron_pellets_extractEntriesTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(MaterialLibrary_iron_pellets self, openplx::RuntimeContext const & context)
+        triggerOnInit(Terrain_MaterialLibrary_iron_pellets self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _TerrainSwig.MaterialLibrary_iron_pellets_triggerOnInit(self, context)
-    __swig_destroy__ = _TerrainSwig.delete_MaterialLibrary_iron_pellets
+        return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_triggerOnInit(self, context)
+    __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_iron_pellets
 
-# Register MaterialLibrary_iron_pellets in _TerrainSwig:
-_TerrainSwig.MaterialLibrary_iron_pellets_swigregister(MaterialLibrary_iron_pellets)
+# Register Terrain_MaterialLibrary_iron_pellets in _TerrainSwig:
+_TerrainSwig.Terrain_MaterialLibrary_iron_pellets_swigregister(Terrain_MaterialLibrary_iron_pellets)
 
-class MaterialLibrary_sand_1(TerrainMaterial):
+class Terrain_MaterialLibrary_sand_1(Terrain_TerrainMaterial):
     r"""Proxy of C++ openplx::Terrain::MaterialLibrary::sand_1 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__(MaterialLibrary_sand_1 self) -> MaterialLibrary_sand_1"""
-        _TerrainSwig.MaterialLibrary_sand_1_swiginit(self, _TerrainSwig.new_MaterialLibrary_sand_1())
+        r"""__init__(Terrain_MaterialLibrary_sand_1 self) -> Terrain_MaterialLibrary_sand_1"""
+        _TerrainSwig.Terrain_MaterialLibrary_sand_1_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_sand_1())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(MaterialLibrary_sand_1 self, std::string const & key, Any value)
+        setDynamic(Terrain_MaterialLibrary_sand_1 self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -3543,22 +3543,22 @@ class MaterialLibrary_sand_1(TerrainMaterial):
         value: openplx::Core::Any &&
 
         """
-        return _TerrainSwig.MaterialLibrary_sand_1_setDynamic(self, key, value)
+        return _TerrainSwig.Terrain_MaterialLibrary_sand_1_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(MaterialLibrary_sand_1 self, std::string const & key) -> Any
+        getDynamic(Terrain_MaterialLibrary_sand_1 self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _TerrainSwig.MaterialLibrary_sand_1_getDynamic(self, key)
+        return _TerrainSwig.Terrain_MaterialLibrary_sand_1_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(MaterialLibrary_sand_1 self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Terrain_MaterialLibrary_sand_1 self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -3566,58 +3566,58 @@ class MaterialLibrary_sand_1(TerrainMaterial):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _TerrainSwig.MaterialLibrary_sand_1_callDynamic(self, key, args)
+        return _TerrainSwig.Terrain_MaterialLibrary_sand_1_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(MaterialLibrary_sand_1 self, ObjectVector output)
+        extractObjectFieldsTo(Terrain_MaterialLibrary_sand_1 self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _TerrainSwig.MaterialLibrary_sand_1_extractObjectFieldsTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_sand_1_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(MaterialLibrary_sand_1 self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Terrain_MaterialLibrary_sand_1 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 _TerrainSwig.MaterialLibrary_sand_1_extractEntriesTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_sand_1_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(MaterialLibrary_sand_1 self, openplx::RuntimeContext const & context)
+        triggerOnInit(Terrain_MaterialLibrary_sand_1 self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _TerrainSwig.MaterialLibrary_sand_1_triggerOnInit(self, context)
-    __swig_destroy__ = _TerrainSwig.delete_MaterialLibrary_sand_1
+        return _TerrainSwig.Terrain_MaterialLibrary_sand_1_triggerOnInit(self, context)
+    __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_sand_1
 
-# Register MaterialLibrary_sand_1 in _TerrainSwig:
-_TerrainSwig.MaterialLibrary_sand_1_swigregister(MaterialLibrary_sand_1)
+# Register Terrain_MaterialLibrary_sand_1 in _TerrainSwig:
+_TerrainSwig.Terrain_MaterialLibrary_sand_1_swigregister(Terrain_MaterialLibrary_sand_1)
 
-class MaterialLibrary_wet_sand(TerrainMaterial):
+class Terrain_MaterialLibrary_wet_sand(Terrain_TerrainMaterial):
     r"""Proxy of C++ openplx::Terrain::MaterialLibrary::wet_sand 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__(MaterialLibrary_wet_sand self) -> MaterialLibrary_wet_sand"""
-        _TerrainSwig.MaterialLibrary_wet_sand_swiginit(self, _TerrainSwig.new_MaterialLibrary_wet_sand())
+        r"""__init__(Terrain_MaterialLibrary_wet_sand self) -> Terrain_MaterialLibrary_wet_sand"""
+        _TerrainSwig.Terrain_MaterialLibrary_wet_sand_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_wet_sand())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(MaterialLibrary_wet_sand self, std::string const & key, Any value)
+        setDynamic(Terrain_MaterialLibrary_wet_sand self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -3625,22 +3625,22 @@ class MaterialLibrary_wet_sand(TerrainMaterial):
         value: openplx::Core::Any &&
 
         """
-        return _TerrainSwig.MaterialLibrary_wet_sand_setDynamic(self, key, value)
+        return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(MaterialLibrary_wet_sand self, std::string const & key) -> Any
+        getDynamic(Terrain_MaterialLibrary_wet_sand self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _TerrainSwig.MaterialLibrary_wet_sand_getDynamic(self, key)
+        return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(MaterialLibrary_wet_sand self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Terrain_MaterialLibrary_wet_sand self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -3648,74 +3648,74 @@ class MaterialLibrary_wet_sand(TerrainMaterial):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _TerrainSwig.MaterialLibrary_wet_sand_callDynamic(self, key, args)
+        return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(MaterialLibrary_wet_sand self, ObjectVector output)
+        extractObjectFieldsTo(Terrain_MaterialLibrary_wet_sand self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _TerrainSwig.MaterialLibrary_wet_sand_extractObjectFieldsTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(MaterialLibrary_wet_sand self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Terrain_MaterialLibrary_wet_sand 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 _TerrainSwig.MaterialLibrary_wet_sand_extractEntriesTo(self, output)
+        return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(MaterialLibrary_wet_sand self, openplx::RuntimeContext const & context)
+        triggerOnInit(Terrain_MaterialLibrary_wet_sand self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _TerrainSwig.MaterialLibrary_wet_sand_triggerOnInit(self, context)
-    __swig_destroy__ = _TerrainSwig.delete_MaterialLibrary_wet_sand
+        return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_triggerOnInit(self, context)
+    __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_wet_sand
 
-# Register MaterialLibrary_wet_sand in _TerrainSwig:
-_TerrainSwig.MaterialLibrary_wet_sand_swigregister(MaterialLibrary_wet_sand)
+# Register Terrain_MaterialLibrary_wet_sand in _TerrainSwig:
+_TerrainSwig.Terrain_MaterialLibrary_wet_sand_swigregister(Terrain_MaterialLibrary_wet_sand)
 
-class Shovel(openplx.Core.Object):
+class Terrain_Shovel(openplx.Core.Object):
     r"""Proxy of C++ openplx::Terrain::Shovel 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__(Shovel self) -> Shovel"""
-        _TerrainSwig.Shovel_swiginit(self, _TerrainSwig.new_Shovel())
+        r"""__init__(Terrain_Shovel self) -> Terrain_Shovel"""
+        _TerrainSwig.Terrain_Shovel_swiginit(self, _TerrainSwig.new_Terrain_Shovel())
 
     def body(self):
-        r"""body(Shovel self) -> std::shared_ptr< openplx::Physics3D::Bodies::RigidBody >"""
-        return _TerrainSwig.Shovel_body(self)
+        r"""body(Terrain_Shovel self) -> std::shared_ptr< openplx::Physics3D::Bodies::RigidBody >"""
+        return _TerrainSwig.Terrain_Shovel_body(self)
 
     def top_edge(self):
-        r"""top_edge(Shovel self) -> std::shared_ptr< openplx::Math::Line >"""
-        return _TerrainSwig.Shovel_top_edge(self)
+        r"""top_edge(Terrain_Shovel self) -> std::shared_ptr< openplx::Math::Line >"""
+        return _TerrainSwig.Terrain_Shovel_top_edge(self)
 
     def cutting_edge(self):
-        r"""cutting_edge(Shovel self) -> std::shared_ptr< openplx::Math::Line >"""
-        return _TerrainSwig.Shovel_cutting_edge(self)
+        r"""cutting_edge(Terrain_Shovel self) -> std::shared_ptr< openplx::Math::Line >"""
+        return _TerrainSwig.Terrain_Shovel_cutting_edge(self)
 
     def cutting_direction(self):
-        r"""cutting_direction(Shovel self) -> std::shared_ptr< openplx::Math::Vec3 >"""
-        return _TerrainSwig.Shovel_cutting_direction(self)
+        r"""cutting_direction(Terrain_Shovel self) -> std::shared_ptr< openplx::Math::Vec3 >"""
+        return _TerrainSwig.Terrain_Shovel_cutting_direction(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Shovel self, std::string const & key, Any value)
+        setDynamic(Terrain_Shovel self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -3723,22 +3723,22 @@ class Shovel(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _TerrainSwig.Shovel_setDynamic(self, key, value)
+        return _TerrainSwig.Terrain_Shovel_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Shovel self, std::string const & key) -> Any
+        getDynamic(Terrain_Shovel self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _TerrainSwig.Shovel_getDynamic(self, key)
+        return _TerrainSwig.Terrain_Shovel_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Shovel self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Terrain_Shovel self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -3746,78 +3746,78 @@ class Shovel(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _TerrainSwig.Shovel_callDynamic(self, key, args)
+        return _TerrainSwig.Terrain_Shovel_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Shovel self, ObjectVector output)
+        extractObjectFieldsTo(Terrain_Shovel self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _TerrainSwig.Shovel_extractObjectFieldsTo(self, output)
+        return _TerrainSwig.Terrain_Shovel_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Shovel self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Terrain_Shovel 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 _TerrainSwig.Shovel_extractEntriesTo(self, output)
+        return _TerrainSwig.Terrain_Shovel_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Shovel self, openplx::RuntimeContext const & context)
+        triggerOnInit(Terrain_Shovel self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _TerrainSwig.Shovel_triggerOnInit(self, context)
-    __swig_destroy__ = _TerrainSwig.delete_Shovel
+        return _TerrainSwig.Terrain_Shovel_triggerOnInit(self, context)
+    __swig_destroy__ = _TerrainSwig.delete_Terrain_Shovel
 
-# Register Shovel in _TerrainSwig:
-_TerrainSwig.Shovel_swigregister(Shovel)
+# Register Terrain_Shovel in _TerrainSwig:
+_TerrainSwig.Terrain_Shovel_swigregister(Terrain_Shovel)
 
-class Terrain(openplx.Physics3D.Bodies_Body):
+class Terrain_Terrain(openplx.Physics3D.Physics3D_Bodies_Body):
     r"""Proxy of C++ openplx::Terrain::Terrain 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__(Terrain self) -> Terrain"""
-        _TerrainSwig.Terrain_swiginit(self, _TerrainSwig.new_Terrain())
+        r"""__init__(Terrain_Terrain self) -> Terrain_Terrain"""
+        _TerrainSwig.Terrain_Terrain_swiginit(self, _TerrainSwig.new_Terrain_Terrain())
 
     def num_elements_x(self):
-        r"""num_elements_x(Terrain self) -> int64_t"""
-        return _TerrainSwig.Terrain_num_elements_x(self)
+        r"""num_elements_x(Terrain_Terrain self) -> int64_t"""
+        return _TerrainSwig.Terrain_Terrain_num_elements_x(self)
 
     def num_elements_y(self):
-        r"""num_elements_y(Terrain self) -> int64_t"""
-        return _TerrainSwig.Terrain_num_elements_y(self)
+        r"""num_elements_y(Terrain_Terrain self) -> int64_t"""
+        return _TerrainSwig.Terrain_Terrain_num_elements_y(self)
 
     def element_size(self):
-        r"""element_size(Terrain self) -> double"""
-        return _TerrainSwig.Terrain_element_size(self)
+        r"""element_size(Terrain_Terrain self) -> double"""
+        return _TerrainSwig.Terrain_Terrain_element_size(self)
 
     def max_depth(self):
-        r"""max_depth(Terrain self) -> double"""
-        return _TerrainSwig.Terrain_max_depth(self)
+        r"""max_depth(Terrain_Terrain self) -> double"""
+        return _TerrainSwig.Terrain_Terrain_max_depth(self)
 
     def material(self):
-        r"""material(Terrain self) -> std::shared_ptr< openplx::Terrain::TerrainMaterial >"""
-        return _TerrainSwig.Terrain_material(self)
+        r"""material(Terrain_Terrain self) -> std::shared_ptr< openplx::Terrain::TerrainMaterial >"""
+        return _TerrainSwig.Terrain_Terrain_material(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Terrain self, std::string const & key, Any value)
+        setDynamic(Terrain_Terrain self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -3825,22 +3825,22 @@ class Terrain(openplx.Physics3D.Bodies_Body):
         value: openplx::Core::Any &&
 
         """
-        return _TerrainSwig.Terrain_setDynamic(self, key, value)
+        return _TerrainSwig.Terrain_Terrain_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Terrain self, std::string const & key) -> Any
+        getDynamic(Terrain_Terrain self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _TerrainSwig.Terrain_getDynamic(self, key)
+        return _TerrainSwig.Terrain_Terrain_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Terrain self, std::string const & key, AnyVector args) -> Any
+        callDynamic(Terrain_Terrain self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -3848,44 +3848,44 @@ class Terrain(openplx.Physics3D.Bodies_Body):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _TerrainSwig.Terrain_callDynamic(self, key, args)
+        return _TerrainSwig.Terrain_Terrain_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Terrain self, ObjectVector output)
+        extractObjectFieldsTo(Terrain_Terrain self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _TerrainSwig.Terrain_extractObjectFieldsTo(self, output)
+        return _TerrainSwig.Terrain_Terrain_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Terrain self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(Terrain_Terrain 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 _TerrainSwig.Terrain_extractEntriesTo(self, output)
+        return _TerrainSwig.Terrain_Terrain_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Terrain self, openplx::RuntimeContext const & context)
+        triggerOnInit(Terrain_Terrain self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _TerrainSwig.Terrain_triggerOnInit(self, context)
-    __swig_destroy__ = _TerrainSwig.delete_Terrain
+        return _TerrainSwig.Terrain_Terrain_triggerOnInit(self, context)
+    __swig_destroy__ = _TerrainSwig.delete_Terrain_Terrain
 
-# Register Terrain in _TerrainSwig:
-_TerrainSwig.Terrain_swigregister(Terrain)
+# Register Terrain_Terrain in _TerrainSwig:
+_TerrainSwig.Terrain_Terrain_swigregister(Terrain_Terrain)