agx-openplx 0.16.8__cp39-cp39-win_amd64.whl → 0.16.10__cp39-cp39-win_amd64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (23) hide show
  1. {agx_openplx-0.16.8.dist-info → agx_openplx-0.16.10.dist-info}/METADATA +2 -2
  2. agx_openplx-0.16.10.dist-info/RECORD +41 -0
  3. openplx/DriveTrain.py +2415 -2415
  4. openplx/Physics.py +10812 -10812
  5. openplx/Physics3D.py +10927 -10927
  6. openplx/Terrain.py +1035 -1035
  7. openplx/_AgxOpenPlxPyApi.cp39-win_amd64.pyd +0 -0
  8. openplx/_CorePythonSwig.cp39-win_amd64.pyd +0 -0
  9. openplx/_DriveTrainSwig.cp39-win_amd64.pyd +0 -0
  10. openplx/_MathSwig.cp39-win_amd64.pyd +0 -0
  11. openplx/_Physics1DSwig.cp39-win_amd64.pyd +0 -0
  12. openplx/_Physics3DSwig.cp39-win_amd64.pyd +0 -0
  13. openplx/_PhysicsSwig.cp39-win_amd64.pyd +0 -0
  14. openplx/_RoboticsSwig.cp39-win_amd64.pyd +0 -0
  15. openplx/_SimulationSwig.cp39-win_amd64.pyd +0 -0
  16. openplx/_TerrainSwig.cp39-win_amd64.pyd +0 -0
  17. openplx/_UrdfSwig.cp39-win_amd64.pyd +0 -0
  18. openplx/_VehiclesSwig.cp39-win_amd64.pyd +0 -0
  19. openplx/_VisualsSwig.cp39-win_amd64.pyd +0 -0
  20. openplx/__init__.py +1 -1
  21. agx_openplx-0.16.8.dist-info/RECORD +0 -41
  22. {agx_openplx-0.16.8.dist-info → agx_openplx-0.16.10.dist-info}/WHEEL +0 -0
  23. {agx_openplx-0.16.8.dist-info → agx_openplx-0.16.10.dist-info}/entry_points.txt +0 -0
openplx/Terrain.py CHANGED
@@ -229,2885 +229,2885 @@ import openplx.Core
229
229
  import openplx.Math
230
230
  import openplx.Physics
231
231
  import openplx.Physics3D
232
- class Terrain_MaterialLibrary_defaultTerrainMaterial_Vector(object):
233
- r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > > class."""
232
+ class Terrain_Shovel_Vector(object):
233
+ r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::Shovel > > class."""
234
234
 
235
235
  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
236
236
  __repr__ = _swig_repr
237
237
 
238
238
  def iterator(self):
239
- r"""iterator(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> SwigPyIterator"""
240
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_iterator(self)
239
+ r"""iterator(Terrain_Shovel_Vector self) -> SwigPyIterator"""
240
+ return _TerrainSwig.Terrain_Shovel_Vector_iterator(self)
241
241
  def __iter__(self):
242
242
  return self.iterator()
243
243
 
244
244
  def __nonzero__(self):
245
- r"""__nonzero__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> bool"""
246
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___nonzero__(self)
245
+ r"""__nonzero__(Terrain_Shovel_Vector self) -> bool"""
246
+ return _TerrainSwig.Terrain_Shovel_Vector___nonzero__(self)
247
247
 
248
248
  def __bool__(self):
249
- r"""__bool__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> bool"""
250
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___bool__(self)
249
+ r"""__bool__(Terrain_Shovel_Vector self) -> bool"""
250
+ return _TerrainSwig.Terrain_Shovel_Vector___bool__(self)
251
251
 
252
252
  def __len__(self):
253
- r"""__len__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type"""
254
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___len__(self)
253
+ r"""__len__(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type"""
254
+ return _TerrainSwig.Terrain_Shovel_Vector___len__(self)
255
255
 
256
256
  def __getslice__(self, i, j):
257
257
  r"""
258
- __getslice__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type j) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
258
+ __getslice__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type j) -> Terrain_Shovel_Vector
259
259
 
260
260
  Parameters
261
261
  ----------
262
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
263
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
262
+ i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
263
+ j: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
264
264
 
265
265
  """
266
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___getslice__(self, i, j)
266
+ return _TerrainSwig.Terrain_Shovel_Vector___getslice__(self, i, j)
267
267
 
268
268
  def __setslice__(self, *args):
269
269
  r"""
270
- __setslice__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type j)
270
+ __setslice__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type j)
271
271
 
272
272
  Parameters
273
273
  ----------
274
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
275
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
274
+ i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
275
+ j: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
276
276
 
277
- __setslice__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type j, Terrain_MaterialLibrary_defaultTerrainMaterial_Vector v)
277
+ __setslice__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type j, Terrain_Shovel_Vector v)
278
278
 
279
279
  Parameters
280
280
  ----------
281
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
282
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
283
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > > > const &
281
+ i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
282
+ j: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
283
+ v: std::vector< std::shared_ptr< openplx::Terrain::Shovel >,std::allocator< std::shared_ptr< openplx::Terrain::Shovel > > > const &
284
284
 
285
285
  """
286
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___setslice__(self, *args)
286
+ return _TerrainSwig.Terrain_Shovel_Vector___setslice__(self, *args)
287
287
 
288
288
  def __delslice__(self, i, j):
289
289
  r"""
290
- __delslice__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type j)
290
+ __delslice__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type j)
291
291
 
292
292
  Parameters
293
293
  ----------
294
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
295
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
294
+ i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
295
+ j: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
296
296
 
297
297
  """
298
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___delslice__(self, i, j)
298
+ return _TerrainSwig.Terrain_Shovel_Vector___delslice__(self, i, j)
299
299
 
300
300
  def __delitem__(self, *args):
301
301
  r"""
302
- __delitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i)
302
+ __delitem__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i)
303
303
 
304
304
  Parameters
305
305
  ----------
306
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
306
+ i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
307
307
 
308
- __delitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, PySliceObject * slice)
308
+ __delitem__(Terrain_Shovel_Vector self, PySliceObject * slice)
309
309
 
310
310
  Parameters
311
311
  ----------
312
312
  slice: PySliceObject *
313
313
 
314
314
  """
315
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___delitem__(self, *args)
315
+ return _TerrainSwig.Terrain_Shovel_Vector___delitem__(self, *args)
316
316
 
317
317
  def __getitem__(self, *args):
318
318
  r"""
319
- __getitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
319
+ __getitem__(Terrain_Shovel_Vector self, PySliceObject * slice) -> Terrain_Shovel_Vector
320
320
 
321
321
  Parameters
322
322
  ----------
323
323
  slice: PySliceObject *
324
324
 
325
- __getitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
325
+ __getitem__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
326
326
 
327
327
  Parameters
328
328
  ----------
329
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
329
+ i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
330
330
 
331
331
  """
332
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___getitem__(self, *args)
332
+ return _TerrainSwig.Terrain_Shovel_Vector___getitem__(self, *args)
333
333
 
334
334
  def __setitem__(self, *args):
335
335
  r"""
336
- __setitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_defaultTerrainMaterial_Vector v)
336
+ __setitem__(Terrain_Shovel_Vector self, PySliceObject * slice, Terrain_Shovel_Vector v)
337
337
 
338
338
  Parameters
339
339
  ----------
340
340
  slice: PySliceObject *
341
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > > > const &
341
+ v: std::vector< std::shared_ptr< openplx::Terrain::Shovel >,std::allocator< std::shared_ptr< openplx::Terrain::Shovel > > > const &
342
342
 
343
- __setitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, PySliceObject * slice)
343
+ __setitem__(Terrain_Shovel_Vector self, PySliceObject * slice)
344
344
 
345
345
  Parameters
346
346
  ----------
347
347
  slice: PySliceObject *
348
348
 
349
- __setitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
349
+ __setitem__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
350
350
 
351
351
  Parameters
352
352
  ----------
353
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
354
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
353
+ i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
354
+ x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
355
355
 
356
356
  """
357
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___setitem__(self, *args)
357
+ return _TerrainSwig.Terrain_Shovel_Vector___setitem__(self, *args)
358
358
 
359
359
  def pop(self):
360
- r"""pop(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type"""
361
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_pop(self)
360
+ r"""pop(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type"""
361
+ return _TerrainSwig.Terrain_Shovel_Vector_pop(self)
362
362
 
363
363
  def append(self, x):
364
364
  r"""
365
- append(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
365
+ append(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
366
366
 
367
367
  Parameters
368
368
  ----------
369
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
369
+ x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
370
370
 
371
371
  """
372
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_append(self, x)
372
+ return _TerrainSwig.Terrain_Shovel_Vector_append(self, x)
373
373
 
374
374
  def empty(self):
375
- r"""empty(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> bool"""
376
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_empty(self)
375
+ r"""empty(Terrain_Shovel_Vector self) -> bool"""
376
+ return _TerrainSwig.Terrain_Shovel_Vector_empty(self)
377
377
 
378
378
  def size(self):
379
- r"""size(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type"""
380
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_size(self)
379
+ r"""size(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type"""
380
+ return _TerrainSwig.Terrain_Shovel_Vector_size(self)
381
381
 
382
382
  def swap(self, v):
383
383
  r"""
384
- swap(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, Terrain_MaterialLibrary_defaultTerrainMaterial_Vector v)
384
+ swap(Terrain_Shovel_Vector self, Terrain_Shovel_Vector v)
385
385
 
386
386
  Parameters
387
387
  ----------
388
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > > &
388
+ v: std::vector< std::shared_ptr< openplx::Terrain::Shovel > > &
389
389
 
390
390
  """
391
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_swap(self, v)
391
+ return _TerrainSwig.Terrain_Shovel_Vector_swap(self, v)
392
392
 
393
393
  def begin(self):
394
- r"""begin(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator"""
395
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_begin(self)
394
+ r"""begin(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator"""
395
+ return _TerrainSwig.Terrain_Shovel_Vector_begin(self)
396
396
 
397
397
  def end(self):
398
- r"""end(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator"""
399
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_end(self)
398
+ r"""end(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator"""
399
+ return _TerrainSwig.Terrain_Shovel_Vector_end(self)
400
400
 
401
401
  def rbegin(self):
402
- r"""rbegin(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::reverse_iterator"""
403
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_rbegin(self)
402
+ r"""rbegin(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::reverse_iterator"""
403
+ return _TerrainSwig.Terrain_Shovel_Vector_rbegin(self)
404
404
 
405
405
  def rend(self):
406
- r"""rend(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::reverse_iterator"""
407
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_rend(self)
406
+ r"""rend(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::reverse_iterator"""
407
+ return _TerrainSwig.Terrain_Shovel_Vector_rend(self)
408
408
 
409
409
  def clear(self):
410
- r"""clear(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self)"""
411
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_clear(self)
410
+ r"""clear(Terrain_Shovel_Vector self)"""
411
+ return _TerrainSwig.Terrain_Shovel_Vector_clear(self)
412
412
 
413
413
  def get_allocator(self):
414
- r"""get_allocator(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::allocator_type"""
415
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_get_allocator(self)
414
+ r"""get_allocator(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::allocator_type"""
415
+ return _TerrainSwig.Terrain_Shovel_Vector_get_allocator(self)
416
416
 
417
417
  def pop_back(self):
418
- r"""pop_back(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self)"""
419
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_pop_back(self)
418
+ r"""pop_back(Terrain_Shovel_Vector self)"""
419
+ return _TerrainSwig.Terrain_Shovel_Vector_pop_back(self)
420
420
 
421
421
  def erase(self, *args):
422
422
  r"""
423
- erase(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
423
+ erase(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
424
424
 
425
425
  Parameters
426
426
  ----------
427
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
427
+ pos: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
428
428
 
429
- erase(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
429
+ erase(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
430
430
 
431
431
  Parameters
432
432
  ----------
433
- first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
434
- last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
433
+ first: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
434
+ last: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
435
435
 
436
436
  """
437
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_erase(self, *args)
437
+ return _TerrainSwig.Terrain_Shovel_Vector_erase(self, *args)
438
438
 
439
439
  def __init__(self, *args):
440
440
  r"""
441
- __init__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
442
- __init__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, Terrain_MaterialLibrary_defaultTerrainMaterial_Vector other) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
441
+ __init__(Terrain_Shovel_Vector self) -> Terrain_Shovel_Vector
442
+ __init__(Terrain_Shovel_Vector self, Terrain_Shovel_Vector other) -> Terrain_Shovel_Vector
443
443
 
444
444
  Parameters
445
445
  ----------
446
- other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > > const &
446
+ other: std::vector< std::shared_ptr< openplx::Terrain::Shovel > > const &
447
447
 
448
- __init__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type size) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
448
+ __init__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type size) -> Terrain_Shovel_Vector
449
449
 
450
450
  Parameters
451
451
  ----------
452
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
452
+ size: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
453
453
 
454
- __init__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & value) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
454
+ __init__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & value) -> Terrain_Shovel_Vector
455
455
 
456
456
  Parameters
457
457
  ----------
458
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
459
- value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
458
+ size: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
459
+ value: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
460
460
 
461
461
  """
462
- _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_defaultTerrainMaterial_Vector(*args))
462
+ _TerrainSwig.Terrain_Shovel_Vector_swiginit(self, _TerrainSwig.new_Terrain_Shovel_Vector(*args))
463
463
 
464
464
  def push_back(self, x):
465
465
  r"""
466
- push_back(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
466
+ push_back(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
467
467
 
468
468
  Parameters
469
469
  ----------
470
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
470
+ x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
471
471
 
472
472
  """
473
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_push_back(self, x)
473
+ return _TerrainSwig.Terrain_Shovel_Vector_push_back(self, x)
474
474
 
475
475
  def front(self):
476
- r"""front(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &"""
477
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_front(self)
476
+ r"""front(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &"""
477
+ return _TerrainSwig.Terrain_Shovel_Vector_front(self)
478
478
 
479
479
  def back(self):
480
- r"""back(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &"""
481
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_back(self)
480
+ r"""back(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &"""
481
+ return _TerrainSwig.Terrain_Shovel_Vector_back(self)
482
482
 
483
483
  def assign(self, n, x):
484
484
  r"""
485
- assign(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
485
+ assign(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
486
486
 
487
487
  Parameters
488
488
  ----------
489
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
490
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
489
+ n: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
490
+ x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
491
491
 
492
492
  """
493
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_assign(self, n, x)
493
+ return _TerrainSwig.Terrain_Shovel_Vector_assign(self, n, x)
494
494
 
495
495
  def resize(self, *args):
496
496
  r"""
497
- resize(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type new_size)
497
+ resize(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type new_size)
498
498
 
499
499
  Parameters
500
500
  ----------
501
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
501
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
502
502
 
503
- resize(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
503
+ resize(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
504
504
 
505
505
  Parameters
506
506
  ----------
507
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
508
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
507
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
508
+ x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
509
509
 
510
510
  """
511
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_resize(self, *args)
511
+ return _TerrainSwig.Terrain_Shovel_Vector_resize(self, *args)
512
512
 
513
513
  def insert(self, *args):
514
514
  r"""
515
- insert(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
515
+ insert(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
516
516
 
517
517
  Parameters
518
518
  ----------
519
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
520
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
519
+ pos: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
520
+ x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
521
521
 
522
- insert(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
522
+ insert(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
523
523
 
524
524
  Parameters
525
525
  ----------
526
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
527
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
528
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
526
+ pos: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
527
+ n: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
528
+ x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
529
529
 
530
530
  """
531
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_insert(self, *args)
531
+ return _TerrainSwig.Terrain_Shovel_Vector_insert(self, *args)
532
532
 
533
533
  def reserve(self, n):
534
534
  r"""
535
- reserve(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type n)
535
+ reserve(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type n)
536
536
 
537
537
  Parameters
538
538
  ----------
539
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
539
+ n: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
540
540
 
541
541
  """
542
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_reserve(self, n)
542
+ return _TerrainSwig.Terrain_Shovel_Vector_reserve(self, n)
543
543
 
544
544
  def capacity(self):
545
- r"""capacity(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type"""
546
- return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_capacity(self)
547
- __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
545
+ r"""capacity(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type"""
546
+ return _TerrainSwig.Terrain_Shovel_Vector_capacity(self)
547
+ __swig_destroy__ = _TerrainSwig.delete_Terrain_Shovel_Vector
548
548
 
549
- # Register Terrain_MaterialLibrary_defaultTerrainMaterial_Vector in _TerrainSwig:
550
- _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_swigregister(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector)
549
+ # Register Terrain_Shovel_Vector in _TerrainSwig:
550
+ _TerrainSwig.Terrain_Shovel_Vector_swigregister(Terrain_Shovel_Vector)
551
551
 
552
- class Terrain_MaterialLibrary_dirt_1_Vector(object):
553
- r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > > class."""
552
+ class Terrain_Terrain_Vector(object):
553
+ r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::Terrain > > class."""
554
554
 
555
555
  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
556
556
  __repr__ = _swig_repr
557
557
 
558
558
  def iterator(self):
559
- r"""iterator(Terrain_MaterialLibrary_dirt_1_Vector self) -> SwigPyIterator"""
560
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_iterator(self)
559
+ r"""iterator(Terrain_Terrain_Vector self) -> SwigPyIterator"""
560
+ return _TerrainSwig.Terrain_Terrain_Vector_iterator(self)
561
561
  def __iter__(self):
562
562
  return self.iterator()
563
563
 
564
564
  def __nonzero__(self):
565
- r"""__nonzero__(Terrain_MaterialLibrary_dirt_1_Vector self) -> bool"""
566
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___nonzero__(self)
565
+ r"""__nonzero__(Terrain_Terrain_Vector self) -> bool"""
566
+ return _TerrainSwig.Terrain_Terrain_Vector___nonzero__(self)
567
567
 
