1390 lines
52 KiB
Python
1390 lines
52 KiB
Python
# This file was automatically generated by SWIG (http://www.swig.org).
|
|
# Version 4.0.1
|
|
#
|
|
# Do not make changes to this file unless you know what you are doing--modify
|
|
# the SWIG interface file instead.
|
|
|
|
from sys import version_info as _swig_python_version_info
|
|
if _swig_python_version_info < (2, 7, 0):
|
|
raise RuntimeError("Python 2.7 or later required")
|
|
|
|
# Import the low-level C/C++ module
|
|
if __package__ or "." in __name__:
|
|
from lib import _py3dna
|
|
else:
|
|
import _py3dna
|
|
|
|
try:
|
|
import builtins as __builtin__
|
|
except ImportError:
|
|
import __builtin__
|
|
|
|
def _swig_repr(self):
|
|
try:
|
|
strthis = "proxy of " + self.this.__repr__()
|
|
except __builtin__.Exception:
|
|
strthis = ""
|
|
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
|
|
|
|
|
|
def _swig_setattr_nondynamic_instance_variable(set):
|
|
def set_instance_attr(self, name, value):
|
|
if name == "thisown":
|
|
self.this.own(value)
|
|
elif name == "this":
|
|
set(self, name, value)
|
|
elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
|
|
set(self, name, value)
|
|
else:
|
|
raise AttributeError("You cannot add instance attributes to %s" % self)
|
|
return set_instance_attr
|
|
|
|
|
|
def _swig_setattr_nondynamic_class_variable(set):
|
|
def set_class_attr(cls, name, value):
|
|
if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
|
|
set(cls, name, value)
|
|
else:
|
|
raise AttributeError("You cannot add class attributes to %s" % cls)
|
|
return set_class_attr
|
|
|
|
|
|
def _swig_add_metaclass(metaclass):
|
|
"""Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
|
|
def wrapper(cls):
|
|
return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
|
|
return wrapper
|
|
|
|
|
|
class _SwigNonDynamicMeta(type):
|
|
"""Meta class to enforce nondynamic attributes (no new attributes) for a class"""
|
|
__setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
|
|
|
|
|
|
|
|
def __new_decorator(factory_func, original_new):
|
|
@staticmethod
|
|
def __new(cls, *args, **kwargs):
|
|
# FIXME: while this workaround solves the immediate issue with the set of classes we currently have,
|
|
# it will fail for classes that use a factory function but need no parameters at all, in which case
|
|
# the factory function will never be invoked, only the original __new__ function.
|
|
if args or kwargs:
|
|
return factory_func(*args, **kwargs)
|
|
return original_new(cls)
|
|
return __new
|
|
|
|
def __managed_init(self, *args, **kwargs):
|
|
self._args = args
|
|
self._kwargs = kwargs
|
|
|
|
class MemoryResource(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _py3dna.delete_MemoryResource
|
|
|
|
def allocate(self, size, alignment):
|
|
return _py3dna.MemoryResource_allocate(self, size, alignment)
|
|
|
|
def deallocate(self, ptr, size, alignment):
|
|
return _py3dna.MemoryResource_deallocate(self, ptr, size, alignment)
|
|
|
|
# Register MemoryResource in _py3dna:
|
|
_py3dna.MemoryResource_swigregister(MemoryResource)
|
|
|
|
class AlignedMemoryResource(MemoryResource):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def allocate(self, size, alignment):
|
|
return _py3dna.AlignedMemoryResource_allocate(self, size, alignment)
|
|
|
|
def deallocate(self, ptr, size, alignment):
|
|
return _py3dna.AlignedMemoryResource_deallocate(self, ptr, size, alignment)
|
|
|
|
def __init__(self):
|
|
_py3dna.AlignedMemoryResource_swiginit(self, _py3dna.new_AlignedMemoryResource())
|
|
__swig_destroy__ = _py3dna.delete_AlignedMemoryResource
|
|
|
|
# Register AlignedMemoryResource in _py3dna:
|
|
_py3dna.AlignedMemoryResource_swigregister(AlignedMemoryResource)
|
|
|
|
class ArenaMemoryResource(MemoryResource):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _py3dna.delete_ArenaMemoryResource
|
|
|
|
def __init__(self, *args):
|
|
_py3dna.ArenaMemoryResource_swiginit(self, _py3dna.new_ArenaMemoryResource(*args))
|
|
|
|
def allocate(self, size, alignment):
|
|
return _py3dna.ArenaMemoryResource_allocate(self, size, alignment)
|
|
|
|
def deallocate(self, ptr, size, alignment):
|
|
return _py3dna.ArenaMemoryResource_deallocate(self, ptr, size, alignment)
|
|
|
|
def getUpstreamMemoryResource(self):
|
|
return _py3dna.ArenaMemoryResource_getUpstreamMemoryResource(self)
|
|
|
|
# Register ArenaMemoryResource in _py3dna:
|
|
_py3dna.ArenaMemoryResource_swigregister(ArenaMemoryResource)
|
|
|
|
class DefaultMemoryResource(MemoryResource):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def allocate(self, size, alignment):
|
|
return _py3dna.DefaultMemoryResource_allocate(self, size, alignment)
|
|
|
|
def deallocate(self, ptr, size, alignment):
|
|
return _py3dna.DefaultMemoryResource_deallocate(self, ptr, size, alignment)
|
|
|
|
def __init__(self):
|
|
_py3dna.DefaultMemoryResource_swiginit(self, _py3dna.new_DefaultMemoryResource())
|
|
__swig_destroy__ = _py3dna.delete_DefaultMemoryResource
|
|
|
|
# Register DefaultMemoryResource in _py3dna:
|
|
_py3dna.DefaultMemoryResource_swigregister(DefaultMemoryResource)
|
|
|
|
class StatusCode(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
code = property(_py3dna.StatusCode_code_get, _py3dna.StatusCode_code_set)
|
|
message = property(_py3dna.StatusCode_message_get, _py3dna.StatusCode_message_set)
|
|
|
|
def __init__(self):
|
|
_py3dna.StatusCode_swiginit(self, _py3dna.new_StatusCode())
|
|
__swig_destroy__ = _py3dna.delete_StatusCode
|
|
|
|
# Register StatusCode in _py3dna:
|
|
_py3dna.StatusCode_swigregister(StatusCode)
|
|
|
|
class Status(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def isOk():
|
|
return _py3dna.Status_isOk()
|
|
|
|
@staticmethod
|
|
def get():
|
|
return _py3dna.Status_get()
|
|
|
|
def __init__(self):
|
|
_py3dna.Status_swiginit(self, _py3dna.new_Status())
|
|
__swig_destroy__ = _py3dna.delete_Status
|
|
|
|
# Register Status in _py3dna:
|
|
_py3dna.Status_swigregister(Status)
|
|
|
|
def Status_isOk():
|
|
return _py3dna.Status_isOk()
|
|
|
|
def Status_get():
|
|
return _py3dna.Status_get()
|
|
|
|
class Readable(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def read(self, *args):
|
|
return _py3dna.Readable_read(self, *args)
|
|
|
|
# Register Readable in _py3dna:
|
|
_py3dna.Readable_swigregister(Readable)
|
|
|
|
class Writable(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def write(self, *args):
|
|
return _py3dna.Writable_write(self, *args)
|
|
|
|
# Register Writable in _py3dna:
|
|
_py3dna.Writable_swigregister(Writable)
|
|
|
|
class Seekable(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def tell(self):
|
|
return _py3dna.Seekable_tell(self)
|
|
|
|
def seek(self, position):
|
|
return _py3dna.Seekable_seek(self, position)
|
|
|
|
# Register Seekable in _py3dna:
|
|
_py3dna.Seekable_swigregister(Seekable)
|
|
|
|
class Openable(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def open(self):
|
|
return _py3dna.Openable_open(self)
|
|
|
|
# Register Openable in _py3dna:
|
|
_py3dna.Openable_swigregister(Openable)
|
|
|
|
class Closeable(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def close(self):
|
|
return _py3dna.Closeable_close(self)
|
|
|
|
# Register Closeable in _py3dna:
|
|
_py3dna.Closeable_swigregister(Closeable)
|
|
|
|
class Controllable(Openable, Closeable):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
# Register Controllable in _py3dna:
|
|
_py3dna.Controllable_swigregister(Controllable)
|
|
|
|
class Bounded(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def size(self):
|
|
return _py3dna.Bounded_size(self)
|
|
|
|
# Register Bounded in _py3dna:
|
|
_py3dna.Bounded_swigregister(Bounded)
|
|
|
|
class Buffered(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def flush(self):
|
|
return _py3dna.Buffered_flush(self)
|
|
|
|
# Register Buffered in _py3dna:
|
|
_py3dna.Buffered_swigregister(Buffered)
|
|
|
|
class Resizable(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def resize(self, size):
|
|
return _py3dna.Resizable_resize(self, size)
|
|
|
|
# Register Resizable in _py3dna:
|
|
_py3dna.Resizable_swigregister(Resizable)
|
|
|
|
class BoundedIOStream(Controllable, Readable, Writable, Seekable, Bounded):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _py3dna.delete_BoundedIOStream
|
|
|
|
# Register BoundedIOStream in _py3dna:
|
|
_py3dna.BoundedIOStream_swigregister(BoundedIOStream)
|
|
cvar = _py3dna.cvar
|
|
BoundedIOStream.OpenError = _py3dna.cvar.BoundedIOStream_OpenError
|
|
BoundedIOStream.ReadError = _py3dna.cvar.BoundedIOStream_ReadError
|
|
BoundedIOStream.WriteError = _py3dna.cvar.BoundedIOStream_WriteError
|
|
BoundedIOStream.AlreadyOpenError = _py3dna.cvar.BoundedIOStream_AlreadyOpenError
|
|
BoundedIOStream.SeekError = _py3dna.cvar.BoundedIOStream_SeekError
|
|
|
|
AccessMode_Read = _py3dna.AccessMode_Read
|
|
AccessMode_Write = _py3dna.AccessMode_Write
|
|
AccessMode_ReadWrite = _py3dna.AccessMode_ReadWrite
|
|
OpenMode_Binary = _py3dna.OpenMode_Binary
|
|
OpenMode_Text = _py3dna.OpenMode_Text
|
|
class FileStream(BoundedIOStream):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def create(path, accessMode, openMode, memRes=None):
|
|
return _py3dna.FileStream_create(path, accessMode, openMode, memRes)
|
|
|
|
@staticmethod
|
|
def destroy(instance):
|
|
return _py3dna.FileStream_destroy(instance)
|
|
__swig_destroy__ = _py3dna.delete_FileStream
|
|
|
|
# Register FileStream in _py3dna:
|
|
_py3dna.FileStream_swigregister(FileStream)
|
|
|
|
def FileStream_create(path, accessMode, openMode, memRes=None):
|
|
return _py3dna.FileStream_create(path, accessMode, openMode, memRes)
|
|
|
|
def FileStream_destroy(instance):
|
|
return _py3dna.FileStream_destroy(instance)
|
|
|
|
class MemoryMappedFileStream(BoundedIOStream, Buffered, Resizable):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def create(path, accessMode, memRes=None):
|
|
return _py3dna.MemoryMappedFileStream_create(path, accessMode, memRes)
|
|
|
|
@staticmethod
|
|
def destroy(instance):
|
|
return _py3dna.MemoryMappedFileStream_destroy(instance)
|
|
__swig_destroy__ = _py3dna.delete_MemoryMappedFileStream
|
|
|
|
# Register MemoryMappedFileStream in _py3dna:
|
|
_py3dna.MemoryMappedFileStream_swigregister(MemoryMappedFileStream)
|
|
|
|
def MemoryMappedFileStream_create(path, accessMode, memRes=None):
|
|
return _py3dna.MemoryMappedFileStream_create(path, accessMode, memRes)
|
|
|
|
def MemoryMappedFileStream_destroy(instance):
|
|
return _py3dna.MemoryMappedFileStream_destroy(instance)
|
|
|
|
class MemoryStream(BoundedIOStream):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def create(*args):
|
|
return _py3dna.MemoryStream_create(*args)
|
|
|
|
@staticmethod
|
|
def destroy(instance):
|
|
return _py3dna.MemoryStream_destroy(instance)
|
|
__swig_destroy__ = _py3dna.delete_MemoryStream
|
|
|
|
# Register MemoryStream in _py3dna:
|
|
_py3dna.MemoryStream_swigregister(MemoryStream)
|
|
|
|
def MemoryStream_create(*args):
|
|
return _py3dna.MemoryStream_create(*args)
|
|
|
|
def MemoryStream_destroy(instance):
|
|
return _py3dna.MemoryStream_destroy(instance)
|
|
|
|
|
|
FileStream.__new__ = __new_decorator(FileStream_create, FileStream.__new__)
|
|
FileStream.__del__ = lambda instance: FileStream_destroy(instance)
|
|
FileStream.__init__ = __managed_init
|
|
del FileStream.create
|
|
del FileStream.destroy
|
|
|
|
|
|
MemoryMappedFileStream.__new__ = __new_decorator(MemoryMappedFileStream_create, MemoryMappedFileStream.__new__)
|
|
MemoryMappedFileStream.__del__ = lambda instance: MemoryMappedFileStream_destroy(instance)
|
|
MemoryMappedFileStream.__init__ = __managed_init
|
|
del MemoryMappedFileStream.create
|
|
del MemoryMappedFileStream.destroy
|
|
|
|
|
|
MemoryStream.__new__ = __new_decorator(MemoryStream_create, MemoryStream.__new__)
|
|
MemoryStream.__del__ = lambda instance: MemoryStream_destroy(instance)
|
|
MemoryStream.__init__ = __managed_init
|
|
del MemoryStream.create
|
|
del MemoryStream.destroy
|
|
|
|
|
|
FileStream.AccessMode_Read = AccessMode_Read
|
|
FileStream.AccessMode_Write = AccessMode_Write
|
|
FileStream.AccessMode_ReadWrite = AccessMode_ReadWrite
|
|
|
|
FileStream.OpenMode_Binary = OpenMode_Binary
|
|
FileStream.OpenMode_Text = OpenMode_Text
|
|
|
|
MemoryMappedFileStream.AccessMode_Read = AccessMode_Read
|
|
MemoryMappedFileStream.AccessMode_Write = AccessMode_Write
|
|
MemoryMappedFileStream.AccessMode_ReadWrite = AccessMode_ReadWrite
|
|
|
|
class StringView(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def c_str(self):
|
|
return _py3dna.StringView_c_str(self)
|
|
|
|
def __ref__(self):
|
|
return _py3dna.StringView___ref__(self)
|
|
|
|
def __init__(self):
|
|
_py3dna.StringView_swiginit(self, _py3dna.new_StringView())
|
|
__swig_destroy__ = _py3dna.delete_StringView
|
|
|
|
# Register StringView in _py3dna:
|
|
_py3dna.StringView_swigregister(StringView)
|
|
|
|
|
|
def __add__(*args):
|
|
return _py3dna.__add__(*args)
|
|
|
|
def __sub__(*args):
|
|
return _py3dna.__sub__(*args)
|
|
|
|
def __mul__(*args):
|
|
return _py3dna.__mul__(*args)
|
|
|
|
def __truediv__(*args):
|
|
return _py3dna.__truediv__(*args)
|
|
|
|
def __eq__(*args):
|
|
return _py3dna.__eq__(*args)
|
|
|
|
def __ne__(*args):
|
|
return _py3dna.__ne__(*args)
|
|
DataLayer_Descriptor = _py3dna.DataLayer_Descriptor
|
|
DataLayer_Definition = _py3dna.DataLayer_Definition
|
|
DataLayer_Behavior = _py3dna.DataLayer_Behavior
|
|
DataLayer_Geometry = _py3dna.DataLayer_Geometry
|
|
DataLayer_GeometryWithoutBlendShapes = _py3dna.DataLayer_GeometryWithoutBlendShapes
|
|
DataLayer_AllWithoutBlendShapes = _py3dna.DataLayer_AllWithoutBlendShapes
|
|
DataLayer_All = _py3dna.DataLayer_All
|
|
Archetype_asian = _py3dna.Archetype_asian
|
|
Archetype_black = _py3dna.Archetype_black
|
|
Archetype_caucasian = _py3dna.Archetype_caucasian
|
|
Archetype_hispanic = _py3dna.Archetype_hispanic
|
|
Archetype_alien = _py3dna.Archetype_alien
|
|
Archetype_other = _py3dna.Archetype_other
|
|
Gender_male = _py3dna.Gender_male
|
|
Gender_female = _py3dna.Gender_female
|
|
Gender_other = _py3dna.Gender_other
|
|
TranslationUnit_cm = _py3dna.TranslationUnit_cm
|
|
TranslationUnit_m = _py3dna.TranslationUnit_m
|
|
RotationUnit_degrees = _py3dna.RotationUnit_degrees
|
|
RotationUnit_radians = _py3dna.RotationUnit_radians
|
|
Direction_left = _py3dna.Direction_left
|
|
Direction_right = _py3dna.Direction_right
|
|
Direction_up = _py3dna.Direction_up
|
|
Direction_down = _py3dna.Direction_down
|
|
Direction_front = _py3dna.Direction_front
|
|
Direction_back = _py3dna.Direction_back
|
|
class CoordinateSystem(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
xAxis = property(_py3dna.CoordinateSystem_xAxis_get, _py3dna.CoordinateSystem_xAxis_set)
|
|
yAxis = property(_py3dna.CoordinateSystem_yAxis_get, _py3dna.CoordinateSystem_yAxis_set)
|
|
zAxis = property(_py3dna.CoordinateSystem_zAxis_get, _py3dna.CoordinateSystem_zAxis_set)
|
|
|
|
def __init__(self):
|
|
_py3dna.CoordinateSystem_swiginit(self, _py3dna.new_CoordinateSystem())
|
|
__swig_destroy__ = _py3dna.delete_CoordinateSystem
|
|
|
|
# Register CoordinateSystem in _py3dna:
|
|
_py3dna.CoordinateSystem_swigregister(CoordinateSystem)
|
|
|
|
class DescriptorReader(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def getName(self):
|
|
return _py3dna.DescriptorReader_getName(self)
|
|
|
|
def getArchetype(self):
|
|
return _py3dna.DescriptorReader_getArchetype(self)
|
|
|
|
def getGender(self):
|
|
return _py3dna.DescriptorReader_getGender(self)
|
|
|
|
def getAge(self):
|
|
return _py3dna.DescriptorReader_getAge(self)
|
|
|
|
def getMetaDataCount(self):
|
|
return _py3dna.DescriptorReader_getMetaDataCount(self)
|
|
|
|
def getMetaDataKey(self, index):
|
|
return _py3dna.DescriptorReader_getMetaDataKey(self, index)
|
|
|
|
def getMetaDataValue(self, key):
|
|
return _py3dna.DescriptorReader_getMetaDataValue(self, key)
|
|
|
|
def getTranslationUnit(self):
|
|
return _py3dna.DescriptorReader_getTranslationUnit(self)
|
|
|
|
def getRotationUnit(self):
|
|
return _py3dna.DescriptorReader_getRotationUnit(self)
|
|
|
|
def getCoordinateSystem(self):
|
|
return _py3dna.DescriptorReader_getCoordinateSystem(self)
|
|
|
|
def getLODCount(self):
|
|
return _py3dna.DescriptorReader_getLODCount(self)
|
|
|
|
def getDBMaxLOD(self):
|
|
return _py3dna.DescriptorReader_getDBMaxLOD(self)
|
|
|
|
def getDBComplexity(self):
|
|
return _py3dna.DescriptorReader_getDBComplexity(self)
|
|
|
|
def getDBName(self):
|
|
return _py3dna.DescriptorReader_getDBName(self)
|
|
|
|
# Register DescriptorReader in _py3dna:
|
|
_py3dna.DescriptorReader_swigregister(DescriptorReader)
|
|
|
|
class MeshBlendShapeChannelMapping(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
meshIndex = property(_py3dna.MeshBlendShapeChannelMapping_meshIndex_get, _py3dna.MeshBlendShapeChannelMapping_meshIndex_set)
|
|
blendShapeChannelIndex = property(_py3dna.MeshBlendShapeChannelMapping_blendShapeChannelIndex_get, _py3dna.MeshBlendShapeChannelMapping_blendShapeChannelIndex_set)
|
|
|
|
def __init__(self):
|
|
_py3dna.MeshBlendShapeChannelMapping_swiginit(self, _py3dna.new_MeshBlendShapeChannelMapping())
|
|
__swig_destroy__ = _py3dna.delete_MeshBlendShapeChannelMapping
|
|
|
|
# Register MeshBlendShapeChannelMapping in _py3dna:
|
|
_py3dna.MeshBlendShapeChannelMapping_swigregister(MeshBlendShapeChannelMapping)
|
|
|
|
class DefinitionReader(DescriptorReader):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def getGUIControlCount(self):
|
|
return _py3dna.DefinitionReader_getGUIControlCount(self)
|
|
|
|
def getGUIControlName(self, index):
|
|
return _py3dna.DefinitionReader_getGUIControlName(self, index)
|
|
|
|
def getRawControlCount(self):
|
|
return _py3dna.DefinitionReader_getRawControlCount(self)
|
|
|
|
def getRawControlName(self, index):
|
|
return _py3dna.DefinitionReader_getRawControlName(self, index)
|
|
|
|
def getJointCount(self):
|
|
return _py3dna.DefinitionReader_getJointCount(self)
|
|
|
|
def getJointName(self, index):
|
|
return _py3dna.DefinitionReader_getJointName(self, index)
|
|
|
|
def getJointIndexListCount(self):
|
|
return _py3dna.DefinitionReader_getJointIndexListCount(self)
|
|
|
|
def getJointIndicesForLOD(self, lod):
|
|
return _py3dna.DefinitionReader_getJointIndicesForLOD(self, lod)
|
|
|
|
def getJointParentIndex(self, index):
|
|
return _py3dna.DefinitionReader_getJointParentIndex(self, index)
|
|
|
|
def getBlendShapeChannelCount(self):
|
|
return _py3dna.DefinitionReader_getBlendShapeChannelCount(self)
|
|
|
|
def getBlendShapeChannelName(self, index):
|
|
return _py3dna.DefinitionReader_getBlendShapeChannelName(self, index)
|
|
|
|
def getBlendShapeChannelIndexListCount(self):
|
|
return _py3dna.DefinitionReader_getBlendShapeChannelIndexListCount(self)
|
|
|
|
def getBlendShapeChannelIndicesForLOD(self, lod):
|
|
return _py3dna.DefinitionReader_getBlendShapeChannelIndicesForLOD(self, lod)
|
|
|
|
def getAnimatedMapCount(self):
|
|
return _py3dna.DefinitionReader_getAnimatedMapCount(self)
|
|
|
|
def getAnimatedMapName(self, index):
|
|
return _py3dna.DefinitionReader_getAnimatedMapName(self, index)
|
|
|
|
def getAnimatedMapIndexListCount(self):
|
|
return _py3dna.DefinitionReader_getAnimatedMapIndexListCount(self)
|
|
|
|
def getAnimatedMapIndicesForLOD(self, lod):
|
|
return _py3dna.DefinitionReader_getAnimatedMapIndicesForLOD(self, lod)
|
|
|
|
def getMeshCount(self):
|
|
return _py3dna.DefinitionReader_getMeshCount(self)
|
|
|
|
def getMeshName(self, index):
|
|
return _py3dna.DefinitionReader_getMeshName(self, index)
|
|
|
|
def getMeshIndexListCount(self):
|
|
return _py3dna.DefinitionReader_getMeshIndexListCount(self)
|
|
|
|
def getMeshIndicesForLOD(self, lod):
|
|
return _py3dna.DefinitionReader_getMeshIndicesForLOD(self, lod)
|
|
|
|
def getMeshBlendShapeChannelMappingCount(self):
|
|
return _py3dna.DefinitionReader_getMeshBlendShapeChannelMappingCount(self)
|
|
|
|
def getMeshBlendShapeChannelMapping(self, index):
|
|
return _py3dna.DefinitionReader_getMeshBlendShapeChannelMapping(self, index)
|
|
|
|
def getMeshBlendShapeChannelMappingIndicesForLOD(self, lod):
|
|
return _py3dna.DefinitionReader_getMeshBlendShapeChannelMappingIndicesForLOD(self, lod)
|
|
|
|
def getNeutralJointTranslation(self, index):
|
|
return _py3dna.DefinitionReader_getNeutralJointTranslation(self, index)
|
|
|
|
def getNeutralJointTranslationXs(self):
|
|
return _py3dna.DefinitionReader_getNeutralJointTranslationXs(self)
|
|
|
|
def getNeutralJointTranslationYs(self):
|
|
return _py3dna.DefinitionReader_getNeutralJointTranslationYs(self)
|
|
|
|
def getNeutralJointTranslationZs(self):
|
|
return _py3dna.DefinitionReader_getNeutralJointTranslationZs(self)
|
|
|
|
def getNeutralJointRotation(self, index):
|
|
return _py3dna.DefinitionReader_getNeutralJointRotation(self, index)
|
|
|
|
def getNeutralJointRotationXs(self):
|
|
return _py3dna.DefinitionReader_getNeutralJointRotationXs(self)
|
|
|
|
def getNeutralJointRotationYs(self):
|
|
return _py3dna.DefinitionReader_getNeutralJointRotationYs(self)
|
|
|
|
def getNeutralJointRotationZs(self):
|
|
return _py3dna.DefinitionReader_getNeutralJointRotationZs(self)
|
|
|
|
# Register DefinitionReader in _py3dna:
|
|
_py3dna.DefinitionReader_swigregister(DefinitionReader)
|
|
|
|
class BehaviorReader(DefinitionReader):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def getGUIToRawInputIndices(self):
|
|
return _py3dna.BehaviorReader_getGUIToRawInputIndices(self)
|
|
|
|
def getGUIToRawOutputIndices(self):
|
|
return _py3dna.BehaviorReader_getGUIToRawOutputIndices(self)
|
|
|
|
def getGUIToRawFromValues(self):
|
|
return _py3dna.BehaviorReader_getGUIToRawFromValues(self)
|
|
|
|
def getGUIToRawToValues(self):
|
|
return _py3dna.BehaviorReader_getGUIToRawToValues(self)
|
|
|
|
def getGUIToRawSlopeValues(self):
|
|
return _py3dna.BehaviorReader_getGUIToRawSlopeValues(self)
|
|
|
|
def getGUIToRawCutValues(self):
|
|
return _py3dna.BehaviorReader_getGUIToRawCutValues(self)
|
|
|
|
def getPSDCount(self):
|
|
return _py3dna.BehaviorReader_getPSDCount(self)
|
|
|
|
def getPSDRowIndices(self):
|
|
return _py3dna.BehaviorReader_getPSDRowIndices(self)
|
|
|
|
def getPSDColumnIndices(self):
|
|
return _py3dna.BehaviorReader_getPSDColumnIndices(self)
|
|
|
|
def getPSDValues(self):
|
|
return _py3dna.BehaviorReader_getPSDValues(self)
|
|
|
|
def getJointRowCount(self):
|
|
return _py3dna.BehaviorReader_getJointRowCount(self)
|
|
|
|
def getJointColumnCount(self):
|
|
return _py3dna.BehaviorReader_getJointColumnCount(self)
|
|
|
|
def getJointVariableAttributeIndices(self, lod):
|
|
return _py3dna.BehaviorReader_getJointVariableAttributeIndices(self, lod)
|
|
|
|
def getJointGroupCount(self):
|
|
return _py3dna.BehaviorReader_getJointGroupCount(self)
|
|
|
|
def getJointGroupLODs(self, jointGroupIndex):
|
|
return _py3dna.BehaviorReader_getJointGroupLODs(self, jointGroupIndex)
|
|
|
|
def getJointGroupInputIndices(self, jointGroupIndex):
|
|
return _py3dna.BehaviorReader_getJointGroupInputIndices(self, jointGroupIndex)
|
|
|
|
def getJointGroupOutputIndices(self, jointGroupIndex):
|
|
return _py3dna.BehaviorReader_getJointGroupOutputIndices(self, jointGroupIndex)
|
|
|
|
def getJointGroupValues(self, jointGroupIndex):
|
|
return _py3dna.BehaviorReader_getJointGroupValues(self, jointGroupIndex)
|
|
|
|
def getJointGroupJointIndices(self, jointGroupIndex):
|
|
return _py3dna.BehaviorReader_getJointGroupJointIndices(self, jointGroupIndex)
|
|
|
|
def getBlendShapeChannelLODs(self):
|
|
return _py3dna.BehaviorReader_getBlendShapeChannelLODs(self)
|
|
|
|
def getBlendShapeChannelInputIndices(self):
|
|
return _py3dna.BehaviorReader_getBlendShapeChannelInputIndices(self)
|
|
|
|
def getBlendShapeChannelOutputIndices(self):
|
|
return _py3dna.BehaviorReader_getBlendShapeChannelOutputIndices(self)
|
|
|
|
def getAnimatedMapLODs(self):
|
|
return _py3dna.BehaviorReader_getAnimatedMapLODs(self)
|
|
|
|
def getAnimatedMapInputIndices(self):
|
|
return _py3dna.BehaviorReader_getAnimatedMapInputIndices(self)
|
|
|
|
def getAnimatedMapOutputIndices(self):
|
|
return _py3dna.BehaviorReader_getAnimatedMapOutputIndices(self)
|
|
|
|
def getAnimatedMapFromValues(self):
|
|
return _py3dna.BehaviorReader_getAnimatedMapFromValues(self)
|
|
|
|
def getAnimatedMapToValues(self):
|
|
return _py3dna.BehaviorReader_getAnimatedMapToValues(self)
|
|
|
|
def getAnimatedMapSlopeValues(self):
|
|
return _py3dna.BehaviorReader_getAnimatedMapSlopeValues(self)
|
|
|
|
def getAnimatedMapCutValues(self):
|
|
return _py3dna.BehaviorReader_getAnimatedMapCutValues(self)
|
|
|
|
# Register BehaviorReader in _py3dna:
|
|
_py3dna.BehaviorReader_swigregister(BehaviorReader)
|
|
|
|
class GeometryReader(DefinitionReader):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def getVertexPositionCount(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexPositionCount(self, meshIndex)
|
|
|
|
def getVertexPosition(self, meshIndex, vertexIndex):
|
|
return _py3dna.GeometryReader_getVertexPosition(self, meshIndex, vertexIndex)
|
|
|
|
def getVertexPositionXs(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexPositionXs(self, meshIndex)
|
|
|
|
def getVertexPositionYs(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexPositionYs(self, meshIndex)
|
|
|
|
def getVertexPositionZs(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexPositionZs(self, meshIndex)
|
|
|
|
def getVertexTextureCoordinateCount(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexTextureCoordinateCount(self, meshIndex)
|
|
|
|
def getVertexTextureCoordinate(self, meshIndex, textureCoordinateIndex):
|
|
return _py3dna.GeometryReader_getVertexTextureCoordinate(self, meshIndex, textureCoordinateIndex)
|
|
|
|
def getVertexTextureCoordinateUs(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexTextureCoordinateUs(self, meshIndex)
|
|
|
|
def getVertexTextureCoordinateVs(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexTextureCoordinateVs(self, meshIndex)
|
|
|
|
def getVertexNormalCount(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexNormalCount(self, meshIndex)
|
|
|
|
def getVertexNormal(self, meshIndex, normalIndex):
|
|
return _py3dna.GeometryReader_getVertexNormal(self, meshIndex, normalIndex)
|
|
|
|
def getVertexNormalXs(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexNormalXs(self, meshIndex)
|
|
|
|
def getVertexNormalYs(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexNormalYs(self, meshIndex)
|
|
|
|
def getVertexNormalZs(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexNormalZs(self, meshIndex)
|
|
|
|
def getVertexLayoutCount(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexLayoutCount(self, meshIndex)
|
|
|
|
def getVertexLayout(self, meshIndex, layoutIndex):
|
|
return _py3dna.GeometryReader_getVertexLayout(self, meshIndex, layoutIndex)
|
|
|
|
def getVertexLayoutPositionIndices(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexLayoutPositionIndices(self, meshIndex)
|
|
|
|
def getVertexLayoutTextureCoordinateIndices(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexLayoutTextureCoordinateIndices(self, meshIndex)
|
|
|
|
def getVertexLayoutNormalIndices(self, meshIndex):
|
|
return _py3dna.GeometryReader_getVertexLayoutNormalIndices(self, meshIndex)
|
|
|
|
def getFaceCount(self, meshIndex):
|
|
return _py3dna.GeometryReader_getFaceCount(self, meshIndex)
|
|
|
|
def getFaceVertexLayoutIndices(self, meshIndex, faceIndex):
|
|
return _py3dna.GeometryReader_getFaceVertexLayoutIndices(self, meshIndex, faceIndex)
|
|
|
|
def getMaximumInfluencePerVertex(self, meshIndex):
|
|
return _py3dna.GeometryReader_getMaximumInfluencePerVertex(self, meshIndex)
|
|
|
|
def getSkinWeightsCount(self, meshIndex):
|
|
return _py3dna.GeometryReader_getSkinWeightsCount(self, meshIndex)
|
|
|
|
def getSkinWeightsValues(self, meshIndex, vertexIndex):
|
|
return _py3dna.GeometryReader_getSkinWeightsValues(self, meshIndex, vertexIndex)
|
|
|
|
def getSkinWeightsJointIndices(self, meshIndex, vertexIndex):
|
|
return _py3dna.GeometryReader_getSkinWeightsJointIndices(self, meshIndex, vertexIndex)
|
|
|
|
def getBlendShapeTargetCount(self, meshIndex):
|
|
return _py3dna.GeometryReader_getBlendShapeTargetCount(self, meshIndex)
|
|
|
|
def getBlendShapeChannelIndex(self, meshIndex, blendShapeTargetIndex):
|
|
return _py3dna.GeometryReader_getBlendShapeChannelIndex(self, meshIndex, blendShapeTargetIndex)
|
|
|
|
def getBlendShapeTargetDeltaCount(self, meshIndex, blendShapeTargetIndex):
|
|
return _py3dna.GeometryReader_getBlendShapeTargetDeltaCount(self, meshIndex, blendShapeTargetIndex)
|
|
|
|
def getBlendShapeTargetDelta(self, meshIndex, blendShapeTargetIndex, deltaIndex):
|
|
return _py3dna.GeometryReader_getBlendShapeTargetDelta(self, meshIndex, blendShapeTargetIndex, deltaIndex)
|
|
|
|
def getBlendShapeTargetDeltaXs(self, meshIndex, blendShapeTargetIndex):
|
|
return _py3dna.GeometryReader_getBlendShapeTargetDeltaXs(self, meshIndex, blendShapeTargetIndex)
|
|
|
|
def getBlendShapeTargetDeltaYs(self, meshIndex, blendShapeTargetIndex):
|
|
return _py3dna.GeometryReader_getBlendShapeTargetDeltaYs(self, meshIndex, blendShapeTargetIndex)
|
|
|
|
def getBlendShapeTargetDeltaZs(self, meshIndex, blendShapeTargetIndex):
|
|
return _py3dna.GeometryReader_getBlendShapeTargetDeltaZs(self, meshIndex, blendShapeTargetIndex)
|
|
|
|
def getBlendShapeTargetVertexIndices(self, meshIndex, blendShapeTargetIndex):
|
|
return _py3dna.GeometryReader_getBlendShapeTargetVertexIndices(self, meshIndex, blendShapeTargetIndex)
|
|
|
|
# Register GeometryReader in _py3dna:
|
|
_py3dna.GeometryReader_swigregister(GeometryReader)
|
|
|
|
class Reader(BehaviorReader, GeometryReader):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _py3dna.delete_Reader
|
|
|
|
def unload(self, layer):
|
|
return _py3dna.Reader_unload(self, layer)
|
|
|
|
# Register Reader in _py3dna:
|
|
_py3dna.Reader_swigregister(Reader)
|
|
|
|
class StreamReader(Reader):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _py3dna.delete_StreamReader
|
|
|
|
def read(self):
|
|
return _py3dna.StreamReader_read(self)
|
|
|
|
# Register StreamReader in _py3dna:
|
|
_py3dna.StreamReader_swigregister(StreamReader)
|
|
StreamReader.SignatureMismatchError = _py3dna.cvar.StreamReader_SignatureMismatchError
|
|
StreamReader.VersionMismatchError = _py3dna.cvar.StreamReader_VersionMismatchError
|
|
StreamReader.InvalidDataError = _py3dna.cvar.StreamReader_InvalidDataError
|
|
|
|
class BinaryStreamReader(StreamReader):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def create(*args):
|
|
return _py3dna.BinaryStreamReader_create(*args)
|
|
|
|
@staticmethod
|
|
def destroy(instance):
|
|
return _py3dna.BinaryStreamReader_destroy(instance)
|
|
__swig_destroy__ = _py3dna.delete_BinaryStreamReader
|
|
|
|
# Register BinaryStreamReader in _py3dna:
|
|
_py3dna.BinaryStreamReader_swigregister(BinaryStreamReader)
|
|
|
|
def BinaryStreamReader_create(*args):
|
|
return _py3dna.BinaryStreamReader_create(*args)
|
|
|
|
def BinaryStreamReader_destroy(instance):
|
|
return _py3dna.BinaryStreamReader_destroy(instance)
|
|
|
|
class JSONStreamReader(StreamReader):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def create(stream, memRes=None):
|
|
return _py3dna.JSONStreamReader_create(stream, memRes)
|
|
|
|
@staticmethod
|
|
def destroy(instance):
|
|
return _py3dna.JSONStreamReader_destroy(instance)
|
|
__swig_destroy__ = _py3dna.delete_JSONStreamReader
|
|
|
|
# Register JSONStreamReader in _py3dna:
|
|
_py3dna.JSONStreamReader_swigregister(JSONStreamReader)
|
|
|
|
def JSONStreamReader_create(stream, memRes=None):
|
|
return _py3dna.JSONStreamReader_create(stream, memRes)
|
|
|
|
def JSONStreamReader_destroy(instance):
|
|
return _py3dna.JSONStreamReader_destroy(instance)
|
|
|
|
|
|
BinaryStreamReader.__new__ = __new_decorator(BinaryStreamReader_create, BinaryStreamReader.__new__)
|
|
BinaryStreamReader.__del__ = lambda instance: BinaryStreamReader_destroy(instance)
|
|
BinaryStreamReader.__init__ = __managed_init
|
|
del BinaryStreamReader.create
|
|
del BinaryStreamReader.destroy
|
|
|
|
|
|
JSONStreamReader.__new__ = __new_decorator(JSONStreamReader_create, JSONStreamReader.__new__)
|
|
JSONStreamReader.__del__ = lambda instance: JSONStreamReader_destroy(instance)
|
|
JSONStreamReader.__init__ = __managed_init
|
|
del JSONStreamReader.create
|
|
del JSONStreamReader.destroy
|
|
|
|
class DescriptorWriter(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def setName(self, name):
|
|
return _py3dna.DescriptorWriter_setName(self, name)
|
|
|
|
def setArchetype(self, archetype):
|
|
return _py3dna.DescriptorWriter_setArchetype(self, archetype)
|
|
|
|
def setGender(self, gender):
|
|
return _py3dna.DescriptorWriter_setGender(self, gender)
|
|
|
|
def setAge(self, age):
|
|
return _py3dna.DescriptorWriter_setAge(self, age)
|
|
|
|
def clearMetaData(self):
|
|
return _py3dna.DescriptorWriter_clearMetaData(self)
|
|
|
|
def setMetaData(self, key, value):
|
|
return _py3dna.DescriptorWriter_setMetaData(self, key, value)
|
|
|
|
def setTranslationUnit(self, unit):
|
|
return _py3dna.DescriptorWriter_setTranslationUnit(self, unit)
|
|
|
|
def setRotationUnit(self, unit):
|
|
return _py3dna.DescriptorWriter_setRotationUnit(self, unit)
|
|
|
|
def setCoordinateSystem(self, system):
|
|
return _py3dna.DescriptorWriter_setCoordinateSystem(self, system)
|
|
|
|
def setLODCount(self, lodCount):
|
|
return _py3dna.DescriptorWriter_setLODCount(self, lodCount)
|
|
|
|
def setDBMaxLOD(self, lod):
|
|
return _py3dna.DescriptorWriter_setDBMaxLOD(self, lod)
|
|
|
|
def setDBComplexity(self, name):
|
|
return _py3dna.DescriptorWriter_setDBComplexity(self, name)
|
|
|
|
def setDBName(self, name):
|
|
return _py3dna.DescriptorWriter_setDBName(self, name)
|
|
|
|
# Register DescriptorWriter in _py3dna:
|
|
_py3dna.DescriptorWriter_swigregister(DescriptorWriter)
|
|
|
|
class DefinitionWriter(DescriptorWriter):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def clearGUIControlNames(self):
|
|
return _py3dna.DefinitionWriter_clearGUIControlNames(self)
|
|
|
|
def setGUIControlName(self, index, name):
|
|
return _py3dna.DefinitionWriter_setGUIControlName(self, index, name)
|
|
|
|
def clearRawControlNames(self):
|
|
return _py3dna.DefinitionWriter_clearRawControlNames(self)
|
|
|
|
def setRawControlName(self, index, name):
|
|
return _py3dna.DefinitionWriter_setRawControlName(self, index, name)
|
|
|
|
def clearJointNames(self):
|
|
return _py3dna.DefinitionWriter_clearJointNames(self)
|
|
|
|
def setJointName(self, index, name):
|
|
return _py3dna.DefinitionWriter_setJointName(self, index, name)
|
|
|
|
def clearJointIndices(self):
|
|
return _py3dna.DefinitionWriter_clearJointIndices(self)
|
|
|
|
def setJointIndices(self, index, jointIndices):
|
|
return _py3dna.DefinitionWriter_setJointIndices(self, index, jointIndices)
|
|
|
|
def clearLODJointMappings(self):
|
|
return _py3dna.DefinitionWriter_clearLODJointMappings(self)
|
|
|
|
def setLODJointMapping(self, lod, index):
|
|
return _py3dna.DefinitionWriter_setLODJointMapping(self, lod, index)
|
|
|
|
def clearBlendShapeChannelNames(self):
|
|
return _py3dna.DefinitionWriter_clearBlendShapeChannelNames(self)
|
|
|
|
def setBlendShapeChannelName(self, index, name):
|
|
return _py3dna.DefinitionWriter_setBlendShapeChannelName(self, index, name)
|
|
|
|
def clearBlendShapeChannelIndices(self):
|
|
return _py3dna.DefinitionWriter_clearBlendShapeChannelIndices(self)
|
|
|
|
def setBlendShapeChannelIndices(self, index, blendShapeChannelIndices):
|
|
return _py3dna.DefinitionWriter_setBlendShapeChannelIndices(self, index, blendShapeChannelIndices)
|
|
|
|
def clearLODBlendShapeChannelMappings(self):
|
|
return _py3dna.DefinitionWriter_clearLODBlendShapeChannelMappings(self)
|
|
|
|
def setLODBlendShapeChannelMapping(self, lod, index):
|
|
return _py3dna.DefinitionWriter_setLODBlendShapeChannelMapping(self, lod, index)
|
|
|
|
def clearAnimatedMapNames(self):
|
|
return _py3dna.DefinitionWriter_clearAnimatedMapNames(self)
|
|
|
|
def setAnimatedMapName(self, index, name):
|
|
return _py3dna.DefinitionWriter_setAnimatedMapName(self, index, name)
|
|
|
|
def clearAnimatedMapIndices(self):
|
|
return _py3dna.DefinitionWriter_clearAnimatedMapIndices(self)
|
|
|
|
def setAnimatedMapIndices(self, index, animatedMapIndices):
|
|
return _py3dna.DefinitionWriter_setAnimatedMapIndices(self, index, animatedMapIndices)
|
|
|
|
def clearLODAnimatedMapMappings(self):
|
|
return _py3dna.DefinitionWriter_clearLODAnimatedMapMappings(self)
|
|
|
|
def setLODAnimatedMapMapping(self, lod, index):
|
|
return _py3dna.DefinitionWriter_setLODAnimatedMapMapping(self, lod, index)
|
|
|
|
def clearMeshNames(self):
|
|
return _py3dna.DefinitionWriter_clearMeshNames(self)
|
|
|
|
def setMeshName(self, index, name):
|
|
return _py3dna.DefinitionWriter_setMeshName(self, index, name)
|
|
|
|
def clearMeshIndices(self):
|
|
return _py3dna.DefinitionWriter_clearMeshIndices(self)
|
|
|
|
def setMeshIndices(self, index, meshIndices):
|
|
return _py3dna.DefinitionWriter_setMeshIndices(self, index, meshIndices)
|
|
|
|
def clearLODMeshMappings(self):
|
|
return _py3dna.DefinitionWriter_clearLODMeshMappings(self)
|
|
|
|
def setLODMeshMapping(self, lod, index):
|
|
return _py3dna.DefinitionWriter_setLODMeshMapping(self, lod, index)
|
|
|
|
def clearMeshBlendShapeChannelMappings(self):
|
|
return _py3dna.DefinitionWriter_clearMeshBlendShapeChannelMappings(self)
|
|
|
|
def setMeshBlendShapeChannelMapping(self, index, meshIndex, blendShapeChannelIndex):
|
|
return _py3dna.DefinitionWriter_setMeshBlendShapeChannelMapping(self, index, meshIndex, blendShapeChannelIndex)
|
|
|
|
def setJointHierarchy(self, jointIndices):
|
|
return _py3dna.DefinitionWriter_setJointHierarchy(self, jointIndices)
|
|
|
|
def setNeutralJointTranslations(self, translations):
|
|
return _py3dna.DefinitionWriter_setNeutralJointTranslations(self, translations)
|
|
|
|
def setNeutralJointRotations(self, rotations):
|
|
return _py3dna.DefinitionWriter_setNeutralJointRotations(self, rotations)
|
|
|
|
# Register DefinitionWriter in _py3dna:
|
|
_py3dna.DefinitionWriter_swigregister(DefinitionWriter)
|
|
|
|
class BehaviorWriter(DefinitionWriter):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def setGUIToRawInputIndices(self, inputIndices):
|
|
return _py3dna.BehaviorWriter_setGUIToRawInputIndices(self, inputIndices)
|
|
|
|
def setGUIToRawOutputIndices(self, outputIndices):
|
|
return _py3dna.BehaviorWriter_setGUIToRawOutputIndices(self, outputIndices)
|
|
|
|
def setGUIToRawFromValues(self, fromValues):
|
|
return _py3dna.BehaviorWriter_setGUIToRawFromValues(self, fromValues)
|
|
|
|
def setGUIToRawToValues(self, toValues):
|
|
return _py3dna.BehaviorWriter_setGUIToRawToValues(self, toValues)
|
|
|
|
def setGUIToRawSlopeValues(self, slopeValues):
|
|
return _py3dna.BehaviorWriter_setGUIToRawSlopeValues(self, slopeValues)
|
|
|
|
def setGUIToRawCutValues(self, cutValues):
|
|
return _py3dna.BehaviorWriter_setGUIToRawCutValues(self, cutValues)
|
|
|
|
def setPSDCount(self, count):
|
|
return _py3dna.BehaviorWriter_setPSDCount(self, count)
|
|
|
|
def setPSDRowIndices(self, rowIndices):
|
|
return _py3dna.BehaviorWriter_setPSDRowIndices(self, rowIndices)
|
|
|
|
def setPSDColumnIndices(self, columnIndices):
|
|
return _py3dna.BehaviorWriter_setPSDColumnIndices(self, columnIndices)
|
|
|
|
def setPSDValues(self, weights):
|
|
return _py3dna.BehaviorWriter_setPSDValues(self, weights)
|
|
|
|
def setJointRowCount(self, rowCount):
|
|
return _py3dna.BehaviorWriter_setJointRowCount(self, rowCount)
|
|
|
|
def setJointColumnCount(self, columnCount):
|
|
return _py3dna.BehaviorWriter_setJointColumnCount(self, columnCount)
|
|
|
|
def clearJointGroups(self):
|
|
return _py3dna.BehaviorWriter_clearJointGroups(self)
|
|
|
|
def deleteJointGroup(self, jointGroupIndex):
|
|
return _py3dna.BehaviorWriter_deleteJointGroup(self, jointGroupIndex)
|
|
|
|
def setJointGroupLODs(self, jointGroupIndex, lods):
|
|
return _py3dna.BehaviorWriter_setJointGroupLODs(self, jointGroupIndex, lods)
|
|
|
|
def setJointGroupInputIndices(self, jointGroupIndex, inputIndices):
|
|
return _py3dna.BehaviorWriter_setJointGroupInputIndices(self, jointGroupIndex, inputIndices)
|
|
|
|
def setJointGroupOutputIndices(self, jointGroupIndex, outputIndices):
|
|
return _py3dna.BehaviorWriter_setJointGroupOutputIndices(self, jointGroupIndex, outputIndices)
|
|
|
|
def setJointGroupValues(self, jointGroupIndex, values):
|
|
return _py3dna.BehaviorWriter_setJointGroupValues(self, jointGroupIndex, values)
|
|
|
|
def setJointGroupJointIndices(self, jointGroupIndex, jointIndices):
|
|
return _py3dna.BehaviorWriter_setJointGroupJointIndices(self, jointGroupIndex, jointIndices)
|
|
|
|
def setBlendShapeChannelLODs(self, lods):
|
|
return _py3dna.BehaviorWriter_setBlendShapeChannelLODs(self, lods)
|
|
|
|
def setBlendShapeChannelInputIndices(self, inputIndices):
|
|
return _py3dna.BehaviorWriter_setBlendShapeChannelInputIndices(self, inputIndices)
|
|
|
|
def setBlendShapeChannelOutputIndices(self, outputIndices):
|
|
return _py3dna.BehaviorWriter_setBlendShapeChannelOutputIndices(self, outputIndices)
|
|
|
|
def setAnimatedMapLODs(self, lods):
|
|
return _py3dna.BehaviorWriter_setAnimatedMapLODs(self, lods)
|
|
|
|
def setAnimatedMapInputIndices(self, inputIndices):
|
|
return _py3dna.BehaviorWriter_setAnimatedMapInputIndices(self, inputIndices)
|
|
|
|
def setAnimatedMapOutputIndices(self, outputIndices):
|
|
return _py3dna.BehaviorWriter_setAnimatedMapOutputIndices(self, outputIndices)
|
|
|
|
def setAnimatedMapFromValues(self, fromValues):
|
|
return _py3dna.BehaviorWriter_setAnimatedMapFromValues(self, fromValues)
|
|
|
|
def setAnimatedMapToValues(self, toValues):
|
|
return _py3dna.BehaviorWriter_setAnimatedMapToValues(self, toValues)
|
|
|
|
def setAnimatedMapSlopeValues(self, slopeValues):
|
|
return _py3dna.BehaviorWriter_setAnimatedMapSlopeValues(self, slopeValues)
|
|
|
|
def setAnimatedMapCutValues(self, cutValues):
|
|
return _py3dna.BehaviorWriter_setAnimatedMapCutValues(self, cutValues)
|
|
|
|
# Register BehaviorWriter in _py3dna:
|
|
_py3dna.BehaviorWriter_swigregister(BehaviorWriter)
|
|
|
|
class GeometryWriter(DefinitionWriter):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def clearMeshes(self):
|
|
return _py3dna.GeometryWriter_clearMeshes(self)
|
|
|
|
def deleteMesh(self, meshIndex):
|
|
return _py3dna.GeometryWriter_deleteMesh(self, meshIndex)
|
|
|
|
def setVertexPositions(self, meshIndex, positions):
|
|
return _py3dna.GeometryWriter_setVertexPositions(self, meshIndex, positions)
|
|
|
|
def setVertexTextureCoordinates(self, meshIndex, textureCoordinates):
|
|
return _py3dna.GeometryWriter_setVertexTextureCoordinates(self, meshIndex, textureCoordinates)
|
|
|
|
def setVertexNormals(self, meshIndex, normals):
|
|
return _py3dna.GeometryWriter_setVertexNormals(self, meshIndex, normals)
|
|
|
|
def setVertexLayouts(self, meshIndex, layouts):
|
|
return _py3dna.GeometryWriter_setVertexLayouts(self, meshIndex, layouts)
|
|
|
|
def clearFaceVertexLayoutIndices(self, meshIndex):
|
|
return _py3dna.GeometryWriter_clearFaceVertexLayoutIndices(self, meshIndex)
|
|
|
|
def setFaceVertexLayoutIndices(self, meshIndex, faceIndex, layoutIndices):
|
|
return _py3dna.GeometryWriter_setFaceVertexLayoutIndices(self, meshIndex, faceIndex, layoutIndices)
|
|
|
|
def setMaximumInfluencePerVertex(self, meshIndex, maxInfluenceCount):
|
|
return _py3dna.GeometryWriter_setMaximumInfluencePerVertex(self, meshIndex, maxInfluenceCount)
|
|
|
|
def clearSkinWeights(self, meshIndex):
|
|
return _py3dna.GeometryWriter_clearSkinWeights(self, meshIndex)
|
|
|
|
def setSkinWeightsValues(self, meshIndex, vertexIndex, weights):
|
|
return _py3dna.GeometryWriter_setSkinWeightsValues(self, meshIndex, vertexIndex, weights)
|
|
|
|
def setSkinWeightsJointIndices(self, meshIndex, vertexIndex, jointIndices):
|
|
return _py3dna.GeometryWriter_setSkinWeightsJointIndices(self, meshIndex, vertexIndex, jointIndices)
|
|
|
|
def clearBlendShapeTargets(self, meshIndex):
|
|
return _py3dna.GeometryWriter_clearBlendShapeTargets(self, meshIndex)
|
|
|
|
def setBlendShapeChannelIndex(self, meshIndex, blendShapeTargetIndex, blendShapeChannelIndex):
|
|
return _py3dna.GeometryWriter_setBlendShapeChannelIndex(self, meshIndex, blendShapeTargetIndex, blendShapeChannelIndex)
|
|
|
|
def setBlendShapeTargetDeltas(self, meshIndex, blendShapeTargetIndex, deltas):
|
|
return _py3dna.GeometryWriter_setBlendShapeTargetDeltas(self, meshIndex, blendShapeTargetIndex, deltas)
|
|
|
|
def setBlendShapeTargetVertexIndices(self, meshIndex, blendShapeTargetIndex, vertexIndices):
|
|
return _py3dna.GeometryWriter_setBlendShapeTargetVertexIndices(self, meshIndex, blendShapeTargetIndex, vertexIndices)
|
|
|
|
# Register GeometryWriter in _py3dna:
|
|
_py3dna.GeometryWriter_swigregister(GeometryWriter)
|
|
|
|
class Writer(BehaviorWriter, GeometryWriter):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _py3dna.delete_Writer
|
|
|
|
def setFrom(self, *args):
|
|
return _py3dna.Writer_setFrom(self, *args)
|
|
|
|
# Register Writer in _py3dna:
|
|
_py3dna.Writer_swigregister(Writer)
|
|
|
|
class StreamWriter(Writer):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _py3dna.delete_StreamWriter
|
|
|
|
def write(self):
|
|
return _py3dna.StreamWriter_write(self)
|
|
|
|
# Register StreamWriter in _py3dna:
|
|
_py3dna.StreamWriter_swigregister(StreamWriter)
|
|
|
|
class BinaryStreamWriter(StreamWriter):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def create(stream, memRes=None):
|
|
return _py3dna.BinaryStreamWriter_create(stream, memRes)
|
|
|
|
@staticmethod
|
|
def destroy(instance):
|
|
return _py3dna.BinaryStreamWriter_destroy(instance)
|
|
__swig_destroy__ = _py3dna.delete_BinaryStreamWriter
|
|
|
|
# Register BinaryStreamWriter in _py3dna:
|
|
_py3dna.BinaryStreamWriter_swigregister(BinaryStreamWriter)
|
|
|
|
def BinaryStreamWriter_create(stream, memRes=None):
|
|
return _py3dna.BinaryStreamWriter_create(stream, memRes)
|
|
|
|
def BinaryStreamWriter_destroy(instance):
|
|
return _py3dna.BinaryStreamWriter_destroy(instance)
|
|
|
|
class JSONStreamWriter(StreamWriter):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
@staticmethod
|
|
def create(stream, indentWidth=4, memRes=None):
|
|
return _py3dna.JSONStreamWriter_create(stream, indentWidth, memRes)
|
|
|
|
@staticmethod
|
|
def destroy(instance):
|
|
return _py3dna.JSONStreamWriter_destroy(instance)
|
|
__swig_destroy__ = _py3dna.delete_JSONStreamWriter
|
|
|
|
# Register JSONStreamWriter in _py3dna:
|
|
_py3dna.JSONStreamWriter_swigregister(JSONStreamWriter)
|
|
|
|
def JSONStreamWriter_create(stream, indentWidth=4, memRes=None):
|
|
return _py3dna.JSONStreamWriter_create(stream, indentWidth, memRes)
|
|
|
|
def JSONStreamWriter_destroy(instance):
|
|
return _py3dna.JSONStreamWriter_destroy(instance)
|
|
|
|
|
|
BinaryStreamWriter.__new__ = __new_decorator(BinaryStreamWriter_create, BinaryStreamWriter.__new__)
|
|
BinaryStreamWriter.__del__ = lambda instance: BinaryStreamWriter_destroy(instance)
|
|
BinaryStreamWriter.__init__ = __managed_init
|
|
del BinaryStreamWriter.create
|
|
del BinaryStreamWriter.destroy
|
|
|
|
|
|
JSONStreamWriter.__new__ = __new_decorator(JSONStreamWriter_create, JSONStreamWriter.__new__)
|
|
JSONStreamWriter.__del__ = lambda instance: JSONStreamWriter_destroy(instance)
|
|
JSONStreamWriter.__init__ = __managed_init
|
|
del JSONStreamWriter.create
|
|
del JSONStreamWriter.destroy
|
|
|
|
|
|
|