568
568
  def __bool__(self):
569
- r"""__bool__(Terrain_MaterialLibrary_dirt_1_Vector self) -> bool"""
570
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___bool__(self)
569
+ r"""__bool__(Terrain_Terrain_Vector self) -> bool"""
570
+ return _TerrainSwig.Terrain_Terrain_Vector___bool__(self)
571
571
 
572
572
  def __len__(self):
573
- r"""__len__(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type"""
574
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___len__(self)
573
+ r"""__len__(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type"""
574
+ return _TerrainSwig.Terrain_Terrain_Vector___len__(self)
575
575
 
576
576
  def __getslice__(self, i, j):
577
577
  r"""
578
- __getslice__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type j) -> Terrain_MaterialLibrary_dirt_1_Vector
578
+ __getslice__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type j) -> Terrain_Terrain_Vector
579
579
 
580
580
  Parameters
581
581
  ----------
582
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
583
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
582
+ i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
583
+ j: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
584
584
 
585
585
  """
586
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___getslice__(self, i, j)
586
+ return _TerrainSwig.Terrain_Terrain_Vector___getslice__(self, i, j)
587
587
 
588
588
  def __setslice__(self, *args):
589
589
  r"""
590
- __setslice__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type j)
590
+ __setslice__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type j)
591
591
 
592
592
  Parameters
593
593
  ----------
594
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
595
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
594
+ i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
595
+ j: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
596
596
 
597
- __setslice__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type j, Terrain_MaterialLibrary_dirt_1_Vector v)
597
+ __setslice__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type j, Terrain_Terrain_Vector v)
598
598
 
599
599
  Parameters
600
600
  ----------
601
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
602
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
603
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > > > const &
601
+ i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
602
+ j: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
603
+ v: std::vector< std::shared_ptr< openplx::Terrain::Terrain >,std::allocator< std::shared_ptr< openplx::Terrain::Terrain > > > const &
604
604
 
605
605
  """
606
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___setslice__(self, *args)
606
+ return _TerrainSwig.Terrain_Terrain_Vector___setslice__(self, *args)
607
607
 
608
608
  def __delslice__(self, i, j):
609
609
  r"""
610
- __delslice__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type j)
610
+ __delslice__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type j)
611
611
 
612
612
  Parameters
613
613
  ----------
614
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
615
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
614
+ i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
615
+ j: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
616
616
 
617
617
  """
618
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___delslice__(self, i, j)
618
+ return _TerrainSwig.Terrain_Terrain_Vector___delslice__(self, i, j)
619
619
 
620
620
  def __delitem__(self, *args):
621
621
  r"""
622
- __delitem__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i)
622
+ __delitem__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i)
623
623
 
624
624
  Parameters
625
625
  ----------
626
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
626
+ i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
627
627
 
628
- __delitem__(Terrain_MaterialLibrary_dirt_1_Vector self, PySliceObject * slice)
628
+ __delitem__(Terrain_Terrain_Vector self, PySliceObject * slice)
629
629
 
630
630
  Parameters
631
631
  ----------
632
632
  slice: PySliceObject *
633
633
 
634
634
  """
635
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___delitem__(self, *args)
635
+ return _TerrainSwig.Terrain_Terrain_Vector___delitem__(self, *args)
636
636
 
637
637
  def __getitem__(self, *args):
638
638
  r"""
639
- __getitem__(Terrain_MaterialLibrary_dirt_1_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_dirt_1_Vector
639
+ __getitem__(Terrain_Terrain_Vector self, PySliceObject * slice) -> Terrain_Terrain_Vector
640
640
 
641
641
  Parameters
642
642
  ----------
643
643
  slice: PySliceObject *
644
644
 
645
- __getitem__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
645
+ __getitem__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
646
646
 
647
647
  Parameters
648
648
  ----------
649
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
649
+ i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
650
650
 
651
651
  """
652
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___getitem__(self, *args)
652
+ return _TerrainSwig.Terrain_Terrain_Vector___getitem__(self, *args)
653
653
 
654
654
  def __setitem__(self, *args):
655
655
  r"""
656
- __setitem__(Terrain_MaterialLibrary_dirt_1_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_dirt_1_Vector v)
656
+ __setitem__(Terrain_Terrain_Vector self, PySliceObject * slice, Terrain_Terrain_Vector v)
657
657
 
658
658
  Parameters
659
659
  ----------
660
660
  slice: PySliceObject *
661
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > > > const &
661
+ v: std::vector< std::shared_ptr< openplx::Terrain::Terrain >,std::allocator< std::shared_ptr< openplx::Terrain::Terrain > > > const &
662
662
 
663
- __setitem__(Terrain_MaterialLibrary_dirt_1_Vector self, PySliceObject * slice)
663
+ __setitem__(Terrain_Terrain_Vector self, PySliceObject * slice)
664
664
 
665
665
  Parameters
666
666
  ----------
667
667
  slice: PySliceObject *
668
668
 
669
- __setitem__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
669
+ __setitem__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
670
670
 
671
671
  Parameters
672
672
  ----------
673
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
674
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
673
+ i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
674
+ x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
675
675
 
676
676
  """
677
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___setitem__(self, *args)
677
+ return _TerrainSwig.Terrain_Terrain_Vector___setitem__(self, *args)
678
678
 
679
679
  def pop(self):
680
- r"""pop(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type"""
681
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_pop(self)
680
+ r"""pop(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type"""
681
+ return _TerrainSwig.Terrain_Terrain_Vector_pop(self)
682
682
 
683
683
  def append(self, x):
684
684
  r"""
685
- append(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
685
+ append(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
686
686
 
687
687
  Parameters
688
688
  ----------
689
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
689
+ x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
690
690
 
691
691
  """
692
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_append(self, x)
692
+ return _TerrainSwig.Terrain_Terrain_Vector_append(self, x)
693
693
 
694
694
  def empty(self):
695
- r"""empty(Terrain_MaterialLibrary_dirt_1_Vector self) -> bool"""
696
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_empty(self)
695
+ r"""empty(Terrain_Terrain_Vector self) -> bool"""
696
+ return _TerrainSwig.Terrain_Terrain_Vector_empty(self)
697
697
 
698
698
  def size(self):
699
- r"""size(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type"""
700
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_size(self)
699
+ r"""size(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type"""
700
+ return _TerrainSwig.Terrain_Terrain_Vector_size(self)
701
701
 
702
702
  def swap(self, v):
703
703
  r"""
704
- swap(Terrain_MaterialLibrary_dirt_1_Vector self, Terrain_MaterialLibrary_dirt_1_Vector v)
704
+ swap(Terrain_Terrain_Vector self, Terrain_Terrain_Vector v)
705
705
 
706
706
  Parameters
707
707
  ----------
708
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > > &
708
+ v: std::vector< std::shared_ptr< openplx::Terrain::Terrain > > &
709
709
 
710
710
  """
711
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_swap(self, v)
711
+ return _TerrainSwig.Terrain_Terrain_Vector_swap(self, v)
712
712
 
713
713
  def begin(self):
714
- r"""begin(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator"""
715
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_begin(self)
714
+ r"""begin(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator"""
715
+ return _TerrainSwig.Terrain_Terrain_Vector_begin(self)
716
716
 
717
717
  def end(self):
718
- r"""end(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator"""
719
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_end(self)
718
+ r"""end(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator"""
719
+ return _TerrainSwig.Terrain_Terrain_Vector_end(self)
720
720
 
721
721
  def rbegin(self):
722
- r"""rbegin(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::reverse_iterator"""
723
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_rbegin(self)
722
+ r"""rbegin(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::reverse_iterator"""
723
+ return _TerrainSwig.Terrain_Terrain_Vector_rbegin(self)
724
724
 
725
725
  def rend(self):
726
- r"""rend(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::reverse_iterator"""
727
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_rend(self)
726
+ r"""rend(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::reverse_iterator"""
727
+ return _TerrainSwig.Terrain_Terrain_Vector_rend(self)
728
728
 
729
729
  def clear(self):
730
- r"""clear(Terrain_MaterialLibrary_dirt_1_Vector self)"""
731
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_clear(self)
730
+ r"""clear(Terrain_Terrain_Vector self)"""
731
+ return _TerrainSwig.Terrain_Terrain_Vector_clear(self)
732
732
 
733
733
  def get_allocator(self):
734
- r"""get_allocator(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::allocator_type"""
735
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_get_allocator(self)
734
+ r"""get_allocator(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::allocator_type"""
735
+ return _TerrainSwig.Terrain_Terrain_Vector_get_allocator(self)
736
736
 
737
737
  def pop_back(self):
738
- r"""pop_back(Terrain_MaterialLibrary_dirt_1_Vector self)"""
739
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_pop_back(self)
738
+ r"""pop_back(Terrain_Terrain_Vector self)"""
739
+ return _TerrainSwig.Terrain_Terrain_Vector_pop_back(self)
740
740
 
741
741
  def erase(self, *args):
742
742
  r"""
743
- erase(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
743
+ erase(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
744
744
 
745
745
  Parameters
746
746
  ----------
747
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
747
+ pos: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
748
748
 
749
- erase(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
749
+ erase(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
750
750
 
751
751
  Parameters
752
752
  ----------
753
- first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
754
- last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
753
+ first: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
754
+ last: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
755
755
 
756
756
  """
757
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_erase(self, *args)
757
+ return _TerrainSwig.Terrain_Terrain_Vector_erase(self, *args)
758
758
 
759
759
  def __init__(self, *args):
760
760
  r"""
761
- __init__(Terrain_MaterialLibrary_dirt_1_Vector self) -> Terrain_MaterialLibrary_dirt_1_Vector
762
- __init__(Terrain_MaterialLibrary_dirt_1_Vector self, Terrain_MaterialLibrary_dirt_1_Vector other) -> Terrain_MaterialLibrary_dirt_1_Vector
761
+ __init__(Terrain_Terrain_Vector self) -> Terrain_Terrain_Vector
762
+ __init__(Terrain_Terrain_Vector self, Terrain_Terrain_Vector other) -> Terrain_Terrain_Vector
763
763
 
764
764
  Parameters
765
765
  ----------
766
- other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > > const &
766
+ other: std::vector< std::shared_ptr< openplx::Terrain::Terrain > > const &
767
767
 
768
- __init__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type size) -> Terrain_MaterialLibrary_dirt_1_Vector
768
+ __init__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type size) -> Terrain_Terrain_Vector
769
769
 
770
770
  Parameters
771
771
  ----------
772
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
772
+ size: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
773
773
 
774
- __init__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & value) -> Terrain_MaterialLibrary_dirt_1_Vector
774
+ __init__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & value) -> Terrain_Terrain_Vector
775
775
 
776
776
  Parameters
777
777
  ----------
778
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
779
- value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
778
+ size: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
779
+ value: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
780
780
 
781
781
  """
782
- _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_dirt_1_Vector(*args))
782
+ _TerrainSwig.Terrain_Terrain_Vector_swiginit(self, _TerrainSwig.new_Terrain_Terrain_Vector(*args))
783
783
 
784
784
  def push_back(self, x):
785
785
  r"""
786
- push_back(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
786
+ push_back(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
787
787
 
788
788
  Parameters
789
789
  ----------
790
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
790
+ x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
791
791
 
792
792
  """
793
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_push_back(self, x)
793
+ return _TerrainSwig.Terrain_Terrain_Vector_push_back(self, x)
794
794
 
795
795
  def front(self):
796
- r"""front(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &"""
797
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_front(self)
796
+ r"""front(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &"""
797
+ return _TerrainSwig.Terrain_Terrain_Vector_front(self)
798
798
 
799
799
  def back(self):
800
- r"""back(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &"""
801
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_back(self)
800
+ r"""back(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &"""
801
+ return _TerrainSwig.Terrain_Terrain_Vector_back(self)
802
802
 
803
803
  def assign(self, n, x):
804
804
  r"""
805
- assign(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
805
+ assign(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
806
806
 
807
807
  Parameters
808
808
  ----------
809
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
810
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
809
+ n: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
810
+ x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
811
811
 
812
812
  """
813
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_assign(self, n, x)
813
+ return _TerrainSwig.Terrain_Terrain_Vector_assign(self, n, x)
814
814
 
815
815
  def resize(self, *args):
816
816
  r"""
817
- resize(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type new_size)
817
+ resize(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type new_size)
818
818
 
819
819
  Parameters
820
820
  ----------
821
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
821
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
822
822
 
823
- resize(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
823
+ resize(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
824
824
 
825
825
  Parameters
826
826
  ----------
827
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
828
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
827
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
828
+ x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
829
829
 
830
830
  """
831
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_resize(self, *args)
831
+ return _TerrainSwig.Terrain_Terrain_Vector_resize(self, *args)
832
832
 
833
833
  def insert(self, *args):
834
834
  r"""
835
- insert(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
835
+ insert(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
836
836
 
837
837
  Parameters
838
838
  ----------
839
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
840
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
839
+ pos: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
840
+ x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
841
841
 
842
- insert(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
842
+ insert(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
843
843
 
844
844
  Parameters
845
845
  ----------
846
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
847
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
848
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
846
+ pos: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
847
+ n: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
848
+ x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
849
849
 
850
850
  """
851
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_insert(self, *args)
851
+ return _TerrainSwig.Terrain_Terrain_Vector_insert(self, *args)
852
852
 
853
853
  def reserve(self, n):
854
854
  r"""
855
- reserve(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type n)
855
+ reserve(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type n)
856
856
 
857
857
  Parameters
858
858
  ----------
859
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
859
+ n: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
860
860
 
861
861
  """
862
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_reserve(self, n)
862
+ return _TerrainSwig.Terrain_Terrain_Vector_reserve(self, n)
863
863
 
864
864
  def capacity(self):
865
- r"""capacity(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type"""
866
- return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_capacity(self)
867
- __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_dirt_1_Vector
865
+ r"""capacity(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type"""
866
+ return _TerrainSwig.Terrain_Terrain_Vector_capacity(self)
867
+ __swig_destroy__ = _TerrainSwig.delete_Terrain_Terrain_Vector
868
868
 
869
- # Register Terrain_MaterialLibrary_dirt_1_Vector in _TerrainSwig:
870
- _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_swigregister(Terrain_MaterialLibrary_dirt_1_Vector)
869
+ # Register Terrain_Terrain_Vector in _TerrainSwig:
870
+ _TerrainSwig.Terrain_Terrain_Vector_swigregister(Terrain_Terrain_Vector)
871
871
 
872
- class Terrain_MaterialLibrary_gravel_1_Vector(object):
873
- r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > > class."""
872
+ class Terrain_TerrainMaterial_Vector(object):
873
+ r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > > class."""
874
874
 
875
875
  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
876
876
  __repr__ = _swig_repr
877
877
 
878
878
  def iterator(self):
879
- r"""iterator(Terrain_MaterialLibrary_gravel_1_Vector self) -> SwigPyIterator"""
880
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_iterator(self)
879
+ r"""iterator(Terrain_TerrainMaterial_Vector self) -> SwigPyIterator"""
880
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_iterator(self)
881
881
  def __iter__(self):
882
882
  return self.iterator()
883
883
 
884
884
  def __nonzero__(self):
885
- r"""__nonzero__(Terrain_MaterialLibrary_gravel_1_Vector self) -> bool"""
886
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___nonzero__(self)
885
+ r"""__nonzero__(Terrain_TerrainMaterial_Vector self) -> bool"""
886
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector___nonzero__(self)
887
887
 
888
888
  def __bool__(self):
889
- r"""__bool__(Terrain_MaterialLibrary_gravel_1_Vector self) -> bool"""
890
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___bool__(self)
889
+ r"""__bool__(Terrain_TerrainMaterial_Vector self) -> bool"""
890
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector___bool__(self)
891
891
 
892
892
  def __len__(self):
893
- r"""__len__(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type"""
894
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___len__(self)
893
+ r"""__len__(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type"""
894
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector___len__(self)
895
895
 
896
896
  def __getslice__(self, i, j):
897
897
  r"""
898
- __getslice__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type j) -> Terrain_MaterialLibrary_gravel_1_Vector
898
+ __getslice__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type j) -> Terrain_TerrainMaterial_Vector
899
899
 
900
900
  Parameters
901
901
  ----------
902
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
903
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
902
+ i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
903
+ j: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
904
904
 
905
905
  """
906
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___getslice__(self, i, j)
906
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector___getslice__(self, i, j)
907
907
 
908
908
  def __setslice__(self, *args):
909
909
  r"""
910
- __setslice__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type j)
910
+ __setslice__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type j)
911
911
 
912
912
  Parameters
913
913
  ----------
914
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
915
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
914
+ i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
915
+ j: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
916
916
 
917
- __setslice__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type j, Terrain_MaterialLibrary_gravel_1_Vector v)
917
+ __setslice__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type j, Terrain_TerrainMaterial_Vector v)
918
918
 
919
919
  Parameters
920
920
  ----------
921
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
922
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
923
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > > > const &
921
+ i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
922
+ j: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
923
+ v: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial >,std::allocator< std::shared_ptr< openplx::Terrain::TerrainMaterial > > > const &
924
924
 
925
925
  """
926
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___setslice__(self, *args)
926
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector___setslice__(self, *args)
927
927
 
928
928
  def __delslice__(self, i, j):
929
929
  r"""
930
- __delslice__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type j)
930
+ __delslice__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type j)
931
931
 
932
932
  Parameters
933
933
  ----------
934
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
935
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
934
+ i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
935
+ j: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
936
936
 
937
937
  """
938
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___delslice__(self, i, j)
938
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector___delslice__(self, i, j)
939
939
 
940
940
  def __delitem__(self, *args):
941
941
  r"""
942
- __delitem__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i)
942
+ __delitem__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i)
943
943
 
944
944
  Parameters
945
945
  ----------
946
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
946
+ i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
947
947
 
948
- __delitem__(Terrain_MaterialLibrary_gravel_1_Vector self, PySliceObject * slice)
948
+ __delitem__(Terrain_TerrainMaterial_Vector self, PySliceObject * slice)
949
949
 
950
950
  Parameters
951
951
  ----------
952
952
  slice: PySliceObject *
953
953
 
954
954
  """
955
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___delitem__(self, *args)
955
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector___delitem__(self, *args)
956
956
 
957
957
  def __getitem__(self, *args):
958
958
  r"""
959
- __getitem__(Terrain_MaterialLibrary_gravel_1_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_gravel_1_Vector
959
+ __getitem__(Terrain_TerrainMaterial_Vector self, PySliceObject * slice) -> Terrain_TerrainMaterial_Vector
960
960
 
961
961
  Parameters
962
962
  ----------
963
963
  slice: PySliceObject *
964
964
 
965
- __getitem__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
965
+ __getitem__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
966
966
 
967
967
  Parameters
968
968
  ----------
969
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
969
+ i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
970
970
 
971
971
  """
972
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___getitem__(self, *args)
972
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector___getitem__(self, *args)
973
973
 
974
974
  def __setitem__(self, *args):
975
975
  r"""
976
- __setitem__(Terrain_MaterialLibrary_gravel_1_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_gravel_1_Vector v)
976
+ __setitem__(Terrain_TerrainMaterial_Vector self, PySliceObject * slice, Terrain_TerrainMaterial_Vector v)
977
977
 
978
978
  Parameters
979
979
  ----------
980
980
  slice: PySliceObject *
981
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > > > const &
981
+ v: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial >,std::allocator< std::shared_ptr< openplx::Terrain::TerrainMaterial > > > const &
982
982
 
983
- __setitem__(Terrain_MaterialLibrary_gravel_1_Vector self, PySliceObject * slice)
983
+ __setitem__(Terrain_TerrainMaterial_Vector self, PySliceObject * slice)
984
984
 
985
985
  Parameters
986
986
  ----------
987
987
  slice: PySliceObject *
988
988
 
989
- __setitem__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
989
+ __setitem__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
990
990
 
991
991
  Parameters
992
992
  ----------
993
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
994
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
993
+ i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
994
+ x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
995
995
 
996
996
  """
997
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___setitem__(self, *args)
997
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector___setitem__(self, *args)
998
998
 
999
999
  def pop(self):
1000
- r"""pop(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type"""
1001
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_pop(self)
1000
+ r"""pop(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type"""
1001
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_pop(self)
1002
1002
 
1003
1003
  def append(self, x):
1004
1004
  r"""
1005
- append(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
1005
+ append(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
1006
1006
 
1007
1007
  Parameters
1008
1008
  ----------
1009
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
1009
+ x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
1010
1010
 
1011
1011
  """
1012
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_append(self, x)
1012
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_append(self, x)
1013
1013
 
1014
1014
  def empty(self):
1015
- r"""empty(Terrain_MaterialLibrary_gravel_1_Vector self) -> bool"""
1016
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_empty(self)
1015
+ r"""empty(Terrain_TerrainMaterial_Vector self) -> bool"""
1016
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_empty(self)
1017
1017
 
1018
1018
  def size(self):
1019
- r"""size(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type"""
1020
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_size(self)
1019
+ r"""size(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type"""
1020
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_size(self)
1021
1021
 
1022
1022
  def swap(self, v):
1023
1023
  r"""
1024
- swap(Terrain_MaterialLibrary_gravel_1_Vector self, Terrain_MaterialLibrary_gravel_1_Vector v)
1024
+ swap(Terrain_TerrainMaterial_Vector self, Terrain_TerrainMaterial_Vector v)
1025
1025
 
1026
1026
  Parameters
1027
1027
  ----------
1028
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > > &
1028
+ v: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > > &
1029
1029
 
1030
1030
  """
1031
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_swap(self, v)
1031
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_swap(self, v)
1032
1032
 
1033
1033
  def begin(self):
1034
- r"""begin(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator"""
1035
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_begin(self)
1034
+ r"""begin(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator"""
1035
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_begin(self)
1036
1036
 
1037
1037
  def end(self):
1038
- r"""end(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator"""
1039
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_end(self)
1038
+ r"""end(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator"""
1039
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_end(self)
1040
1040
 
1041
1041
  def rbegin(self):
1042
- r"""rbegin(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::reverse_iterator"""
1043
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_rbegin(self)
1042
+ r"""rbegin(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::reverse_iterator"""
1043
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_rbegin(self)
1044
1044
 
1045
1045
  def rend(self):
1046
- r"""rend(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::reverse_iterator"""
1047
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_rend(self)
1046
+ r"""rend(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::reverse_iterator"""
1047
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_rend(self)
1048
1048
 
1049
1049
  def clear(self):
1050
- r"""clear(Terrain_MaterialLibrary_gravel_1_Vector self)"""
1051
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_clear(self)
1050
+ r"""clear(Terrain_TerrainMaterial_Vector self)"""
1051
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_clear(self)
1052
1052
 
1053
1053
  def get_allocator(self):
1054
- r"""get_allocator(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::allocator_type"""
1055
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_get_allocator(self)
1054
+ r"""get_allocator(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::allocator_type"""
1055
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_get_allocator(self)
1056
1056
 
1057
1057
  def pop_back(self):
1058
- r"""pop_back(Terrain_MaterialLibrary_gravel_1_Vector self)"""
1059
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_pop_back(self)
1058
+ r"""pop_back(Terrain_TerrainMaterial_Vector self)"""
1059
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_pop_back(self)
1060
1060
 
1061
1061
  def erase(self, *args):
1062
1062
  r"""
1063
- erase(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
1063
+ erase(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
1064
1064
 
1065
1065
  Parameters
1066
1066
  ----------
1067
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
1067
+ pos: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
1068
1068
 
1069
- erase(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
1069
+ erase(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
1070
1070
 
1071
1071
  Parameters
1072
1072
  ----------
1073
- first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
1074
- last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
1073
+ first: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
1074
+ last: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
1075
1075
 
1076
1076
  """
1077
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_erase(self, *args)
1077
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_erase(self, *args)
1078
1078
 
1079
1079
  def __init__(self, *args):
1080
1080
  r"""
1081
- __init__(Terrain_MaterialLibrary_gravel_1_Vector self) -> Terrain_MaterialLibrary_gravel_1_Vector
1082
- __init__(Terrain_MaterialLibrary_gravel_1_Vector self, Terrain_MaterialLibrary_gravel_1_Vector other) -> Terrain_MaterialLibrary_gravel_1_Vector
1081
+ __init__(Terrain_TerrainMaterial_Vector self) -> Terrain_TerrainMaterial_Vector
1082
+ __init__(Terrain_TerrainMaterial_Vector self, Terrain_TerrainMaterial_Vector other) -> Terrain_TerrainMaterial_Vector
1083
1083
 
1084
1084
  Parameters
1085
1085
  ----------
1086
- other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > > const &
1086
+ other: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > > const &
1087
1087
 
1088
- __init__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type size) -> Terrain_MaterialLibrary_gravel_1_Vector
1088
+ __init__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type size) -> Terrain_TerrainMaterial_Vector
1089
1089
 
1090
1090
  Parameters
1091
1091
  ----------
1092
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
1092
+ size: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
1093
1093
 
1094
- __init__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & value) -> Terrain_MaterialLibrary_gravel_1_Vector
1094
+ __init__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & value) -> Terrain_TerrainMaterial_Vector
1095
1095
 
1096
1096
  Parameters
1097
1097
  ----------
1098
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
1099
- value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
1098
+ size: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
1099
+ value: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
1100
1100
 
1101
1101
  """
1102
- _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_gravel_1_Vector(*args))
1102
+ _TerrainSwig.Terrain_TerrainMaterial_Vector_swiginit(self, _TerrainSwig.new_Terrain_TerrainMaterial_Vector(*args))
1103
1103
 
1104
1104
  def push_back(self, x):
1105
1105
  r"""
1106
- push_back(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
1106
+ push_back(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
1107
1107
 
1108
1108
  Parameters
1109
1109
  ----------
1110
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
1110
+ x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
1111
1111
 
1112
1112
  """
1113
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_push_back(self, x)
1113
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_push_back(self, x)
1114
1114
 
1115
1115
  def front(self):
1116
- r"""front(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &"""
1117
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_front(self)
1116
+ r"""front(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &"""
1117
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_front(self)
1118
1118
 
1119
1119
  def back(self):
1120
- r"""back(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &"""
1121
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_back(self)
1120
+ r"""back(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &"""
1121
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_back(self)
1122
1122
 
1123
1123
  def assign(self, n, x):
1124
1124
  r"""
1125
- assign(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
1125
+ assign(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
1126
1126
 
1127
1127
  Parameters
1128
1128
  ----------
1129
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
1130
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
1129
+ n: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
1130
+ x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
1131
1131
 
1132
1132
  """
1133
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_assign(self, n, x)
1133
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_assign(self, n, x)
1134
1134
 
1135
1135
  def resize(self, *args):
1136
1136
  r"""
1137
- resize(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type new_size)
1137
+ resize(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type new_size)
1138
1138
 
1139
1139
  Parameters
1140
1140
  ----------
1141
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
1141
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
1142
1142
 
1143
- resize(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
1143
+ resize(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
1144
1144
 
1145
1145
  Parameters
1146
1146
  ----------
1147
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
1148
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
1147
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
1148
+ x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
1149
1149
 
1150
1150
  """
1151
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_resize(self, *args)
1151
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_resize(self, *args)
1152
1152
 
1153
1153
  def insert(self, *args):
1154
1154
  r"""
1155
- insert(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
1155
+ insert(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
1156
1156
 
1157
1157
  Parameters
1158
1158
  ----------
1159
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
1160
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
1159
+ pos: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
1160
+ x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
1161
1161
 
1162
- insert(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
1162
+ insert(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
1163
1163
 
1164
1164
  Parameters
1165
1165
  ----------
1166
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
1167
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
1168
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
1166
+ pos: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
1167
+ n: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
1168
+ x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
1169
1169
 
1170
1170
  """
1171
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_insert(self, *args)
1171
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_insert(self, *args)
1172
1172
 
1173
1173
  def reserve(self, n):
1174
1174
  r"""
1175
- reserve(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type n)
1175
+ reserve(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type n)
1176
1176
 
1177
1177
  Parameters
1178
1178
  ----------
1179
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
1179
+ n: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
1180
1180
 
1181
1181
  """
1182
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_reserve(self, n)
1182
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_reserve(self, n)
1183
1183
 
1184
1184
  def capacity(self):
1185
- r"""capacity(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type"""
1186
- return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_capacity(self)
1187
- __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_gravel_1_Vector
1185
+ r"""capacity(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type"""
1186
+ return _TerrainSwig.Terrain_TerrainMaterial_Vector_capacity(self)
1187
+ __swig_destroy__ = _TerrainSwig.delete_Terrain_TerrainMaterial_Vector
1188
1188
 
1189
- # Register Terrain_MaterialLibrary_gravel_1_Vector in _TerrainSwig:
1190
- _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_swigregister(Terrain_MaterialLibrary_gravel_1_Vector)
1189
+ # Register Terrain_TerrainMaterial_Vector in _TerrainSwig:
1190
+ _TerrainSwig.Terrain_TerrainMaterial_Vector_swigregister(Terrain_TerrainMaterial_Vector)
1191
1191
 
1192
- class Terrain_MaterialLibrary_iron_pellets_Vector(object):
1193
- r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > > class."""
1192
+ class Terrain_MaterialLibrary_defaultTerrainMaterial_Vector(object):
1193
+ r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > > class."""
1194
1194
 
1195
1195
  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1196
1196
  __repr__ = _swig_repr
1197
1197
 
1198
1198
  def iterator(self):
1199
- r"""iterator(Terrain_MaterialLibrary_iron_pellets_Vector self) -> SwigPyIterator"""
1200
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_iterator(self)
1199
+ r"""iterator(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> SwigPyIterator"""
1200
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_iterator(self)
1201
1201
  def __iter__(self):
1202
1202
  return self.iterator()
1203
1203
 
1204
1204
  def __nonzero__(self):
1205
- r"""__nonzero__(Terrain_MaterialLibrary_iron_pellets_Vector self) -> bool"""
1206
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___nonzero__(self)
1205
+ r"""__nonzero__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> bool"""
1206
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___nonzero__(self)
1207
1207
 
1208
1208
  def __bool__(self):
1209
- r"""__bool__(Terrain_MaterialLibrary_iron_pellets_Vector self) -> bool"""
1210
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___bool__(self)
1209
+ r"""__bool__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> bool"""
1210
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___bool__(self)
1211
1211
 
1212
1212
  def __len__(self):
1213
- r"""__len__(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type"""
1214
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___len__(self)
1213
+ r"""__len__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type"""
1214
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___len__(self)
1215
1215
 
1216
1216
  def __getslice__(self, i, j):
1217
1217
  r"""
1218
- __getslice__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type j) -> Terrain_MaterialLibrary_iron_pellets_Vector
1218
+ __getslice__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type j) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
1219
1219
 
1220
1220
  Parameters
1221
1221
  ----------
1222
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1223
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1222
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1223
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1224
1224
 
1225
1225
  """
1226
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___getslice__(self, i, j)
1226
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___getslice__(self, i, j)
1227
1227
 
1228
1228
  def __setslice__(self, *args):
1229
1229
  r"""
1230
- __setslice__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type j)
1230
+ __setslice__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type j)
1231
1231
 
1232
1232
  Parameters
1233
1233
  ----------
1234
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1235
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1234
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1235
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1236
1236
 
1237
- __setslice__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type j, Terrain_MaterialLibrary_iron_pellets_Vector v)
1237
+ __setslice__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type j, Terrain_MaterialLibrary_defaultTerrainMaterial_Vector v)
1238
1238
 
1239
1239
  Parameters
1240
1240
  ----------
1241
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1242
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1243
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > > > const &
1241
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1242
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1243
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > > > const &
1244
1244
 
1245
1245
  """
1246
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___setslice__(self, *args)
1246
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___setslice__(self, *args)
1247
1247
 
1248
1248
  def __delslice__(self, i, j):
1249
1249
  r"""
1250
- __delslice__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type j)
1250
+ __delslice__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type j)
1251
1251
 
1252
1252
  Parameters
1253
1253
  ----------
1254
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1255
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1254
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1255
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1256
1256
 
1257
1257
  """
1258
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___delslice__(self, i, j)
1258
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___delslice__(self, i, j)
1259
1259
 
1260
1260
  def __delitem__(self, *args):
1261
1261
  r"""
1262
- __delitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i)
1262
+ __delitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i)
1263
1263
 
1264
1264
  Parameters
1265
1265
  ----------
1266
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1266
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1267
1267
 
1268
- __delitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, PySliceObject * slice)
1268
+ __delitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, PySliceObject * slice)
1269
1269
 
1270
1270
  Parameters
1271
1271
  ----------
1272
1272
  slice: PySliceObject *
1273
1273
 
1274
1274
  """
1275
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___delitem__(self, *args)
1275
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___delitem__(self, *args)
1276
1276
 
1277
1277
  def __getitem__(self, *args):
1278
1278
  r"""
1279
- __getitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_iron_pellets_Vector
1279
+ __getitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
1280
1280
 
1281
1281
  Parameters
1282
1282
  ----------
1283
1283
  slice: PySliceObject *
1284
1284
 
1285
- __getitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
1285
+ __getitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
1286
1286
 
1287
1287
  Parameters
1288
1288
  ----------
1289
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1289
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1290
1290
 
1291
1291
  """
1292
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___getitem__(self, *args)
1292
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___getitem__(self, *args)
1293
1293
 
1294
1294
  def __setitem__(self, *args):
1295
1295
  r"""
1296
- __setitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_iron_pellets_Vector v)
1296
+ __setitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_defaultTerrainMaterial_Vector v)
1297
1297
 
1298
1298
  Parameters
1299
1299
  ----------
1300
1300
  slice: PySliceObject *
1301
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > > > const &
1301
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > > > const &
1302
1302
 
1303
- __setitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, PySliceObject * slice)
1303
+ __setitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, PySliceObject * slice)
1304
1304
 
1305
1305
  Parameters
1306
1306
  ----------
1307
1307
  slice: PySliceObject *
1308
1308
 
1309
- __setitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
1309
+ __setitem__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
1310
1310
 
1311
1311
  Parameters
1312
1312
  ----------
1313
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
1314
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
1313
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::difference_type
1314
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
1315
1315
 
1316
1316
  """
1317
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___setitem__(self, *args)
1317
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector___setitem__(self, *args)
1318
1318
 
1319
1319
  def pop(self):
1320
- r"""pop(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type"""
1321
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_pop(self)
1320
+ r"""pop(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type"""
1321
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_pop(self)
1322
1322
 
1323
1323
  def append(self, x):
1324
1324
  r"""
1325
- append(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
1325
+ append(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
1326
1326
 
1327
1327
  Parameters
1328
1328
  ----------
1329
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
1329
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
1330
1330
 
1331
1331
  """
1332
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_append(self, x)
1332
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_append(self, x)
1333
1333
 
1334
1334
  def empty(self):
1335
- r"""empty(Terrain_MaterialLibrary_iron_pellets_Vector self) -> bool"""
1336
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_empty(self)
1335
+ r"""empty(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> bool"""
1336
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_empty(self)
1337
1337
 
1338
1338
  def size(self):
1339
- r"""size(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type"""
1340
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_size(self)
1339
+ r"""size(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type"""
1340
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_size(self)
1341
1341
 
1342
1342
  def swap(self, v):
1343
1343
  r"""
1344
- swap(Terrain_MaterialLibrary_iron_pellets_Vector self, Terrain_MaterialLibrary_iron_pellets_Vector v)
1344
+ swap(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, Terrain_MaterialLibrary_defaultTerrainMaterial_Vector v)
1345
1345
 
1346
1346
  Parameters
1347
1347
  ----------
1348
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > > &
1348
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > > &
1349
1349
 
1350
1350
  """
1351
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_swap(self, v)
1351
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_swap(self, v)
1352
1352
 
1353
1353
  def begin(self):
1354
- r"""begin(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator"""
1355
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_begin(self)
1354
+ r"""begin(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator"""
1355
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_begin(self)
1356
1356
 
1357
1357
  def end(self):
1358
- r"""end(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator"""
1359
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_end(self)
1358
+ r"""end(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator"""
1359
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_end(self)
1360
1360
 
1361
1361
  def rbegin(self):
1362
- r"""rbegin(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::reverse_iterator"""
1363
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_rbegin(self)
1362
+ r"""rbegin(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::reverse_iterator"""
1363
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_rbegin(self)
1364
1364
 
1365
1365
  def rend(self):
1366
- r"""rend(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::reverse_iterator"""
1367
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_rend(self)
1366
+ r"""rend(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::reverse_iterator"""
1367
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_rend(self)
1368
1368
 
1369
1369
  def clear(self):
1370
- r"""clear(Terrain_MaterialLibrary_iron_pellets_Vector self)"""
1371
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_clear(self)
1370
+ r"""clear(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self)"""
1371
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_clear(self)
1372
1372
 
1373
1373
  def get_allocator(self):
1374
- r"""get_allocator(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::allocator_type"""
1375
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_get_allocator(self)
1374
+ r"""get_allocator(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::allocator_type"""
1375
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_get_allocator(self)
1376
1376
 
1377
1377
  def pop_back(self):
1378
- r"""pop_back(Terrain_MaterialLibrary_iron_pellets_Vector self)"""
1379
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_pop_back(self)
1378
+ r"""pop_back(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self)"""
1379
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_pop_back(self)
1380
1380
 
1381
1381
  def erase(self, *args):
1382
1382
  r"""
1383
- erase(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
1383
+ erase(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
1384
1384
 
1385
1385
  Parameters
1386
1386
  ----------
1387
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
1387
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
1388
1388
 
1389
- erase(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
1389
+ erase(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
1390
1390
 
1391
1391
  Parameters
1392
1392
  ----------
1393
- first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
1394
- last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
1393
+ first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
1394
+ last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
1395
1395
 
1396
1396
  """
1397
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_erase(self, *args)
1397
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_erase(self, *args)
1398
1398
 
1399
1399
  def __init__(self, *args):
1400
1400
  r"""
1401
- __init__(Terrain_MaterialLibrary_iron_pellets_Vector self) -> Terrain_MaterialLibrary_iron_pellets_Vector
1402
- __init__(Terrain_MaterialLibrary_iron_pellets_Vector self, Terrain_MaterialLibrary_iron_pellets_Vector other) -> Terrain_MaterialLibrary_iron_pellets_Vector
1401
+ __init__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
1402
+ __init__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, Terrain_MaterialLibrary_defaultTerrainMaterial_Vector other) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
1403
1403
 
1404
1404
  Parameters
1405
1405
  ----------
1406
- other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > > const &
1406
+ other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > > const &
1407
1407
 
1408
- __init__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type size) -> Terrain_MaterialLibrary_iron_pellets_Vector
1408
+ __init__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type size) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
1409
1409
 
1410
1410
  Parameters
1411
1411
  ----------
1412
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
1412
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
1413
1413
 
1414
- __init__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & value) -> Terrain_MaterialLibrary_iron_pellets_Vector
1414
+ __init__(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & value) -> Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
1415
1415
 
1416
1416
  Parameters
1417
1417
  ----------
1418
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
1419
- value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
1418
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
1419
+ value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
1420
1420
 
1421
1421
  """
1422
- _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_iron_pellets_Vector(*args))
1422
+ _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_defaultTerrainMaterial_Vector(*args))
1423
1423
 
1424
1424
  def push_back(self, x):
1425
1425
  r"""
1426
- push_back(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
1426
+ push_back(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
1427
1427
 
1428
1428
  Parameters
1429
1429
  ----------
1430
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
1430
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
1431
1431
 
1432
1432
  """
1433
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_push_back(self, x)
1433
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_push_back(self, x)
1434
1434
 
1435
1435
  def front(self):
1436
- r"""front(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &"""
1437
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_front(self)
1436
+ r"""front(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &"""
1437
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_front(self)
1438
1438
 
1439
1439
  def back(self):
1440
- r"""back(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &"""
1441
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_back(self)
1440
+ r"""back(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &"""
1441
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_back(self)
1442
1442
 
1443
1443
  def assign(self, n, x):
1444
1444
  r"""
1445
- assign(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
1445
+ assign(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
1446
1446
 
1447
1447
  Parameters
1448
1448
  ----------
1449
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
1450
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
1449
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
1450
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
1451
1451
 
1452
1452
  """
1453
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_assign(self, n, x)
1453
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_assign(self, n, x)
1454
1454
 
1455
1455
  def resize(self, *args):
1456
1456
  r"""
1457
- resize(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type new_size)
1457
+ resize(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type new_size)
1458
1458
 
1459
1459
  Parameters
1460
1460
  ----------
1461
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
1461
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
1462
1462
 
1463
- resize(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
1463
+ resize(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
1464
1464
 
1465
1465
  Parameters
1466
1466
  ----------
1467
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
1468
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
1467
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
1468
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
1469
1469
 
1470
1470
  """
1471
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_resize(self, *args)
1471
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_resize(self, *args)
1472
1472
 
1473
1473
  def insert(self, *args):
1474
1474
  r"""
1475
- insert(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
1475
+ insert(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
1476
1476
 
1477
1477
  Parameters
1478
1478
  ----------
1479
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
1480
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
1479
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
1480
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
1481
1481
 
1482
- insert(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
1482
+ insert(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const & x)
1483
1483
 
1484
1484
  Parameters
1485
1485
  ----------
1486
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
1487
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
1488
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
1486
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::iterator
1487
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
1488
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::value_type const &
1489
1489
 
1490
1490
  """
1491
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_insert(self, *args)
1491
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_insert(self, *args)
1492
1492
 
1493
1493
  def reserve(self, n):
1494
1494
  r"""
1495
- reserve(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type n)
1495
+ reserve(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type n)
1496
1496
 
1497
1497
  Parameters
1498
1498
  ----------
1499
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
1499
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type
1500
1500
 
1501
1501
  """
1502
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_reserve(self, n)
1502
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_reserve(self, n)
1503
1503
 
1504
1504
  def capacity(self):
1505
- r"""capacity(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type"""
1506
- return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_capacity(self)
1507
- __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_iron_pellets_Vector
1505
+ r"""capacity(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::defaultTerrainMaterial > >::size_type"""
1506
+ return _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_capacity(self)
1507
+ __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_defaultTerrainMaterial_Vector
1508
1508
 
1509
- # Register Terrain_MaterialLibrary_iron_pellets_Vector in _TerrainSwig:
1510
- _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_swigregister(Terrain_MaterialLibrary_iron_pellets_Vector)
1509
+ # Register Terrain_MaterialLibrary_defaultTerrainMaterial_Vector in _TerrainSwig:
1510
+ _TerrainSwig.Terrain_MaterialLibrary_defaultTerrainMaterial_Vector_swigregister(Terrain_MaterialLibrary_defaultTerrainMaterial_Vector)
1511
1511
 
1512
- class Terrain_MaterialLibrary_sand_1_Vector(object):
1513
- r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > > class."""
1512
+ class Terrain_MaterialLibrary_dirt_1_Vector(object):
1513
+ r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > > class."""
1514
1514
 
1515
1515
  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1516
1516
  __repr__ = _swig_repr
1517
1517
 
1518
1518
  def iterator(self):
1519
- r"""iterator(Terrain_MaterialLibrary_sand_1_Vector self) -> SwigPyIterator"""
1520
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_iterator(self)
1519
+ r"""iterator(Terrain_MaterialLibrary_dirt_1_Vector self) -> SwigPyIterator"""
1520
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_iterator(self)
1521
1521
  def __iter__(self):
1522
1522
  return self.iterator()
1523
1523
 
1524
1524
  def __nonzero__(self):
1525
- r"""__nonzero__(Terrain_MaterialLibrary_sand_1_Vector self) -> bool"""
1526
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___nonzero__(self)
1525
+ r"""__nonzero__(Terrain_MaterialLibrary_dirt_1_Vector self) -> bool"""
1526
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___nonzero__(self)
1527
1527
 
1528
1528
  def __bool__(self):
1529
- r"""__bool__(Terrain_MaterialLibrary_sand_1_Vector self) -> bool"""
1530
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___bool__(self)
1529
+ r"""__bool__(Terrain_MaterialLibrary_dirt_1_Vector self) -> bool"""
1530
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___bool__(self)
1531
1531
 
1532
1532
  def __len__(self):
1533
- r"""__len__(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type"""
1534
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___len__(self)
1533
+ r"""__len__(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type"""
1534
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___len__(self)
1535
1535
 
1536
1536
  def __getslice__(self, i, j):
1537
1537
  r"""
1538
- __getslice__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type j) -> Terrain_MaterialLibrary_sand_1_Vector
1538
+ __getslice__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type j) -> Terrain_MaterialLibrary_dirt_1_Vector
1539
1539
 
1540
1540
  Parameters
1541
1541
  ----------
1542
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1543
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1542
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1543
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1544
1544
 
1545
1545
  """
1546
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___getslice__(self, i, j)
1546
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___getslice__(self, i, j)
1547
1547
 
1548
1548
  def __setslice__(self, *args):
1549
1549
  r"""
1550
- __setslice__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type j)
1550
+ __setslice__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type j)
1551
1551
 
1552
1552
  Parameters
1553
1553
  ----------
1554
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1555
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1554
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1555
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1556
1556
 
1557
- __setslice__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type j, Terrain_MaterialLibrary_sand_1_Vector v)
1557
+ __setslice__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type j, Terrain_MaterialLibrary_dirt_1_Vector v)
1558
1558
 
1559
1559
  Parameters
1560
1560
  ----------
1561
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1562
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1563
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > > > const &
1561
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1562
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1563
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > > > const &
1564
1564
 
1565
1565
  """
1566
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___setslice__(self, *args)
1566
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___setslice__(self, *args)
1567
1567
 
1568
1568
  def __delslice__(self, i, j):
1569
1569
  r"""
1570
- __delslice__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type j)
1570
+ __delslice__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type j)
1571
1571
 
1572
1572
  Parameters
1573
1573
  ----------
1574
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1575
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1574
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1575
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1576
1576
 
1577
1577
  """
1578
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___delslice__(self, i, j)
1578
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___delslice__(self, i, j)
1579
1579
 
1580
1580
  def __delitem__(self, *args):
1581
1581
  r"""
1582
- __delitem__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i)
1582
+ __delitem__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i)
1583
1583
 
1584
1584
  Parameters
1585
1585
  ----------
1586
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1586
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1587
1587
 
1588
- __delitem__(Terrain_MaterialLibrary_sand_1_Vector self, PySliceObject * slice)
1588
+ __delitem__(Terrain_MaterialLibrary_dirt_1_Vector self, PySliceObject * slice)
1589
1589
 
1590
1590
  Parameters
1591
1591
  ----------
1592
1592
  slice: PySliceObject *
1593
1593
 
1594
1594
  """
1595
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___delitem__(self, *args)
1595
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___delitem__(self, *args)
1596
1596
 
1597
1597
  def __getitem__(self, *args):
1598
1598
  r"""
1599
- __getitem__(Terrain_MaterialLibrary_sand_1_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_sand_1_Vector
1599
+ __getitem__(Terrain_MaterialLibrary_dirt_1_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_dirt_1_Vector
1600
1600
 
1601
1601
  Parameters
1602
1602
  ----------
1603
1603
  slice: PySliceObject *
1604
1604
 
1605
- __getitem__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
1605
+ __getitem__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
1606
1606
 
1607
1607
  Parameters
1608
1608
  ----------
1609
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1609
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1610
1610
 
1611
1611
  """
1612
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___getitem__(self, *args)
1612
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___getitem__(self, *args)
1613
1613
 
1614
1614
  def __setitem__(self, *args):
1615
1615
  r"""
1616
- __setitem__(Terrain_MaterialLibrary_sand_1_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_sand_1_Vector v)
1616
+ __setitem__(Terrain_MaterialLibrary_dirt_1_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_dirt_1_Vector v)
1617
1617
 
1618
1618
  Parameters
1619
1619
  ----------
1620
1620
  slice: PySliceObject *
1621
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > > > const &
1621
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > > > const &
1622
1622
 
1623
- __setitem__(Terrain_MaterialLibrary_sand_1_Vector self, PySliceObject * slice)
1623
+ __setitem__(Terrain_MaterialLibrary_dirt_1_Vector self, PySliceObject * slice)
1624
1624
 
1625
1625
  Parameters
1626
1626
  ----------
1627
1627
  slice: PySliceObject *
1628
1628
 
1629
- __setitem__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
1629
+ __setitem__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
1630
1630
 
1631
1631
  Parameters
1632
1632
  ----------
1633
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
1634
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
1633
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::difference_type
1634
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
1635
1635
 
1636
1636
  """
1637
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___setitem__(self, *args)
1637
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector___setitem__(self, *args)
1638
1638
 
1639
1639
  def pop(self):
1640
- r"""pop(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type"""
1641
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_pop(self)
1640
+ r"""pop(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type"""
1641
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_pop(self)
1642
1642
 
1643
1643
  def append(self, x):
1644
1644
  r"""
1645
- append(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
1645
+ append(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
1646
1646
 
1647
1647
  Parameters
1648
1648
  ----------
1649
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
1649
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
1650
1650
 
1651
1651
  """
1652
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_append(self, x)
1652
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_append(self, x)
1653
1653
 
1654
1654
  def empty(self):
1655
- r"""empty(Terrain_MaterialLibrary_sand_1_Vector self) -> bool"""
1656
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_empty(self)
1655
+ r"""empty(Terrain_MaterialLibrary_dirt_1_Vector self) -> bool"""
1656
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_empty(self)
1657
1657
 
1658
1658
  def size(self):
1659
- r"""size(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type"""
1660
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_size(self)
1659
+ r"""size(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type"""
1660
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_size(self)
1661
1661
 
1662
1662
  def swap(self, v):
1663
1663
  r"""
1664
- swap(Terrain_MaterialLibrary_sand_1_Vector self, Terrain_MaterialLibrary_sand_1_Vector v)
1664
+ swap(Terrain_MaterialLibrary_dirt_1_Vector self, Terrain_MaterialLibrary_dirt_1_Vector v)
1665
1665
 
1666
1666
  Parameters
1667
1667
  ----------
1668
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > > &
1668
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > > &
1669
1669
 
1670
1670
  """
1671
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_swap(self, v)
1671
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_swap(self, v)
1672
1672
 
1673
1673
  def begin(self):
1674
- r"""begin(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator"""
1675
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_begin(self)
1674
+ r"""begin(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator"""
1675
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_begin(self)
1676
1676
 
1677
1677
  def end(self):
1678
- r"""end(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator"""
1679
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_end(self)
1678
+ r"""end(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator"""
1679
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_end(self)
1680
1680
 
1681
1681
  def rbegin(self):
1682
- r"""rbegin(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::reverse_iterator"""
1683
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_rbegin(self)
1682
+ r"""rbegin(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::reverse_iterator"""
1683
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_rbegin(self)
1684
1684
 
1685
1685
  def rend(self):
1686
- r"""rend(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::reverse_iterator"""
1687
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_rend(self)
1686
+ r"""rend(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::reverse_iterator"""
1687
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_rend(self)
1688
1688
 
1689
1689
  def clear(self):
1690
- r"""clear(Terrain_MaterialLibrary_sand_1_Vector self)"""
1691
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_clear(self)
1690
+ r"""clear(Terrain_MaterialLibrary_dirt_1_Vector self)"""
1691
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_clear(self)
1692
1692
 
1693
1693
  def get_allocator(self):
1694
- r"""get_allocator(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::allocator_type"""
1695
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_get_allocator(self)
1694
+ r"""get_allocator(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::allocator_type"""
1695
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_get_allocator(self)
1696
1696
 
1697
1697
  def pop_back(self):
1698
- r"""pop_back(Terrain_MaterialLibrary_sand_1_Vector self)"""
1699
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_pop_back(self)
1698
+ r"""pop_back(Terrain_MaterialLibrary_dirt_1_Vector self)"""
1699
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_pop_back(self)
1700
1700
 
1701
1701
  def erase(self, *args):
1702
1702
  r"""
1703
- erase(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
1703
+ erase(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
1704
1704
 
1705
1705
  Parameters
1706
1706
  ----------
1707
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
1707
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
1708
1708
 
1709
- erase(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
1709
+ erase(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
1710
1710
 
1711
1711
  Parameters
1712
1712
  ----------
1713
- first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
1714
- last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
1713
+ first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
1714
+ last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
1715
1715
 
1716
1716
  """
1717
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_erase(self, *args)
1717
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_erase(self, *args)
1718
1718
 
1719
1719
  def __init__(self, *args):
1720
1720
  r"""
1721
- __init__(Terrain_MaterialLibrary_sand_1_Vector self) -> Terrain_MaterialLibrary_sand_1_Vector
1722
- __init__(Terrain_MaterialLibrary_sand_1_Vector self, Terrain_MaterialLibrary_sand_1_Vector other) -> Terrain_MaterialLibrary_sand_1_Vector
1721
+ __init__(Terrain_MaterialLibrary_dirt_1_Vector self) -> Terrain_MaterialLibrary_dirt_1_Vector
1722
+ __init__(Terrain_MaterialLibrary_dirt_1_Vector self, Terrain_MaterialLibrary_dirt_1_Vector other) -> Terrain_MaterialLibrary_dirt_1_Vector
1723
1723
 
1724
1724
  Parameters
1725
1725
  ----------
1726
- other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > > const &
1726
+ other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > > const &
1727
1727
 
1728
- __init__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type size) -> Terrain_MaterialLibrary_sand_1_Vector
1728
+ __init__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type size) -> Terrain_MaterialLibrary_dirt_1_Vector
1729
1729
 
1730
1730
  Parameters
1731
1731
  ----------
1732
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
1732
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
1733
1733
 
1734
- __init__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & value) -> Terrain_MaterialLibrary_sand_1_Vector
1734
+ __init__(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & value) -> Terrain_MaterialLibrary_dirt_1_Vector
1735
1735
 
1736
1736
  Parameters
1737
1737
  ----------
1738
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
1739
- value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
1738
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
1739
+ value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
1740
1740
 
1741
1741
  """
1742
- _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_sand_1_Vector(*args))
1742
+ _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_dirt_1_Vector(*args))
1743
1743
 
1744
1744
  def push_back(self, x):
1745
1745
  r"""
1746
- push_back(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
1746
+ push_back(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
1747
1747
 
1748
1748
  Parameters
1749
1749
  ----------
1750
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
1750
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
1751
1751
 
1752
1752
  """
1753
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_push_back(self, x)
1753
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_push_back(self, x)
1754
1754
 
1755
1755
  def front(self):
1756
- r"""front(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &"""
1757
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_front(self)
1756
+ r"""front(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &"""
1757
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_front(self)
1758
1758
 
1759
1759
  def back(self):
1760
- r"""back(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &"""
1761
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_back(self)
1760
+ r"""back(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &"""
1761
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_back(self)
1762
1762
 
1763
1763
  def assign(self, n, x):
1764
1764
  r"""
1765
- assign(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
1765
+ assign(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
1766
1766
 
1767
1767
  Parameters
1768
1768
  ----------
1769
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
1770
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
1769
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
1770
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
1771
1771
 
1772
1772
  """
1773
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_assign(self, n, x)
1773
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_assign(self, n, x)
1774
1774
 
1775
1775
  def resize(self, *args):
1776
1776
  r"""
1777
- resize(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type new_size)
1777
+ resize(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type new_size)
1778
1778
 
1779
1779
  Parameters
1780
1780
  ----------
1781
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
1781
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
1782
1782
 
1783
- resize(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
1783
+ resize(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
1784
1784
 
1785
1785
  Parameters
1786
1786
  ----------
1787
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
1788
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
1787
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
1788
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
1789
1789
 
1790
1790
  """
1791
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_resize(self, *args)
1791
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_resize(self, *args)
1792
1792
 
1793
1793
  def insert(self, *args):
1794
1794
  r"""
1795
- insert(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
1795
+ insert(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
1796
1796
 
1797
1797
  Parameters
1798
1798
  ----------
1799
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
1800
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
1799
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
1800
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
1801
1801
 
1802
- insert(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
1802
+ insert(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const & x)
1803
1803
 
1804
1804
  Parameters
1805
1805
  ----------
1806
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
1807
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
1808
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
1806
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::iterator
1807
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
1808
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::value_type const &
1809
1809
 
1810
1810
  """
1811
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_insert(self, *args)
1811
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_insert(self, *args)
1812
1812
 
1813
1813
  def reserve(self, n):
1814
1814
  r"""
1815
- reserve(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type n)
1815
+ reserve(Terrain_MaterialLibrary_dirt_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type n)
1816
1816
 
1817
1817
  Parameters
1818
1818
  ----------
1819
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
1819
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type
1820
1820
 
1821
1821
  """
1822
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_reserve(self, n)
1822
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_reserve(self, n)
1823
1823
 
1824
1824
  def capacity(self):
1825
- r"""capacity(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type"""
1826
- return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_capacity(self)
1827
- __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_sand_1_Vector
1825
+ r"""capacity(Terrain_MaterialLibrary_dirt_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::dirt_1 > >::size_type"""
1826
+ return _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_capacity(self)
1827
+ __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_dirt_1_Vector
1828
1828
 
1829
- # Register Terrain_MaterialLibrary_sand_1_Vector in _TerrainSwig:
1830
- _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_swigregister(Terrain_MaterialLibrary_sand_1_Vector)
1829
+ # Register Terrain_MaterialLibrary_dirt_1_Vector in _TerrainSwig:
1830
+ _TerrainSwig.Terrain_MaterialLibrary_dirt_1_Vector_swigregister(Terrain_MaterialLibrary_dirt_1_Vector)
1831
1831
 
1832
- class Terrain_MaterialLibrary_wet_sand_Vector(object):
1833
- r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > > class."""
1832
+ class Terrain_MaterialLibrary_gravel_1_Vector(object):
1833
+ r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > > class."""
1834
1834
 
1835
1835
  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
1836
1836
  __repr__ = _swig_repr
1837
1837
 
1838
1838
  def iterator(self):
1839
- r"""iterator(Terrain_MaterialLibrary_wet_sand_Vector self) -> SwigPyIterator"""
1840
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_iterator(self)
1839
+ r"""iterator(Terrain_MaterialLibrary_gravel_1_Vector self) -> SwigPyIterator"""
1840
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_iterator(self)
1841
1841
  def __iter__(self):
1842
1842
  return self.iterator()
1843
1843
 
1844
1844
  def __nonzero__(self):
1845
- r"""__nonzero__(Terrain_MaterialLibrary_wet_sand_Vector self) -> bool"""
1846
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___nonzero__(self)
1845
+ r"""__nonzero__(Terrain_MaterialLibrary_gravel_1_Vector self) -> bool"""
1846
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___nonzero__(self)
1847
1847
 
1848
1848
  def __bool__(self):
1849
- r"""__bool__(Terrain_MaterialLibrary_wet_sand_Vector self) -> bool"""
1850
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___bool__(self)
1849
+ r"""__bool__(Terrain_MaterialLibrary_gravel_1_Vector self) -> bool"""
1850
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___bool__(self)
1851
1851
 
1852
1852
  def __len__(self):
1853
- r"""__len__(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type"""
1854
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___len__(self)
1853
+ r"""__len__(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type"""
1854
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___len__(self)
1855
1855
 
1856
1856
  def __getslice__(self, i, j):
1857
1857
  r"""
1858
- __getslice__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type j) -> Terrain_MaterialLibrary_wet_sand_Vector
1858
+ __getslice__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type j) -> Terrain_MaterialLibrary_gravel_1_Vector
1859
1859
 
1860
1860
  Parameters
1861
1861
  ----------
1862
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1863
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1862
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1863
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1864
1864
 
1865
1865
  """
1866
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___getslice__(self, i, j)
1866
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___getslice__(self, i, j)
1867
1867
 
1868
1868
  def __setslice__(self, *args):
1869
1869
  r"""
1870
- __setslice__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type j)
1870
+ __setslice__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type j)
1871
1871
 
1872
1872
  Parameters
1873
1873
  ----------
1874
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1875
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1874
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1875
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1876
1876
 
1877
- __setslice__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type j, Terrain_MaterialLibrary_wet_sand_Vector v)
1877
+ __setslice__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type j, Terrain_MaterialLibrary_gravel_1_Vector v)
1878
1878
 
1879
1879
  Parameters
1880
1880
  ----------
1881
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1882
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1883
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > > > const &
1881
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1882
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1883
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > > > const &
1884
1884
 
1885
1885
  """
1886
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___setslice__(self, *args)
1886
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___setslice__(self, *args)
1887
1887
 
1888
1888
  def __delslice__(self, i, j):
1889
1889
  r"""
1890
- __delslice__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type j)
1890
+ __delslice__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type j)
1891
1891
 
1892
1892
  Parameters
1893
1893
  ----------
1894
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1895
- j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1894
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1895
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1896
1896
 
1897
1897
  """
1898
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___delslice__(self, i, j)
1898
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___delslice__(self, i, j)
1899
1899
 
1900
1900
  def __delitem__(self, *args):
1901
1901
  r"""
1902
- __delitem__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i)
1902
+ __delitem__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i)
1903
1903
 
1904
1904
  Parameters
1905
1905
  ----------
1906
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1906
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1907
1907
 
1908
- __delitem__(Terrain_MaterialLibrary_wet_sand_Vector self, PySliceObject * slice)
1908
+ __delitem__(Terrain_MaterialLibrary_gravel_1_Vector self, PySliceObject * slice)
1909
1909
 
1910
1910
  Parameters
1911
1911
  ----------
1912
1912
  slice: PySliceObject *
1913
1913
 
1914
1914
  """
1915
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___delitem__(self, *args)
1915
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___delitem__(self, *args)
1916
1916
 
1917
1917
  def __getitem__(self, *args):
1918
1918
  r"""
1919
- __getitem__(Terrain_MaterialLibrary_wet_sand_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_wet_sand_Vector
1919
+ __getitem__(Terrain_MaterialLibrary_gravel_1_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_gravel_1_Vector
1920
1920
 
1921
1921
  Parameters
1922
1922
  ----------
1923
1923
  slice: PySliceObject *
1924
1924
 
1925
- __getitem__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
1925
+ __getitem__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
1926
1926
 
1927
1927
  Parameters
1928
1928
  ----------
1929
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1929
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1930
1930
 
1931
1931
  """
1932
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___getitem__(self, *args)
1932
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___getitem__(self, *args)
1933
1933
 
1934
1934
  def __setitem__(self, *args):
1935
1935
  r"""
1936
- __setitem__(Terrain_MaterialLibrary_wet_sand_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_wet_sand_Vector v)
1936
+ __setitem__(Terrain_MaterialLibrary_gravel_1_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_gravel_1_Vector v)
1937
1937
 
1938
1938
  Parameters
1939
1939
  ----------
1940
1940
  slice: PySliceObject *
1941
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > > > const &
1941
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > > > const &
1942
1942
 
1943
- __setitem__(Terrain_MaterialLibrary_wet_sand_Vector self, PySliceObject * slice)
1943
+ __setitem__(Terrain_MaterialLibrary_gravel_1_Vector self, PySliceObject * slice)
1944
1944
 
1945
1945
  Parameters
1946
1946
  ----------
1947
1947
  slice: PySliceObject *
1948
1948
 
1949
- __setitem__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
1949
+ __setitem__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
1950
1950
 
1951
1951
  Parameters
1952
1952
  ----------
1953
- i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
1954
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
1953
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::difference_type
1954
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
1955
1955
 
1956
1956
  """
1957
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___setitem__(self, *args)
1957
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector___setitem__(self, *args)
1958
1958
 
1959
1959
  def pop(self):
1960
- r"""pop(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type"""
1961
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_pop(self)
1960
+ r"""pop(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type"""
1961
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_pop(self)
1962
1962
 
1963
1963
  def append(self, x):
1964
1964
  r"""
1965
- append(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
1965
+ append(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
1966
1966
 
1967
1967
  Parameters
1968
1968
  ----------
1969
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
1969
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
1970
1970
 
1971
1971
  """
1972
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_append(self, x)
1972
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_append(self, x)
1973
1973
 
1974
1974
  def empty(self):
1975
- r"""empty(Terrain_MaterialLibrary_wet_sand_Vector self) -> bool"""
1976
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_empty(self)
1975
+ r"""empty(Terrain_MaterialLibrary_gravel_1_Vector self) -> bool"""
1976
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_empty(self)
1977
1977
 
1978
1978
  def size(self):
1979
- r"""size(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type"""
1980
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_size(self)
1979
+ r"""size(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type"""
1980
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_size(self)
1981
1981
 
1982
1982
  def swap(self, v):
1983
1983
  r"""
1984
- swap(Terrain_MaterialLibrary_wet_sand_Vector self, Terrain_MaterialLibrary_wet_sand_Vector v)
1984
+ swap(Terrain_MaterialLibrary_gravel_1_Vector self, Terrain_MaterialLibrary_gravel_1_Vector v)
1985
1985
 
1986
1986
  Parameters
1987
1987
  ----------
1988
- v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > > &
1988
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > > &
1989
1989
 
1990
1990
  """
1991
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_swap(self, v)
1991
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_swap(self, v)
1992
1992
 
1993
1993
  def begin(self):
1994
- r"""begin(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator"""
1995
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_begin(self)
1994
+ r"""begin(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator"""
1995
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_begin(self)
1996
1996
 
1997
1997
  def end(self):
1998
- r"""end(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator"""
1999
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_end(self)
1998
+ r"""end(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator"""
1999
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_end(self)
2000
2000
 
2001
2001
  def rbegin(self):
2002
- r"""rbegin(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::reverse_iterator"""
2003
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_rbegin(self)
2002
+ r"""rbegin(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::reverse_iterator"""
2003
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_rbegin(self)
2004
2004
 
2005
2005
  def rend(self):
2006
- r"""rend(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::reverse_iterator"""
2007
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_rend(self)
2006
+ r"""rend(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::reverse_iterator"""
2007
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_rend(self)
2008
2008
 
2009
2009
  def clear(self):
2010
- r"""clear(Terrain_MaterialLibrary_wet_sand_Vector self)"""
2011
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_clear(self)
2010
+ r"""clear(Terrain_MaterialLibrary_gravel_1_Vector self)"""
2011
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_clear(self)
2012
2012
 
2013
2013
  def get_allocator(self):
2014
- r"""get_allocator(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::allocator_type"""
2015
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_get_allocator(self)
2014
+ r"""get_allocator(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::allocator_type"""
2015
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_get_allocator(self)
2016
2016
 
2017
2017
  def pop_back(self):
2018
- r"""pop_back(Terrain_MaterialLibrary_wet_sand_Vector self)"""
2019
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_pop_back(self)
2018
+ r"""pop_back(Terrain_MaterialLibrary_gravel_1_Vector self)"""
2019
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_pop_back(self)
2020
2020
 
2021
2021
  def erase(self, *args):
2022
2022
  r"""
2023
- erase(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2023
+ erase(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
2024
2024
 
2025
2025
  Parameters
2026
2026
  ----------
2027
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2027
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
2028
2028
 
2029
- erase(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2029
+ erase(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
2030
2030
 
2031
2031
  Parameters
2032
2032
  ----------
2033
- first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2034
- last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2033
+ first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
2034
+ last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
2035
2035
 
2036
2036
  """
2037
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_erase(self, *args)
2037
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_erase(self, *args)
2038
2038
 
2039
2039
  def __init__(self, *args):
2040
2040
  r"""
2041
- __init__(Terrain_MaterialLibrary_wet_sand_Vector self) -> Terrain_MaterialLibrary_wet_sand_Vector
2042
- __init__(Terrain_MaterialLibrary_wet_sand_Vector self, Terrain_MaterialLibrary_wet_sand_Vector other) -> Terrain_MaterialLibrary_wet_sand_Vector
2041
+ __init__(Terrain_MaterialLibrary_gravel_1_Vector self) -> Terrain_MaterialLibrary_gravel_1_Vector
2042
+ __init__(Terrain_MaterialLibrary_gravel_1_Vector self, Terrain_MaterialLibrary_gravel_1_Vector other) -> Terrain_MaterialLibrary_gravel_1_Vector
2043
2043
 
2044
2044
  Parameters
2045
2045
  ----------
2046
- other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > > const &
2046
+ other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > > const &
2047
2047
 
2048
- __init__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type size) -> Terrain_MaterialLibrary_wet_sand_Vector
2048
+ __init__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type size) -> Terrain_MaterialLibrary_gravel_1_Vector
2049
2049
 
2050
2050
  Parameters
2051
2051
  ----------
2052
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
2052
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
2053
2053
 
2054
- __init__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & value) -> Terrain_MaterialLibrary_wet_sand_Vector
2054
+ __init__(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & value) -> Terrain_MaterialLibrary_gravel_1_Vector
2055
2055
 
2056
2056
  Parameters
2057
2057
  ----------
2058
- size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
2059
- value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
2058
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
2059
+ value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
2060
2060
 
2061
2061
  """
2062
- _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_wet_sand_Vector(*args))
2062
+ _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_gravel_1_Vector(*args))
2063
2063
 
2064
2064
  def push_back(self, x):
2065
2065
  r"""
2066
- push_back(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
2066
+ push_back(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
2067
2067
 
2068
2068
  Parameters
2069
2069
  ----------
2070
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
2070
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
2071
2071
 
2072
2072
  """
2073
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_push_back(self, x)
2073
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_push_back(self, x)
2074
2074
 
2075
2075
  def front(self):
2076
- r"""front(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &"""
2077
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_front(self)
2076
+ r"""front(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &"""
2077
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_front(self)
2078
2078
 
2079
2079
  def back(self):
2080
- r"""back(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &"""
2081
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_back(self)
2080
+ r"""back(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &"""
2081
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_back(self)
2082
2082
 
2083
2083
  def assign(self, n, x):
2084
2084
  r"""
2085
- assign(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
2085
+ assign(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
2086
2086
 
2087
2087
  Parameters
2088
2088
  ----------
2089
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
2090
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
2089
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
2090
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
2091
2091
 
2092
2092
  """
2093
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_assign(self, n, x)
2093
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_assign(self, n, x)
2094
2094
 
2095
2095
  def resize(self, *args):
2096
2096
  r"""
2097
- resize(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type new_size)
2097
+ resize(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type new_size)
2098
2098
 
2099
2099
  Parameters
2100
2100
  ----------
2101
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
2101
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
2102
2102
 
2103
- resize(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
2103
+ resize(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
2104
2104
 
2105
2105
  Parameters
2106
2106
  ----------
2107
- new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
2108
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
2107
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
2108
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
2109
2109
 
2110
2110
  """
2111
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_resize(self, *args)
2111
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_resize(self, *args)
2112
2112
 
2113
2113
  def insert(self, *args):
2114
2114
  r"""
2115
- insert(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2115
+ insert(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
2116
2116
 
2117
2117
  Parameters
2118
2118
  ----------
2119
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2120
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
2119
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
2120
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
2121
2121
 
2122
- insert(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
2122
+ insert(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const & x)
2123
2123
 
2124
2124
  Parameters
2125
2125
  ----------
2126
- pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2127
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
2128
- x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
2126
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::iterator
2127
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
2128
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::value_type const &
2129
2129
 
2130
2130
  """
2131
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_insert(self, *args)
2131
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_insert(self, *args)
2132
2132
 
2133
2133
  def reserve(self, n):
2134
2134
  r"""
2135
- reserve(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type n)
2135
+ reserve(Terrain_MaterialLibrary_gravel_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type n)
2136
2136
 
2137
2137
  Parameters
2138
2138
  ----------
2139
- n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
2139
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type
2140
2140
 
2141
2141
  """
2142
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_reserve(self, n)
2142
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_reserve(self, n)
2143
2143
 
2144
2144
  def capacity(self):
2145
- r"""capacity(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type"""
2146
- return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_capacity(self)
2147
- __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_wet_sand_Vector
2145
+ r"""capacity(Terrain_MaterialLibrary_gravel_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::gravel_1 > >::size_type"""
2146
+ return _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_capacity(self)
2147
+ __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_gravel_1_Vector
2148
2148
 
2149
- # Register Terrain_MaterialLibrary_wet_sand_Vector in _TerrainSwig:
2150
- _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_swigregister(Terrain_MaterialLibrary_wet_sand_Vector)
2149
+ # Register Terrain_MaterialLibrary_gravel_1_Vector in _TerrainSwig:
2150
+ _TerrainSwig.Terrain_MaterialLibrary_gravel_1_Vector_swigregister(Terrain_MaterialLibrary_gravel_1_Vector)
2151
2151
 
2152
- class Terrain_Shovel_Vector(object):
2153
- r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::Shovel > > class."""
2152
+ class Terrain_MaterialLibrary_iron_pellets_Vector(object):
2153
+ r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > > class."""
2154
2154
 
2155
2155
  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2156
2156
  __repr__ = _swig_repr
2157
2157
 
2158
2158
  def iterator(self):
2159
- r"""iterator(Terrain_Shovel_Vector self) -> SwigPyIterator"""
2160
- return _TerrainSwig.Terrain_Shovel_Vector_iterator(self)
2159
+ r"""iterator(Terrain_MaterialLibrary_iron_pellets_Vector self) -> SwigPyIterator"""
2160
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_iterator(self)
2161
2161
  def __iter__(self):
2162
2162
  return self.iterator()
2163
2163
 
2164
2164
  def __nonzero__(self):
2165
- r"""__nonzero__(Terrain_Shovel_Vector self) -> bool"""
2166
- return _TerrainSwig.Terrain_Shovel_Vector___nonzero__(self)
2165
+ r"""__nonzero__(Terrain_MaterialLibrary_iron_pellets_Vector self) -> bool"""
2166
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___nonzero__(self)
2167
2167
 
2168
2168
  def __bool__(self):
2169
- r"""__bool__(Terrain_Shovel_Vector self) -> bool"""
2170
- return _TerrainSwig.Terrain_Shovel_Vector___bool__(self)
2169
+ r"""__bool__(Terrain_MaterialLibrary_iron_pellets_Vector self) -> bool"""
2170
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___bool__(self)
2171
2171
 
2172
2172
  def __len__(self):
2173
- r"""__len__(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type"""
2174
- return _TerrainSwig.Terrain_Shovel_Vector___len__(self)
2173
+ r"""__len__(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type"""
2174
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___len__(self)
2175
2175
 
2176
2176
  def __getslice__(self, i, j):
2177
2177
  r"""
2178
- __getslice__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type j) -> Terrain_Shovel_Vector
2178
+ __getslice__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type j) -> Terrain_MaterialLibrary_iron_pellets_Vector
2179
2179
 
2180
2180
  Parameters
2181
2181
  ----------
2182
- i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2183
- j: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2182
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2183
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2184
2184
 
2185
2185
  """
2186
- return _TerrainSwig.Terrain_Shovel_Vector___getslice__(self, i, j)
2186
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___getslice__(self, i, j)
2187
2187
 
2188
2188
  def __setslice__(self, *args):
2189
2189
  r"""
2190
- __setslice__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type j)
2190
+ __setslice__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type j)
2191
2191
 
2192
2192
  Parameters
2193
2193
  ----------
2194
- i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2195
- j: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2194
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2195
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2196
2196
 
2197
- __setslice__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type j, Terrain_Shovel_Vector v)
2197
+ __setslice__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type j, Terrain_MaterialLibrary_iron_pellets_Vector v)
2198
2198
 
2199
2199
  Parameters
2200
2200
  ----------
2201
- i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2202
- j: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2203
- v: std::vector< std::shared_ptr< openplx::Terrain::Shovel >,std::allocator< std::shared_ptr< openplx::Terrain::Shovel > > > const &
2201
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2202
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2203
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > > > const &
2204
2204
 
2205
2205
  """
2206
- return _TerrainSwig.Terrain_Shovel_Vector___setslice__(self, *args)
2206
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___setslice__(self, *args)
2207
2207
 
2208
2208
  def __delslice__(self, i, j):
2209
2209
  r"""
2210
- __delslice__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type j)
2210
+ __delslice__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type j)
2211
2211
 
2212
2212
  Parameters
2213
2213
  ----------
2214
- i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2215
- j: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2214
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2215
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2216
2216
 
2217
2217
  """
2218
- return _TerrainSwig.Terrain_Shovel_Vector___delslice__(self, i, j)
2218
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___delslice__(self, i, j)
2219
2219
 
2220
2220
  def __delitem__(self, *args):
2221
2221
  r"""
2222
- __delitem__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i)
2222
+ __delitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i)
2223
2223
 
2224
2224
  Parameters
2225
2225
  ----------
2226
- i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2226
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2227
2227
 
2228
- __delitem__(Terrain_Shovel_Vector self, PySliceObject * slice)
2228
+ __delitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, PySliceObject * slice)
2229
2229
 
2230
2230
  Parameters
2231
2231
  ----------
2232
2232
  slice: PySliceObject *
2233
2233
 
2234
2234
  """
2235
- return _TerrainSwig.Terrain_Shovel_Vector___delitem__(self, *args)
2235
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___delitem__(self, *args)
2236
2236
 
2237
2237
  def __getitem__(self, *args):
2238
2238
  r"""
2239
- __getitem__(Terrain_Shovel_Vector self, PySliceObject * slice) -> Terrain_Shovel_Vector
2239
+ __getitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_iron_pellets_Vector
2240
2240
 
2241
2241
  Parameters
2242
2242
  ----------
2243
2243
  slice: PySliceObject *
2244
2244
 
2245
- __getitem__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
2245
+ __getitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
2246
2246
 
2247
2247
  Parameters
2248
2248
  ----------
2249
- i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2249
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2250
2250
 
2251
2251
  """
2252
- return _TerrainSwig.Terrain_Shovel_Vector___getitem__(self, *args)
2252
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___getitem__(self, *args)
2253
2253
 
2254
2254
  def __setitem__(self, *args):
2255
2255
  r"""
2256
- __setitem__(Terrain_Shovel_Vector self, PySliceObject * slice, Terrain_Shovel_Vector v)
2256
+ __setitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_iron_pellets_Vector v)
2257
2257
 
2258
2258
  Parameters
2259
2259
  ----------
2260
2260
  slice: PySliceObject *
2261
- v: std::vector< std::shared_ptr< openplx::Terrain::Shovel >,std::allocator< std::shared_ptr< openplx::Terrain::Shovel > > > const &
2261
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > > > const &
2262
2262
 
2263
- __setitem__(Terrain_Shovel_Vector self, PySliceObject * slice)
2263
+ __setitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, PySliceObject * slice)
2264
2264
 
2265
2265
  Parameters
2266
2266
  ----------
2267
2267
  slice: PySliceObject *
2268
2268
 
2269
- __setitem__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
2269
+ __setitem__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
2270
2270
 
2271
2271
  Parameters
2272
2272
  ----------
2273
- i: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::difference_type
2274
- x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
2273
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::difference_type
2274
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
2275
2275
 
2276
2276
  """
2277
- return _TerrainSwig.Terrain_Shovel_Vector___setitem__(self, *args)
2277
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector___setitem__(self, *args)
2278
2278
 
2279
2279
  def pop(self):
2280
- r"""pop(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type"""
2281
- return _TerrainSwig.Terrain_Shovel_Vector_pop(self)
2280
+ r"""pop(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type"""
2281
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_pop(self)
2282
2282
 
2283
2283
  def append(self, x):
2284
2284
  r"""
2285
- append(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
2285
+ append(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
2286
2286
 
2287
2287
  Parameters
2288
2288
  ----------
2289
- x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
2289
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
2290
2290
 
2291
2291
  """
2292
- return _TerrainSwig.Terrain_Shovel_Vector_append(self, x)
2292
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_append(self, x)
2293
2293
 
2294
2294
  def empty(self):
2295
- r"""empty(Terrain_Shovel_Vector self) -> bool"""
2296
- return _TerrainSwig.Terrain_Shovel_Vector_empty(self)
2295
+ r"""empty(Terrain_MaterialLibrary_iron_pellets_Vector self) -> bool"""
2296
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_empty(self)
2297
2297
 
2298
2298
  def size(self):
2299
- r"""size(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type"""
2300
- return _TerrainSwig.Terrain_Shovel_Vector_size(self)
2299
+ r"""size(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type"""
2300
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_size(self)
2301
2301
 
2302
2302
  def swap(self, v):
2303
2303
  r"""
2304
- swap(Terrain_Shovel_Vector self, Terrain_Shovel_Vector v)
2304
+ swap(Terrain_MaterialLibrary_iron_pellets_Vector self, Terrain_MaterialLibrary_iron_pellets_Vector v)
2305
2305
 
2306
2306
  Parameters
2307
2307
  ----------
2308
- v: std::vector< std::shared_ptr< openplx::Terrain::Shovel > > &
2308
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > > &
2309
2309
 
2310
2310
  """
2311
- return _TerrainSwig.Terrain_Shovel_Vector_swap(self, v)
2311
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_swap(self, v)
2312
2312
 
2313
2313
  def begin(self):
2314
- r"""begin(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator"""
2315
- return _TerrainSwig.Terrain_Shovel_Vector_begin(self)
2314
+ r"""begin(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator"""
2315
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_begin(self)
2316
2316
 
2317
2317
  def end(self):
2318
- r"""end(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator"""
2319
- return _TerrainSwig.Terrain_Shovel_Vector_end(self)
2318
+ r"""end(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator"""
2319
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_end(self)
2320
2320
 
2321
2321
  def rbegin(self):
2322
- r"""rbegin(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::reverse_iterator"""
2323
- return _TerrainSwig.Terrain_Shovel_Vector_rbegin(self)
2322
+ r"""rbegin(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::reverse_iterator"""
2323
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_rbegin(self)
2324
2324
 
2325
2325
  def rend(self):
2326
- r"""rend(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::reverse_iterator"""
2327
- return _TerrainSwig.Terrain_Shovel_Vector_rend(self)
2326
+ r"""rend(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::reverse_iterator"""
2327
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_rend(self)
2328
2328
 
2329
2329
  def clear(self):
2330
- r"""clear(Terrain_Shovel_Vector self)"""
2331
- return _TerrainSwig.Terrain_Shovel_Vector_clear(self)
2330
+ r"""clear(Terrain_MaterialLibrary_iron_pellets_Vector self)"""
2331
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_clear(self)
2332
2332
 
2333
2333
  def get_allocator(self):
2334
- r"""get_allocator(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::allocator_type"""
2335
- return _TerrainSwig.Terrain_Shovel_Vector_get_allocator(self)
2334
+ r"""get_allocator(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::allocator_type"""
2335
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_get_allocator(self)
2336
2336
 
2337
2337
  def pop_back(self):
2338
- r"""pop_back(Terrain_Shovel_Vector self)"""
2339
- return _TerrainSwig.Terrain_Shovel_Vector_pop_back(self)
2338
+ r"""pop_back(Terrain_MaterialLibrary_iron_pellets_Vector self)"""
2339
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_pop_back(self)
2340
2340
 
2341
2341
  def erase(self, *args):
2342
2342
  r"""
2343
- erase(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
2343
+ erase(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
2344
2344
 
2345
2345
  Parameters
2346
2346
  ----------
2347
- pos: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
2347
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
2348
2348
 
2349
- erase(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
2349
+ erase(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
2350
2350
 
2351
2351
  Parameters
2352
2352
  ----------
2353
- first: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
2354
- last: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
2353
+ first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
2354
+ last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
2355
2355
 
2356
2356
  """
2357
- return _TerrainSwig.Terrain_Shovel_Vector_erase(self, *args)
2357
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_erase(self, *args)
2358
2358
 
2359
2359
  def __init__(self, *args):
2360
2360
  r"""
2361
- __init__(Terrain_Shovel_Vector self) -> Terrain_Shovel_Vector
2362
- __init__(Terrain_Shovel_Vector self, Terrain_Shovel_Vector other) -> Terrain_Shovel_Vector
2361
+ __init__(Terrain_MaterialLibrary_iron_pellets_Vector self) -> Terrain_MaterialLibrary_iron_pellets_Vector
2362
+ __init__(Terrain_MaterialLibrary_iron_pellets_Vector self, Terrain_MaterialLibrary_iron_pellets_Vector other) -> Terrain_MaterialLibrary_iron_pellets_Vector
2363
2363
 
2364
2364
  Parameters
2365
2365
  ----------
2366
- other: std::vector< std::shared_ptr< openplx::Terrain::Shovel > > const &
2366
+ other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > > const &
2367
2367
 
2368
- __init__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type size) -> Terrain_Shovel_Vector
2368
+ __init__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type size) -> Terrain_MaterialLibrary_iron_pellets_Vector
2369
2369
 
2370
2370
  Parameters
2371
2371
  ----------
2372
- size: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
2372
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
2373
2373
 
2374
- __init__(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & value) -> Terrain_Shovel_Vector
2374
+ __init__(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & value) -> Terrain_MaterialLibrary_iron_pellets_Vector
2375
2375
 
2376
2376
  Parameters
2377
2377
  ----------
2378
- size: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
2379
- value: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
2378
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
2379
+ value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
2380
2380
 
2381
2381
  """
2382
- _TerrainSwig.Terrain_Shovel_Vector_swiginit(self, _TerrainSwig.new_Terrain_Shovel_Vector(*args))
2382
+ _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_iron_pellets_Vector(*args))
2383
2383
 
2384
2384
  def push_back(self, x):
2385
2385
  r"""
2386
- push_back(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
2386
+ push_back(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
2387
2387
 
2388
2388
  Parameters
2389
2389
  ----------
2390
- x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
2390
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
2391
2391
 
2392
2392
  """
2393
- return _TerrainSwig.Terrain_Shovel_Vector_push_back(self, x)
2393
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_push_back(self, x)
2394
2394
 
2395
2395
  def front(self):
2396
- r"""front(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &"""
2397
- return _TerrainSwig.Terrain_Shovel_Vector_front(self)
2396
+ r"""front(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &"""
2397
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_front(self)
2398
2398
 
2399
2399
  def back(self):
2400
- r"""back(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &"""
2401
- return _TerrainSwig.Terrain_Shovel_Vector_back(self)
2400
+ r"""back(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &"""
2401
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_back(self)
2402
2402
 
2403
2403
  def assign(self, n, x):
2404
2404
  r"""
2405
- assign(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
2405
+ assign(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
2406
2406
 
2407
2407
  Parameters
2408
2408
  ----------
2409
- n: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
2410
- x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
2409
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
2410
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
2411
2411
 
2412
2412
  """
2413
- return _TerrainSwig.Terrain_Shovel_Vector_assign(self, n, x)
2413
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_assign(self, n, x)
2414
2414
 
2415
2415
  def resize(self, *args):
2416
2416
  r"""
2417
- resize(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type new_size)
2417
+ resize(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type new_size)
2418
2418
 
2419
2419
  Parameters
2420
2420
  ----------
2421
- new_size: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
2421
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
2422
2422
 
2423
- resize(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
2423
+ resize(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
2424
2424
 
2425
2425
  Parameters
2426
2426
  ----------
2427
- new_size: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
2428
- x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
2427
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
2428
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
2429
2429
 
2430
2430
  """
2431
- return _TerrainSwig.Terrain_Shovel_Vector_resize(self, *args)
2431
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_resize(self, *args)
2432
2432
 
2433
2433
  def insert(self, *args):
2434
2434
  r"""
2435
- insert(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
2435
+ insert(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
2436
2436
 
2437
2437
  Parameters
2438
2438
  ----------
2439
- pos: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
2440
- x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
2439
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
2440
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
2441
2441
 
2442
- insert(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const & x)
2442
+ insert(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const & x)
2443
2443
 
2444
2444
  Parameters
2445
2445
  ----------
2446
- pos: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::iterator
2447
- n: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
2448
- x: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::value_type const &
2446
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::iterator
2447
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
2448
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::value_type const &
2449
2449
 
2450
2450
  """
2451
- return _TerrainSwig.Terrain_Shovel_Vector_insert(self, *args)
2451
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_insert(self, *args)
2452
2452
 
2453
2453
  def reserve(self, n):
2454
2454
  r"""
2455
- reserve(Terrain_Shovel_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type n)
2455
+ reserve(Terrain_MaterialLibrary_iron_pellets_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type n)
2456
2456
 
2457
2457
  Parameters
2458
2458
  ----------
2459
- n: std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type
2459
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type
2460
2460
 
2461
2461
  """
2462
- return _TerrainSwig.Terrain_Shovel_Vector_reserve(self, n)
2462
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_reserve(self, n)
2463
2463
 
2464
2464
  def capacity(self):
2465
- r"""capacity(Terrain_Shovel_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Shovel > >::size_type"""
2466
- return _TerrainSwig.Terrain_Shovel_Vector_capacity(self)
2467
- __swig_destroy__ = _TerrainSwig.delete_Terrain_Shovel_Vector
2465
+ r"""capacity(Terrain_MaterialLibrary_iron_pellets_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::iron_pellets > >::size_type"""
2466
+ return _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_capacity(self)
2467
+ __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_iron_pellets_Vector
2468
2468
 
2469
- # Register Terrain_Shovel_Vector in _TerrainSwig:
2470
- _TerrainSwig.Terrain_Shovel_Vector_swigregister(Terrain_Shovel_Vector)
2469
+ # Register Terrain_MaterialLibrary_iron_pellets_Vector in _TerrainSwig:
2470
+ _TerrainSwig.Terrain_MaterialLibrary_iron_pellets_Vector_swigregister(Terrain_MaterialLibrary_iron_pellets_Vector)
2471
2471
 
2472
- class Terrain_Terrain_Vector(object):
2473
- r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::Terrain > > class."""
2472
+ class Terrain_MaterialLibrary_sand_1_Vector(object):
2473
+ r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > > class."""
2474
2474
 
2475
2475
  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2476
2476
  __repr__ = _swig_repr
2477
2477
 
2478
2478
  def iterator(self):
2479
- r"""iterator(Terrain_Terrain_Vector self) -> SwigPyIterator"""
2480
- return _TerrainSwig.Terrain_Terrain_Vector_iterator(self)
2479
+ r"""iterator(Terrain_MaterialLibrary_sand_1_Vector self) -> SwigPyIterator"""
2480
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_iterator(self)
2481
2481
  def __iter__(self):
2482
2482
  return self.iterator()
2483
2483
 
2484
2484
  def __nonzero__(self):
2485
- r"""__nonzero__(Terrain_Terrain_Vector self) -> bool"""
2486
- return _TerrainSwig.Terrain_Terrain_Vector___nonzero__(self)
2485
+ r"""__nonzero__(Terrain_MaterialLibrary_sand_1_Vector self) -> bool"""
2486
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___nonzero__(self)
2487
2487
 
2488
2488
  def __bool__(self):
2489
- r"""__bool__(Terrain_Terrain_Vector self) -> bool"""
2490
- return _TerrainSwig.Terrain_Terrain_Vector___bool__(self)
2489
+ r"""__bool__(Terrain_MaterialLibrary_sand_1_Vector self) -> bool"""
2490
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___bool__(self)
2491
2491
 
2492
2492
  def __len__(self):
2493
- r"""__len__(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type"""
2494
- return _TerrainSwig.Terrain_Terrain_Vector___len__(self)
2493
+ r"""__len__(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type"""
2494
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___len__(self)
2495
2495
 
2496
2496
  def __getslice__(self, i, j):
2497
2497
  r"""
2498
- __getslice__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type j) -> Terrain_Terrain_Vector
2498
+ __getslice__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type j) -> Terrain_MaterialLibrary_sand_1_Vector
2499
2499
 
2500
2500
  Parameters
2501
2501
  ----------
2502
- i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2503
- j: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2502
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2503
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2504
2504
 
2505
2505
  """
2506
- return _TerrainSwig.Terrain_Terrain_Vector___getslice__(self, i, j)
2506
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___getslice__(self, i, j)
2507
2507
 
2508
2508
  def __setslice__(self, *args):
2509
2509
  r"""
2510
- __setslice__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type j)
2510
+ __setslice__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type j)
2511
2511
 
2512
2512
  Parameters
2513
2513
  ----------
2514
- i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2515
- j: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2514
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2515
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2516
2516
 
2517
- __setslice__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type j, Terrain_Terrain_Vector v)
2517
+ __setslice__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type j, Terrain_MaterialLibrary_sand_1_Vector v)
2518
2518
 
2519
2519
  Parameters
2520
2520
  ----------
2521
- i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2522
- j: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2523
- v: std::vector< std::shared_ptr< openplx::Terrain::Terrain >,std::allocator< std::shared_ptr< openplx::Terrain::Terrain > > > const &
2521
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2522
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2523
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > > > const &
2524
2524
 
2525
2525
  """
2526
- return _TerrainSwig.Terrain_Terrain_Vector___setslice__(self, *args)
2526
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___setslice__(self, *args)
2527
2527
 
2528
2528
  def __delslice__(self, i, j):
2529
2529
  r"""
2530
- __delslice__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type j)
2530
+ __delslice__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type j)
2531
2531
 
2532
2532
  Parameters
2533
2533
  ----------
2534
- i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2535
- j: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2534
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2535
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2536
2536
 
2537
2537
  """
2538
- return _TerrainSwig.Terrain_Terrain_Vector___delslice__(self, i, j)
2538
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___delslice__(self, i, j)
2539
2539
 
2540
2540
  def __delitem__(self, *args):
2541
2541
  r"""
2542
- __delitem__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i)
2542
+ __delitem__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i)
2543
2543
 
2544
2544
  Parameters
2545
2545
  ----------
2546
- i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2546
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2547
2547
 
2548
- __delitem__(Terrain_Terrain_Vector self, PySliceObject * slice)
2548
+ __delitem__(Terrain_MaterialLibrary_sand_1_Vector self, PySliceObject * slice)
2549
2549
 
2550
2550
  Parameters
2551
2551
  ----------
2552
2552
  slice: PySliceObject *
2553
2553
 
2554
2554
  """
2555
- return _TerrainSwig.Terrain_Terrain_Vector___delitem__(self, *args)
2555
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___delitem__(self, *args)
2556
2556
 
2557
2557
  def __getitem__(self, *args):
2558
2558
  r"""
2559
- __getitem__(Terrain_Terrain_Vector self, PySliceObject * slice) -> Terrain_Terrain_Vector
2559
+ __getitem__(Terrain_MaterialLibrary_sand_1_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_sand_1_Vector
2560
2560
 
2561
2561
  Parameters
2562
2562
  ----------
2563
2563
  slice: PySliceObject *
2564
2564
 
2565
- __getitem__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
2565
+ __getitem__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
2566
2566
 
2567
2567
  Parameters
2568
2568
  ----------
2569
- i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2569
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2570
2570
 
2571
2571
  """
2572
- return _TerrainSwig.Terrain_Terrain_Vector___getitem__(self, *args)
2572
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___getitem__(self, *args)
2573
2573
 
2574
2574
  def __setitem__(self, *args):
2575
2575
  r"""
2576
- __setitem__(Terrain_Terrain_Vector self, PySliceObject * slice, Terrain_Terrain_Vector v)
2576
+ __setitem__(Terrain_MaterialLibrary_sand_1_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_sand_1_Vector v)
2577
2577
 
2578
2578
  Parameters
2579
2579
  ----------
2580
2580
  slice: PySliceObject *
2581
- v: std::vector< std::shared_ptr< openplx::Terrain::Terrain >,std::allocator< std::shared_ptr< openplx::Terrain::Terrain > > > const &
2581
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > > > const &
2582
2582
 
2583
- __setitem__(Terrain_Terrain_Vector self, PySliceObject * slice)
2583
+ __setitem__(Terrain_MaterialLibrary_sand_1_Vector self, PySliceObject * slice)
2584
2584
 
2585
2585
  Parameters
2586
2586
  ----------
2587
2587
  slice: PySliceObject *
2588
2588
 
2589
- __setitem__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
2589
+ __setitem__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
2590
2590
 
2591
2591
  Parameters
2592
2592
  ----------
2593
- i: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::difference_type
2594
- x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
2593
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::difference_type
2594
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
2595
2595
 
2596
2596
  """
2597
- return _TerrainSwig.Terrain_Terrain_Vector___setitem__(self, *args)
2597
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector___setitem__(self, *args)
2598
2598
 
2599
2599
  def pop(self):
2600
- r"""pop(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type"""
2601
- return _TerrainSwig.Terrain_Terrain_Vector_pop(self)
2600
+ r"""pop(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type"""
2601
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_pop(self)
2602
2602
 
2603
2603
  def append(self, x):
2604
2604
  r"""
2605
- append(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
2605
+ append(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
2606
2606
 
2607
2607
  Parameters
2608
2608
  ----------
2609
- x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
2609
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
2610
2610
 
2611
2611
  """
2612
- return _TerrainSwig.Terrain_Terrain_Vector_append(self, x)
2612
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_append(self, x)
2613
2613
 
2614
2614
  def empty(self):
2615
- r"""empty(Terrain_Terrain_Vector self) -> bool"""
2616
- return _TerrainSwig.Terrain_Terrain_Vector_empty(self)
2615
+ r"""empty(Terrain_MaterialLibrary_sand_1_Vector self) -> bool"""
2616
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_empty(self)
2617
2617
 
2618
2618
  def size(self):
2619
- r"""size(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type"""
2620
- return _TerrainSwig.Terrain_Terrain_Vector_size(self)
2619
+ r"""size(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type"""
2620
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_size(self)
2621
2621
 
2622
2622
  def swap(self, v):
2623
2623
  r"""
2624
- swap(Terrain_Terrain_Vector self, Terrain_Terrain_Vector v)
2624
+ swap(Terrain_MaterialLibrary_sand_1_Vector self, Terrain_MaterialLibrary_sand_1_Vector v)
2625
2625
 
2626
2626
  Parameters
2627
2627
  ----------
2628
- v: std::vector< std::shared_ptr< openplx::Terrain::Terrain > > &
2628
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > > &
2629
2629
 
2630
2630
  """
2631
- return _TerrainSwig.Terrain_Terrain_Vector_swap(self, v)
2631
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_swap(self, v)
2632
2632
 
2633
2633
  def begin(self):
2634
- r"""begin(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator"""
2635
- return _TerrainSwig.Terrain_Terrain_Vector_begin(self)
2634
+ r"""begin(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator"""
2635
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_begin(self)
2636
2636
 
2637
2637
  def end(self):
2638
- r"""end(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator"""
2639
- return _TerrainSwig.Terrain_Terrain_Vector_end(self)
2638
+ r"""end(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator"""
2639
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_end(self)
2640
2640
 
2641
2641
  def rbegin(self):
2642
- r"""rbegin(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::reverse_iterator"""
2643
- return _TerrainSwig.Terrain_Terrain_Vector_rbegin(self)
2642
+ r"""rbegin(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::reverse_iterator"""
2643
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_rbegin(self)
2644
2644
 
2645
2645
  def rend(self):
2646
- r"""rend(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::reverse_iterator"""
2647
- return _TerrainSwig.Terrain_Terrain_Vector_rend(self)
2646
+ r"""rend(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::reverse_iterator"""
2647
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_rend(self)
2648
2648
 
2649
2649
  def clear(self):
2650
- r"""clear(Terrain_Terrain_Vector self)"""
2651
- return _TerrainSwig.Terrain_Terrain_Vector_clear(self)
2650
+ r"""clear(Terrain_MaterialLibrary_sand_1_Vector self)"""
2651
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_clear(self)
2652
2652
 
2653
2653
  def get_allocator(self):
2654
- r"""get_allocator(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::allocator_type"""
2655
- return _TerrainSwig.Terrain_Terrain_Vector_get_allocator(self)
2654
+ r"""get_allocator(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::allocator_type"""
2655
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_get_allocator(self)
2656
2656
 
2657
2657
  def pop_back(self):
2658
- r"""pop_back(Terrain_Terrain_Vector self)"""
2659
- return _TerrainSwig.Terrain_Terrain_Vector_pop_back(self)
2658
+ r"""pop_back(Terrain_MaterialLibrary_sand_1_Vector self)"""
2659
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_pop_back(self)
2660
2660
 
2661
2661
  def erase(self, *args):
2662
2662
  r"""
2663
- erase(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
2663
+ erase(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
2664
2664
 
2665
2665
  Parameters
2666
2666
  ----------
2667
- pos: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
2667
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
2668
2668
 
2669
- erase(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
2669
+ erase(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
2670
2670
 
2671
2671
  Parameters
2672
2672
  ----------
2673
- first: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
2674
- last: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
2673
+ first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
2674
+ last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
2675
2675
 
2676
2676
  """
2677
- return _TerrainSwig.Terrain_Terrain_Vector_erase(self, *args)
2677
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_erase(self, *args)
2678
2678
 
2679
2679
  def __init__(self, *args):
2680
2680
  r"""
2681
- __init__(Terrain_Terrain_Vector self) -> Terrain_Terrain_Vector
2682
- __init__(Terrain_Terrain_Vector self, Terrain_Terrain_Vector other) -> Terrain_Terrain_Vector
2681
+ __init__(Terrain_MaterialLibrary_sand_1_Vector self) -> Terrain_MaterialLibrary_sand_1_Vector
2682
+ __init__(Terrain_MaterialLibrary_sand_1_Vector self, Terrain_MaterialLibrary_sand_1_Vector other) -> Terrain_MaterialLibrary_sand_1_Vector
2683
2683
 
2684
2684
  Parameters
2685
2685
  ----------
2686
- other: std::vector< std::shared_ptr< openplx::Terrain::Terrain > > const &
2686
+ other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > > const &
2687
2687
 
2688
- __init__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type size) -> Terrain_Terrain_Vector
2688
+ __init__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type size) -> Terrain_MaterialLibrary_sand_1_Vector
2689
2689
 
2690
2690
  Parameters
2691
2691
  ----------
2692
- size: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
2692
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
2693
2693
 
2694
- __init__(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & value) -> Terrain_Terrain_Vector
2694
+ __init__(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & value) -> Terrain_MaterialLibrary_sand_1_Vector
2695
2695
 
2696
2696
  Parameters
2697
2697
  ----------
2698
- size: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
2699
- value: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
2698
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
2699
+ value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
2700
2700
 
2701
2701
  """
2702
- _TerrainSwig.Terrain_Terrain_Vector_swiginit(self, _TerrainSwig.new_Terrain_Terrain_Vector(*args))
2702
+ _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_sand_1_Vector(*args))
2703
2703
 
2704
2704
  def push_back(self, x):
2705
2705
  r"""
2706
- push_back(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
2706
+ push_back(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
2707
2707
 
2708
2708
  Parameters
2709
2709
  ----------
2710
- x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
2710
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
2711
2711
 
2712
2712
  """
2713
- return _TerrainSwig.Terrain_Terrain_Vector_push_back(self, x)
2713
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_push_back(self, x)
2714
2714
 
2715
2715
  def front(self):
2716
- r"""front(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &"""
2717
- return _TerrainSwig.Terrain_Terrain_Vector_front(self)
2716
+ r"""front(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &"""
2717
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_front(self)
2718
2718
 
2719
2719
  def back(self):
2720
- r"""back(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &"""
2721
- return _TerrainSwig.Terrain_Terrain_Vector_back(self)
2720
+ r"""back(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &"""
2721
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_back(self)
2722
2722
 
2723
2723
  def assign(self, n, x):
2724
2724
  r"""
2725
- assign(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
2725
+ assign(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
2726
2726
 
2727
2727
  Parameters
2728
2728
  ----------
2729
- n: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
2730
- x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
2729
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
2730
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
2731
2731
 
2732
2732
  """
2733
- return _TerrainSwig.Terrain_Terrain_Vector_assign(self, n, x)
2733
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_assign(self, n, x)
2734
2734
 
2735
2735
  def resize(self, *args):
2736
2736
  r"""
2737
- resize(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type new_size)
2737
+ resize(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type new_size)
2738
2738
 
2739
2739
  Parameters
2740
2740
  ----------
2741
- new_size: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
2741
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
2742
2742
 
2743
- resize(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
2743
+ resize(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
2744
2744
 
2745
2745
  Parameters
2746
2746
  ----------
2747
- new_size: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
2748
- x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
2747
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
2748
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
2749
2749
 
2750
2750
  """
2751
- return _TerrainSwig.Terrain_Terrain_Vector_resize(self, *args)
2751
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_resize(self, *args)
2752
2752
 
2753
2753
  def insert(self, *args):
2754
2754
  r"""
2755
- insert(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
2755
+ insert(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
2756
2756
 
2757
2757
  Parameters
2758
2758
  ----------
2759
- pos: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
2760
- x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
2759
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
2760
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
2761
2761
 
2762
- insert(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const & x)
2762
+ insert(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const & x)
2763
2763
 
2764
2764
  Parameters
2765
2765
  ----------
2766
- pos: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::iterator
2767
- n: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
2768
- x: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::value_type const &
2766
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::iterator
2767
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
2768
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::value_type const &
2769
2769
 
2770
2770
  """
2771
- return _TerrainSwig.Terrain_Terrain_Vector_insert(self, *args)
2771
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_insert(self, *args)
2772
2772
 
2773
2773
  def reserve(self, n):
2774
2774
  r"""
2775
- reserve(Terrain_Terrain_Vector self, std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type n)
2775
+ reserve(Terrain_MaterialLibrary_sand_1_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type n)
2776
2776
 
2777
2777
  Parameters
2778
2778
  ----------
2779
- n: std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type
2779
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type
2780
2780
 
2781
2781
  """
2782
- return _TerrainSwig.Terrain_Terrain_Vector_reserve(self, n)
2782
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_reserve(self, n)
2783
2783
 
2784
2784
  def capacity(self):
2785
- r"""capacity(Terrain_Terrain_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::Terrain > >::size_type"""
2786
- return _TerrainSwig.Terrain_Terrain_Vector_capacity(self)
2787
- __swig_destroy__ = _TerrainSwig.delete_Terrain_Terrain_Vector
2785
+ r"""capacity(Terrain_MaterialLibrary_sand_1_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::sand_1 > >::size_type"""
2786
+ return _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_capacity(self)
2787
+ __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_sand_1_Vector
2788
2788
 
2789
- # Register Terrain_Terrain_Vector in _TerrainSwig:
2790
- _TerrainSwig.Terrain_Terrain_Vector_swigregister(Terrain_Terrain_Vector)
2789
+ # Register Terrain_MaterialLibrary_sand_1_Vector in _TerrainSwig:
2790
+ _TerrainSwig.Terrain_MaterialLibrary_sand_1_Vector_swigregister(Terrain_MaterialLibrary_sand_1_Vector)
2791
2791
 
2792
- class Terrain_TerrainMaterial_Vector(object):
2793
- r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > > class."""
2792
+ class Terrain_MaterialLibrary_wet_sand_Vector(object):
2793
+ r"""Proxy of C++ std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > > class."""
2794
2794
 
2795
2795
  thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
2796
2796
  __repr__ = _swig_repr
2797
2797
 
2798
2798
  def iterator(self):
2799
- r"""iterator(Terrain_TerrainMaterial_Vector self) -> SwigPyIterator"""
2800
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_iterator(self)
2799
+ r"""iterator(Terrain_MaterialLibrary_wet_sand_Vector self) -> SwigPyIterator"""
2800
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_iterator(self)
2801
2801
  def __iter__(self):
2802
2802
  return self.iterator()
2803
2803
 
2804
2804
  def __nonzero__(self):
2805
- r"""__nonzero__(Terrain_TerrainMaterial_Vector self) -> bool"""
2806
- return _TerrainSwig.Terrain_TerrainMaterial_Vector___nonzero__(self)
2805
+ r"""__nonzero__(Terrain_MaterialLibrary_wet_sand_Vector self) -> bool"""
2806
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___nonzero__(self)
2807
2807
 
2808
2808
  def __bool__(self):
2809
- r"""__bool__(Terrain_TerrainMaterial_Vector self) -> bool"""
2810
- return _TerrainSwig.Terrain_TerrainMaterial_Vector___bool__(self)
2809
+ r"""__bool__(Terrain_MaterialLibrary_wet_sand_Vector self) -> bool"""
2810
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___bool__(self)
2811
2811
 
2812
2812
  def __len__(self):
2813
- r"""__len__(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type"""
2814
- return _TerrainSwig.Terrain_TerrainMaterial_Vector___len__(self)
2813
+ r"""__len__(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type"""
2814
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___len__(self)
2815
2815
 
2816
2816
  def __getslice__(self, i, j):
2817
2817
  r"""
2818
- __getslice__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type j) -> Terrain_TerrainMaterial_Vector
2818
+ __getslice__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type j) -> Terrain_MaterialLibrary_wet_sand_Vector
2819
2819
 
2820
2820
  Parameters
2821
2821
  ----------
2822
- i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2823
- j: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2822
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2823
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2824
2824
 
2825
2825
  """
2826
- return _TerrainSwig.Terrain_TerrainMaterial_Vector___getslice__(self, i, j)
2826
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___getslice__(self, i, j)
2827
2827
 
2828
2828
  def __setslice__(self, *args):
2829
2829
  r"""
2830
- __setslice__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type j)
2830
+ __setslice__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type j)
2831
2831
 
2832
2832
  Parameters
2833
2833
  ----------
2834
- i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2835
- j: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2834
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2835
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2836
2836
 
2837
- __setslice__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type j, Terrain_TerrainMaterial_Vector v)
2837
+ __setslice__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type j, Terrain_MaterialLibrary_wet_sand_Vector v)
2838
2838
 
2839
2839
  Parameters
2840
2840
  ----------
2841
- i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2842
- j: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2843
- v: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial >,std::allocator< std::shared_ptr< openplx::Terrain::TerrainMaterial > > > const &
2841
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2842
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2843
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > > > const &
2844
2844
 
2845
2845
  """
2846
- return _TerrainSwig.Terrain_TerrainMaterial_Vector___setslice__(self, *args)
2846
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___setslice__(self, *args)
2847
2847
 
2848
2848
  def __delslice__(self, i, j):
2849
2849
  r"""
2850
- __delslice__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type j)
2850
+ __delslice__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type j)
2851
2851
 
2852
2852
  Parameters
2853
2853
  ----------
2854
- i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2855
- j: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2854
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2855
+ j: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2856
2856
 
2857
2857
  """
2858
- return _TerrainSwig.Terrain_TerrainMaterial_Vector___delslice__(self, i, j)
2858
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___delslice__(self, i, j)
2859
2859
 
2860
2860
  def __delitem__(self, *args):
2861
2861
  r"""
2862
- __delitem__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i)
2862
+ __delitem__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i)
2863
2863
 
2864
2864
  Parameters
2865
2865
  ----------
2866
- i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2866
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2867
2867
 
2868
- __delitem__(Terrain_TerrainMaterial_Vector self, PySliceObject * slice)
2868
+ __delitem__(Terrain_MaterialLibrary_wet_sand_Vector self, PySliceObject * slice)
2869
2869
 
2870
2870
  Parameters
2871
2871
  ----------
2872
2872
  slice: PySliceObject *
2873
2873
 
2874
2874
  """
2875
- return _TerrainSwig.Terrain_TerrainMaterial_Vector___delitem__(self, *args)
2875
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___delitem__(self, *args)
2876
2876
 
2877
2877
  def __getitem__(self, *args):
2878
2878
  r"""
2879
- __getitem__(Terrain_TerrainMaterial_Vector self, PySliceObject * slice) -> Terrain_TerrainMaterial_Vector
2879
+ __getitem__(Terrain_MaterialLibrary_wet_sand_Vector self, PySliceObject * slice) -> Terrain_MaterialLibrary_wet_sand_Vector
2880
2880
 
2881
2881
  Parameters
2882
2882
  ----------
2883
2883
  slice: PySliceObject *
2884
2884
 
2885
- __getitem__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
2885
+ __getitem__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
2886
2886
 
2887
2887
  Parameters
2888
2888
  ----------
2889
- i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2889
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2890
2890
 
2891
2891
  """
2892
- return _TerrainSwig.Terrain_TerrainMaterial_Vector___getitem__(self, *args)
2892
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___getitem__(self, *args)
2893
2893
 
2894
2894
  def __setitem__(self, *args):
2895
2895
  r"""
2896
- __setitem__(Terrain_TerrainMaterial_Vector self, PySliceObject * slice, Terrain_TerrainMaterial_Vector v)
2896
+ __setitem__(Terrain_MaterialLibrary_wet_sand_Vector self, PySliceObject * slice, Terrain_MaterialLibrary_wet_sand_Vector v)
2897
2897
 
2898
2898
  Parameters
2899
2899
  ----------
2900
2900
  slice: PySliceObject *
2901
- v: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial >,std::allocator< std::shared_ptr< openplx::Terrain::TerrainMaterial > > > const &
2901
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand >,std::allocator< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > > > const &
2902
2902
 
2903
- __setitem__(Terrain_TerrainMaterial_Vector self, PySliceObject * slice)
2903
+ __setitem__(Terrain_MaterialLibrary_wet_sand_Vector self, PySliceObject * slice)
2904
2904
 
2905
2905
  Parameters
2906
2906
  ----------
2907
2907
  slice: PySliceObject *
2908
2908
 
2909
- __setitem__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
2909
+ __setitem__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type i, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
2910
2910
 
2911
2911
  Parameters
2912
2912
  ----------
2913
- i: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::difference_type
2914
- x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
2913
+ i: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::difference_type
2914
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
2915
2915
 
2916
2916
  """
2917
- return _TerrainSwig.Terrain_TerrainMaterial_Vector___setitem__(self, *args)
2917
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector___setitem__(self, *args)
2918
2918
 
2919
2919
  def pop(self):
2920
- r"""pop(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type"""
2921
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_pop(self)
2920
+ r"""pop(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type"""
2921
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_pop(self)
2922
2922
 
2923
2923
  def append(self, x):
2924
2924
  r"""
2925
- append(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
2925
+ append(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
2926
2926
 
2927
2927
  Parameters
2928
2928
  ----------
2929
- x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
2929
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
2930
2930
 
2931
2931
  """
2932
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_append(self, x)
2932
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_append(self, x)
2933
2933
 
2934
2934
  def empty(self):
2935
- r"""empty(Terrain_TerrainMaterial_Vector self) -> bool"""
2936
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_empty(self)
2935
+ r"""empty(Terrain_MaterialLibrary_wet_sand_Vector self) -> bool"""
2936
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_empty(self)
2937
2937
 
2938
2938
  def size(self):
2939
- r"""size(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type"""
2940
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_size(self)
2939
+ r"""size(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type"""
2940
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_size(self)
2941
2941
 
2942
2942
  def swap(self, v):
2943
2943
  r"""
2944
- swap(Terrain_TerrainMaterial_Vector self, Terrain_TerrainMaterial_Vector v)
2944
+ swap(Terrain_MaterialLibrary_wet_sand_Vector self, Terrain_MaterialLibrary_wet_sand_Vector v)
2945
2945
 
2946
2946
  Parameters
2947
2947
  ----------
2948
- v: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > > &
2948
+ v: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > > &
2949
2949
 
2950
2950
  """
2951
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_swap(self, v)
2951
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_swap(self, v)
2952
2952
 
2953
2953
  def begin(self):
2954
- r"""begin(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator"""
2955
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_begin(self)
2954
+ r"""begin(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator"""
2955
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_begin(self)
2956
2956
 
2957
2957
  def end(self):
2958
- r"""end(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator"""
2959
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_end(self)
2958
+ r"""end(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator"""
2959
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_end(self)
2960
2960
 
2961
2961
  def rbegin(self):
2962
- r"""rbegin(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::reverse_iterator"""
2963
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_rbegin(self)
2962
+ r"""rbegin(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::reverse_iterator"""
2963
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_rbegin(self)
2964
2964
 
2965
2965
  def rend(self):
2966
- r"""rend(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::reverse_iterator"""
2967
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_rend(self)
2966
+ r"""rend(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::reverse_iterator"""
2967
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_rend(self)
2968
2968
 
2969
2969
  def clear(self):
2970
- r"""clear(Terrain_TerrainMaterial_Vector self)"""
2971
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_clear(self)
2970
+ r"""clear(Terrain_MaterialLibrary_wet_sand_Vector self)"""
2971
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_clear(self)
2972
2972
 
2973
2973
  def get_allocator(self):
2974
- r"""get_allocator(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::allocator_type"""
2975
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_get_allocator(self)
2974
+ r"""get_allocator(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::allocator_type"""
2975
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_get_allocator(self)
2976
2976
 
2977
2977
  def pop_back(self):
2978
- r"""pop_back(Terrain_TerrainMaterial_Vector self)"""
2979
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_pop_back(self)
2978
+ r"""pop_back(Terrain_MaterialLibrary_wet_sand_Vector self)"""
2979
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_pop_back(self)
2980
2980
 
2981
2981
  def erase(self, *args):
2982
2982
  r"""
2983
- erase(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
2983
+ erase(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator pos) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2984
2984
 
2985
2985
  Parameters
2986
2986
  ----------
2987
- pos: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
2987
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2988
2988
 
2989
- erase(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
2989
+ erase(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator first, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator last) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2990
2990
 
2991
2991
  Parameters
2992
2992
  ----------
2993
- first: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
2994
- last: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
2993
+ first: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2994
+ last: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
2995
2995
 
2996
2996
  """
2997
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_erase(self, *args)
2997
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_erase(self, *args)
2998
2998
 
2999
2999
  def __init__(self, *args):
3000
3000
  r"""
3001
- __init__(Terrain_TerrainMaterial_Vector self) -> Terrain_TerrainMaterial_Vector
3002
- __init__(Terrain_TerrainMaterial_Vector self, Terrain_TerrainMaterial_Vector other) -> Terrain_TerrainMaterial_Vector
3001
+ __init__(Terrain_MaterialLibrary_wet_sand_Vector self) -> Terrain_MaterialLibrary_wet_sand_Vector
3002
+ __init__(Terrain_MaterialLibrary_wet_sand_Vector self, Terrain_MaterialLibrary_wet_sand_Vector other) -> Terrain_MaterialLibrary_wet_sand_Vector
3003
3003
 
3004
3004
  Parameters
3005
3005
  ----------
3006
- other: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > > const &
3006
+ other: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > > const &
3007
3007
 
3008
- __init__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type size) -> Terrain_TerrainMaterial_Vector
3008
+ __init__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type size) -> Terrain_MaterialLibrary_wet_sand_Vector
3009
3009
 
3010
3010
  Parameters
3011
3011
  ----------
3012
- size: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
3012
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
3013
3013
 
3014
- __init__(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & value) -> Terrain_TerrainMaterial_Vector
3014
+ __init__(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & value) -> Terrain_MaterialLibrary_wet_sand_Vector
3015
3015
 
3016
3016
  Parameters
3017
3017
  ----------
3018
- size: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
3019
- value: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
3018
+ size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
3019
+ value: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
3020
3020
 
3021
3021
  """
3022
- _TerrainSwig.Terrain_TerrainMaterial_Vector_swiginit(self, _TerrainSwig.new_Terrain_TerrainMaterial_Vector(*args))
3022
+ _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_swiginit(self, _TerrainSwig.new_Terrain_MaterialLibrary_wet_sand_Vector(*args))
3023
3023
 
3024
3024
  def push_back(self, x):
3025
3025
  r"""
3026
- push_back(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
3026
+ push_back(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
3027
3027
 
3028
3028
  Parameters
3029
3029
  ----------
3030
- x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
3030
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
3031
3031
 
3032
3032
  """
3033
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_push_back(self, x)
3033
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_push_back(self, x)
3034
3034
 
3035
3035
  def front(self):
3036
- r"""front(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &"""
3037
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_front(self)
3036
+ r"""front(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &"""
3037
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_front(self)
3038
3038
 
3039
3039
  def back(self):
3040
- r"""back(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &"""
3041
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_back(self)
3040
+ r"""back(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &"""
3041
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_back(self)
3042
3042
 
3043
3043
  def assign(self, n, x):
3044
3044
  r"""
3045
- assign(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
3045
+ assign(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
3046
3046
 
3047
3047
  Parameters
3048
3048
  ----------
3049
- n: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
3050
- x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
3049
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
3050
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
3051
3051
 
3052
3052
  """
3053
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_assign(self, n, x)
3053
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_assign(self, n, x)
3054
3054
 
3055
3055
  def resize(self, *args):
3056
3056
  r"""
3057
- resize(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type new_size)
3057
+ resize(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type new_size)
3058
3058
 
3059
3059
  Parameters
3060
3060
  ----------
3061
- new_size: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
3061
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
3062
3062
 
3063
- resize(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
3063
+ resize(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type new_size, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
3064
3064
 
3065
3065
  Parameters
3066
3066
  ----------
3067
- new_size: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
3068
- x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
3067
+ new_size: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
3068
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
3069
3069
 
3070
3070
  """
3071
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_resize(self, *args)
3071
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_resize(self, *args)
3072
3072
 
3073
3073
  def insert(self, *args):
3074
3074
  r"""
3075
- insert(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
3075
+ insert(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
3076
3076
 
3077
3077
  Parameters
3078
3078
  ----------
3079
- pos: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
3080
- x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
3079
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
3080
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
3081
3081
 
3082
- insert(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const & x)
3082
+ insert(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator pos, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type n, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const & x)
3083
3083
 
3084
3084
  Parameters
3085
3085
  ----------
3086
- pos: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::iterator
3087
- n: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
3088
- x: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::value_type const &
3086
+ pos: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::iterator
3087
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
3088
+ x: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::value_type const &
3089
3089
 
3090
3090
  """
3091
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_insert(self, *args)
3091
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_insert(self, *args)
3092
3092
 
3093
3093
  def reserve(self, n):
3094
3094
  r"""
3095
- reserve(Terrain_TerrainMaterial_Vector self, std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type n)
3095
+ reserve(Terrain_MaterialLibrary_wet_sand_Vector self, std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type n)
3096
3096
 
3097
3097
  Parameters
3098
3098
  ----------
3099
- n: std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type
3099
+ n: std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type
3100
3100
 
3101
3101
  """
3102
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_reserve(self, n)
3102
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_reserve(self, n)
3103
3103
 
3104
3104
  def capacity(self):
3105
- r"""capacity(Terrain_TerrainMaterial_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::TerrainMaterial > >::size_type"""
3106
- return _TerrainSwig.Terrain_TerrainMaterial_Vector_capacity(self)
3107
- __swig_destroy__ = _TerrainSwig.delete_Terrain_TerrainMaterial_Vector
3105
+ r"""capacity(Terrain_MaterialLibrary_wet_sand_Vector self) -> std::vector< std::shared_ptr< openplx::Terrain::MaterialLibrary::wet_sand > >::size_type"""
3106
+ return _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_capacity(self)
3107
+ __swig_destroy__ = _TerrainSwig.delete_Terrain_MaterialLibrary_wet_sand_Vector
3108
3108
 
3109
- # Register Terrain_TerrainMaterial_Vector in _TerrainSwig:
3110
- _TerrainSwig.Terrain_TerrainMaterial_Vector_swigregister(Terrain_TerrainMaterial_Vector)
3109
+ # Register Terrain_MaterialLibrary_wet_sand_Vector in _TerrainSwig:
3110
+ _TerrainSwig.Terrain_MaterialLibrary_wet_sand_Vector_swigregister(Terrain_MaterialLibrary_wet_sand_Vector)
3111
3111
 
3112
3112
  class Terrain_TerrainMaterial(openplx.Physics.Physics_Charges_Material):
3113
3113
  r"""Proxy of C++ openplx::Terrain::TerrainMaterial class."""