Skip to content

Instantly share code, notes, and snippets.

@ceremcem

ceremcem/coin.py

Created September 17, 2018 22:31
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save ceremcem/04f19e862230c342c2622bb1f5f6f04b to your computer and use it in GitHub Desktop.
Save ceremcem/04f19e862230c342c2622bb1f5f6f04b to your computer and use it in GitHub Desktop.
Download ZIP
coin.py according to #95
Raw
coin.py
This file has been truncated, but you can view the full file.
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
"""
Pivy is a Coin binding for Python. Coin is a high-level 3D graphics
library with a C++ Application Programming Interface. Coin uses
scene-graph data structures to render real-time graphics suitable for
mostly all kinds of scientific and engineering visualization
applications.
"""
from sys import version_info
if version_info >= (2, 6, 0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module('_coin', [dirname(__file__)])
except ImportError:
import _coin
return _coin
if fp is not None:
try:
_mod = imp.load_module('_coin', fp, pathname, description)
finally:
fp.close()
return _mod
_coin = swig_import_helper()
del swig_import_helper
else:
import _coin
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
if (name == "thisown"):
return self.this.own(value)
if (name == "this"):
if type(value).__name__ == 'SwigPyObject':
self.__dict__[name] = value
return
method = class_type.__swig_setmethods__.get(name, None)
if method:
return method(self, value)
if (not static):
object.__setattr__(self, name, value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
def _swig_setattr(self, class_type, name, value):
return _swig_setattr_nondynamic(self, class_type, name, value, 0)
def _swig_getattr_nondynamic(self, class_type, name, static=1):
if (name == "thisown"):
return self.this.own()
method = class_type.__swig_getmethods__.get(name, None)
if method:
return method(self)
if (not static):
return object.__getattr__(self, name)
else:
raise AttributeError(name)
def _swig_getattr(self, class_type, name):
return _swig_getattr_nondynamic(self, class_type, name, 0)
def _swig_repr(self):
try:
strthis = "proxy of " + self.this.__repr__()
except Exception:
strthis = ""
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object:
pass
_newclass = 0
def _swig_setattr_nondynamic_method(set):
def set_attr(self, name, value):
if (name == "thisown"):
return self.this.own(value)
if hasattr(self, name) or (name == "this"):
set(self, name, value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class charp(object):
"""Proxy of C++ charp class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(charp self) -> charp"""
this = _coin.new_charp()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_charp
__del__ = lambda self: None
def assign(self, value):
"""assign(charp self, char value)"""
return _coin.charp_assign(self, value)
def value(self):
"""value(charp self) -> char"""
return _coin.charp_value(self)
def cast(self):
"""cast(charp self) -> char *"""
return _coin.charp_cast(self)
def frompointer(t):
"""frompointer(char * t) -> charp"""
return _coin.charp_frompointer(t)
frompointer = staticmethod(frompointer)
charp_swigregister = _coin.charp_swigregister
charp_swigregister(charp)
cast = _coin.cast
def charp_frompointer(t):
"""charp_frompointer(char * t) -> charp"""
return _coin.charp_frompointer(t)
class intp(object):
"""Proxy of C++ intp class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(intp self) -> intp"""
this = _coin.new_intp()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_intp
__del__ = lambda self: None
def assign(self, value):
"""assign(intp self, int value)"""
return _coin.intp_assign(self, value)
def value(self):
"""value(intp self) -> int"""
return _coin.intp_value(self)
def cast(self):
"""cast(intp self) -> int *"""
return _coin.intp_cast(self)
def frompointer(t):
"""frompointer(int * t) -> intp"""
return _coin.intp_frompointer(t)
frompointer = staticmethod(frompointer)
intp_swigregister = _coin.intp_swigregister
intp_swigregister(intp)
def intp_frompointer(t):
"""intp_frompointer(int * t) -> intp"""
return _coin.intp_frompointer(t)
class longp(object):
"""Proxy of C++ longp class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(longp self) -> longp"""
this = _coin.new_longp()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_longp
__del__ = lambda self: None
def assign(self, value):
"""assign(longp self, long value)"""
return _coin.longp_assign(self, value)
def value(self):
"""value(longp self) -> long"""
return _coin.longp_value(self)
def cast(self):
"""cast(longp self) -> long *"""
return _coin.longp_cast(self)
def frompointer(t):
"""frompointer(long * t) -> longp"""
return _coin.longp_frompointer(t)
frompointer = staticmethod(frompointer)
longp_swigregister = _coin.longp_swigregister
longp_swigregister(longp)
def longp_frompointer(t):
"""longp_frompointer(long * t) -> longp"""
return _coin.longp_frompointer(t)
class floatp(object):
"""Proxy of C++ floatp class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(floatp self) -> floatp"""
this = _coin.new_floatp()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_floatp
__del__ = lambda self: None
def assign(self, value):
"""assign(floatp self, float value)"""
return _coin.floatp_assign(self, value)
def value(self):
"""value(floatp self) -> float"""
return _coin.floatp_value(self)
def cast(self):
"""cast(floatp self) -> float *"""
return _coin.floatp_cast(self)
def frompointer(t):
"""frompointer(float * t) -> floatp"""
return _coin.floatp_frompointer(t)
frompointer = staticmethod(frompointer)
floatp_swigregister = _coin.floatp_swigregister
floatp_swigregister(floatp)
def floatp_frompointer(t):
"""floatp_frompointer(float * t) -> floatp"""
return _coin.floatp_frompointer(t)
class doublep(object):
"""Proxy of C++ doublep class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(doublep self) -> doublep"""
this = _coin.new_doublep()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_doublep
__del__ = lambda self: None
def assign(self, value):
"""assign(doublep self, double value)"""
return _coin.doublep_assign(self, value)
def value(self):
"""value(doublep self) -> double"""
return _coin.doublep_value(self)
def cast(self):
"""cast(doublep self) -> double *"""
return _coin.doublep_cast(self)
def frompointer(t):
"""frompointer(double * t) -> doublep"""
return _coin.doublep_frompointer(t)
frompointer = staticmethod(frompointer)
doublep_swigregister = _coin.doublep_swigregister
doublep_swigregister(doublep)
def doublep_frompointer(t):
"""doublep_frompointer(double * t) -> doublep"""
return _coin.doublep_frompointer(t)
_coin.FALSE_swigconstant(_coin)
FALSE = _coin.FALSE
_coin.TRUE_swigconstant(_coin)
TRUE = _coin.TRUE
_coin.HAVE_INTTYPES_H_swigconstant(_coin)
HAVE_INTTYPES_H = _coin.HAVE_INTTYPES_H
_coin.HAVE_STDINT_H_swigconstant(_coin)
HAVE_STDINT_H = _coin.HAVE_STDINT_H
_coin.HAVE_SYS_TYPES_H_swigconstant(_coin)
HAVE_SYS_TYPES_H = _coin.HAVE_SYS_TYPES_H
_coin.HAVE_STDDEF_H_swigconstant(_coin)
HAVE_STDDEF_H = _coin.HAVE_STDDEF_H
_coin.HAVE_INT8_T_swigconstant(_coin)
HAVE_INT8_T = _coin.HAVE_INT8_T
_coin.HAVE_UINT8_T_swigconstant(_coin)
HAVE_UINT8_T = _coin.HAVE_UINT8_T
_coin.HAVE_INT16_T_swigconstant(_coin)
HAVE_INT16_T = _coin.HAVE_INT16_T
_coin.HAVE_UINT16_T_swigconstant(_coin)
HAVE_UINT16_T = _coin.HAVE_UINT16_T
_coin.HAVE_INT32_T_swigconstant(_coin)
HAVE_INT32_T = _coin.HAVE_INT32_T
_coin.HAVE_UINT32_T_swigconstant(_coin)
HAVE_UINT32_T = _coin.HAVE_UINT32_T
_coin.HAVE_INT64_T_swigconstant(_coin)
HAVE_INT64_T = _coin.HAVE_INT64_T
_coin.HAVE_UINT64_T_swigconstant(_coin)
HAVE_UINT64_T = _coin.HAVE_UINT64_T
_coin.HAVE_INTPTR_T_swigconstant(_coin)
HAVE_INTPTR_T = _coin.HAVE_INTPTR_T
_coin.HAVE_UINTPTR_T_swigconstant(_coin)
HAVE_UINTPTR_T = _coin.HAVE_UINTPTR_T
_coin.M_E_swigconstant(_coin)
M_E = _coin.M_E
_coin.M_LOG2E_swigconstant(_coin)
M_LOG2E = _coin.M_LOG2E
_coin.M_LOG10E_swigconstant(_coin)
M_LOG10E = _coin.M_LOG10E
_coin.M_LN2_swigconstant(_coin)
M_LN2 = _coin.M_LN2
_coin.M_LN10_swigconstant(_coin)
M_LN10 = _coin.M_LN10
_coin.M_PI_swigconstant(_coin)
M_PI = _coin.M_PI
_coin.M_TWOPI_swigconstant(_coin)
M_TWOPI = _coin.M_TWOPI
_coin.M_PI_2_swigconstant(_coin)
M_PI_2 = _coin.M_PI_2
_coin.M_PI_4_swigconstant(_coin)
M_PI_4 = _coin.M_PI_4
_coin.M_3PI_4_swigconstant(_coin)
M_3PI_4 = _coin.M_3PI_4
_coin.M_SQRTPI_swigconstant(_coin)
M_SQRTPI = _coin.M_SQRTPI
_coin.M_1_PI_swigconstant(_coin)
M_1_PI = _coin.M_1_PI
_coin.M_2_PI_swigconstant(_coin)
M_2_PI = _coin.M_2_PI
_coin.M_2_SQRTPI_swigconstant(_coin)
M_2_SQRTPI = _coin.M_2_SQRTPI
_coin.M_SQRT2_swigconstant(_coin)
M_SQRT2 = _coin.M_SQRT2
_coin.M_SQRT1_2_swigconstant(_coin)
M_SQRT1_2 = _coin.M_SQRT1_2
_coin.M_LN2LO_swigconstant(_coin)
M_LN2LO = _coin.M_LN2LO
_coin.M_LN2HI_swigconstant(_coin)
M_LN2HI = _coin.M_LN2HI
_coin.M_SQRT3_swigconstant(_coin)
M_SQRT3 = _coin.M_SQRT3
_coin.M_IVLN10_swigconstant(_coin)
M_IVLN10 = _coin.M_IVLN10
_coin.M_LOG2_E_swigconstant(_coin)
M_LOG2_E = _coin.M_LOG2_E
_coin.M_INVLN2_swigconstant(_coin)
M_INVLN2 = _coin.M_INVLN2
_coin.COIN_MAJOR_VERSION_swigconstant(_coin)
COIN_MAJOR_VERSION = _coin.COIN_MAJOR_VERSION
_coin.COIN_MINOR_VERSION_swigconstant(_coin)
COIN_MINOR_VERSION = _coin.COIN_MINOR_VERSION
_coin.COIN_MICRO_VERSION_swigconstant(_coin)
COIN_MICRO_VERSION = _coin.COIN_MICRO_VERSION
_coin.COIN_VERSION_swigconstant(_coin)
COIN_VERSION = _coin.COIN_VERSION
_coin.HAVE_HASH_QUOTING_swigconstant(_coin)
HAVE_HASH_QUOTING = _coin.HAVE_HASH_QUOTING
_coin.SUN_CC_4_0_SOTYPE_INIT_BUG_swigconstant(_coin)
SUN_CC_4_0_SOTYPE_INIT_BUG = _coin.SUN_CC_4_0_SOTYPE_INIT_BUG
class SbDict(object):
"""Proxy of C++ SbDict class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbDict self, int const entries=251) -> SbDict
__init__(SbDict self) -> SbDict
__init__(SbDict self, SbDict arg2) -> SbDict
"""
this = _coin.new_SbDict(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SbDict
__del__ = lambda self: None
def applyToAll(self, *args):
"""
applyToAll(SbDict self, SbDictApplyFunc * rtn)
applyToAll(SbDict self, SbDictApplyDataFunc * rtn, void * data)
"""
return _coin.SbDict_applyToAll(self, *args)
def clear(self):
"""clear(SbDict self)"""
return _coin.SbDict_clear(self)
def enter(self, key, value):
"""enter(SbDict self, SbDict::Key const key, void *const value) -> SbBool"""
return _coin.SbDict_enter(self, key, value)
def find(self, key, value):
"""find(SbDict self, SbDict::Key const key, void *& value) -> SbBool"""
return _coin.SbDict_find(self, key, value)
def makePList(self, keys, values):
"""makePList(SbDict self, SbPList keys, SbPList values)"""
return _coin.SbDict_makePList(self, keys, values)
def remove(self, key):
"""remove(SbDict self, SbDict::Key const key) -> SbBool"""
return _coin.SbDict_remove(self, key)
def setHashingFunction(self, func):
"""setHashingFunction(SbDict self, SbDictHashingFunc * func)"""
return _coin.SbDict_setHashingFunction(self, func)
SbDict_swigregister = _coin.SbDict_swigregister
SbDict_swigregister(SbDict)
class SoType(object):
"""Proxy of C++ SoType class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def fromName(name):
"""fromName(SbName name) -> SoType"""
return _coin.SoType_fromName(name)
fromName = staticmethod(fromName)
def getName(self):
"""getName(SoType self) -> SbName"""
return _coin.SoType_getName(self)
def getParent(self):
"""getParent(SoType self) -> SoType"""
return _coin.SoType_getParent(self)
def isDerivedFrom(self, type):
"""isDerivedFrom(SoType self, SoType type) -> SbBool"""
return _coin.SoType_isDerivedFrom(self, type)
def getAllDerivedFrom(type, list):
"""getAllDerivedFrom(SoType type, SoTypeList list) -> int"""
return _coin.SoType_getAllDerivedFrom(type, list)
getAllDerivedFrom = staticmethod(getAllDerivedFrom)
def canCreateInstance(self):
"""canCreateInstance(SoType self) -> SbBool"""
return _coin.SoType_canCreateInstance(self)
def getData(self):
"""getData(SoType self) -> uint16_t"""
return _coin.SoType_getData(self)
def getKey(self):
"""getKey(SoType self) -> int16_t"""
return _coin.SoType_getKey(self)
def __eq__(self, type):
"""__eq__(SoType self, SoType type) -> SbBool"""
return _coin.SoType___eq__(self, type)
def __ne__(self, type):
"""__ne__(SoType self, SoType type) -> SbBool"""
return _coin.SoType___ne__(self, type)
def __lt__(self, type):
"""__lt__(SoType self, SoType type) -> SbBool"""
return _coin.SoType___lt__(self, type)
def __le__(self, type):
"""__le__(SoType self, SoType type) -> SbBool"""
return _coin.SoType___le__(self, type)
def __ge__(self, type):
"""__ge__(SoType self, SoType type) -> SbBool"""
return _coin.SoType___ge__(self, type)
def __gt__(self, type):
"""__gt__(SoType self, SoType type) -> SbBool"""
return _coin.SoType___gt__(self, type)
def removeType(name):
"""removeType(SbName name) -> SbBool"""
return _coin.SoType_removeType(name)
removeType = staticmethod(removeType)
def init():
"""init()"""
return _coin.SoType_init()
init = staticmethod(init)
def fromKey(key):
"""fromKey(uint16_t key) -> SoType"""
return _coin.SoType_fromKey(key)
fromKey = staticmethod(fromKey)
def badType():
"""badType() -> SoType"""
return _coin.SoType_badType()
badType = staticmethod(badType)
def isBad(self):
"""isBad(SoType self) -> SbBool"""
return _coin.SoType_isBad(self)
def makeInternal(self):
"""makeInternal(SoType self)"""
return _coin.SoType_makeInternal(self)
def isInternal(self):
"""isInternal(SoType self) -> SbBool"""
return _coin.SoType_isInternal(self)
def getNumTypes():
"""getNumTypes() -> int"""
return _coin.SoType_getNumTypes()
getNumTypes = staticmethod(getNumTypes)
def getInstantiationMethod(self):
"""getInstantiationMethod(SoType self) -> SoType::instantiationMethod"""
return _coin.SoType_getInstantiationMethod(self)
def createInstance(self):
"""createInstance(SoType self) -> PyObject *"""
return _coin.SoType_createInstance(self)
def __init__(self):
"""__init__(SoType self) -> SoType"""
this = _coin.new_SoType()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoType
__del__ = lambda self: None
SoType_swigregister = _coin.SoType_swigregister
SoType_swigregister(SoType)
def SoType_fromName(name):
"""SoType_fromName(SbName name) -> SoType"""
return _coin.SoType_fromName(name)
def SoType_getAllDerivedFrom(type, list):
"""SoType_getAllDerivedFrom(SoType type, SoTypeList list) -> int"""
return _coin.SoType_getAllDerivedFrom(type, list)
def SoType_removeType(name):
"""SoType_removeType(SbName name) -> SbBool"""
return _coin.SoType_removeType(name)
def SoType_init():
"""SoType_init()"""
return _coin.SoType_init()
def SoType_fromKey(key):
"""SoType_fromKey(uint16_t key) -> SoType"""
return _coin.SoType_fromKey(key)
def SoType_badType():
"""SoType_badType() -> SoType"""
return _coin.SoType_badType()
def SoType_getNumTypes():
"""SoType_getNumTypes() -> int"""
return _coin.SoType_getNumTypes()
class SbPList(object):
"""Proxy of C++ SbPList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbPList self, int const sizehint) -> SbPList
__init__(SbPList self) -> SbPList
__init__(SbPList self, SbPList l) -> SbPList
"""
this = _coin.new_SbPList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SbPList
__del__ = lambda self: None
def copy(self, l):
"""copy(SbPList self, SbPList l)"""
return _coin.SbPList_copy(self, l)
def fit(self):
"""fit(SbPList self)"""
return _coin.SbPList_fit(self)
def append(self, item):
"""append(SbPList self, void * item)"""
return _coin.SbPList_append(self, item)
def find(self, item):
"""find(SbPList self, void * item) -> int"""
return _coin.SbPList_find(self, item)
def insert(self, item, insertbefore):
"""insert(SbPList self, void * item, int const insertbefore)"""
return _coin.SbPList_insert(self, item, insertbefore)
def removeItem(self, item):
"""removeItem(SbPList self, void * item)"""
return _coin.SbPList_removeItem(self, item)
def remove(self, index):
"""remove(SbPList self, int const index)"""
return _coin.SbPList_remove(self, index)
def removeFast(self, index):
"""removeFast(SbPList self, int const index)"""
return _coin.SbPList_removeFast(self, index)
def getLength(self):
"""getLength(SbPList self) -> int"""
return _coin.SbPList_getLength(self)
def truncate(self, length, fit=0):
"""
truncate(SbPList self, int const length, int const fit=0)
truncate(SbPList self, int const length)
"""
return _coin.SbPList_truncate(self, length, fit)
def getArrayPtr(self, start=0):
"""
getArrayPtr(SbPList self, int const start=0)
getArrayPtr(SbPList self) -> void **
"""
return _coin.SbPList_getArrayPtr(self, start)
def __eq__(self, l):
"""__eq__(SbPList self, SbPList l) -> int"""
return _coin.SbPList___eq__(self, l)
def __ne__(self, l):
"""__ne__(SbPList self, SbPList l) -> int"""
return _coin.SbPList___ne__(self, l)
def get(self, index):
"""get(SbPList self, int const index) -> void *"""
return _coin.SbPList_get(self, index)
def set(self, index, item):
"""set(SbPList self, int const index, void * item)"""
return _coin.SbPList_set(self, index, item)
def __getitem__(self, i):
"""__getitem__(SbPList self, int i) -> void *"""
return _coin.SbPList___getitem__(self, i)
def __setitem__(self, i, val):
"""__setitem__(SbPList self, int i, void * val)"""
return _coin.SbPList___setitem__(self, i, val)
def __iter__(self):
for i in range(self.getLength()):
yield self[i]
SbPList_swigregister = _coin.SbPList_swigregister
SbPList_swigregister(SbPList)
class SbIntList(SbPList):
"""Proxy of C++ SbIntList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbIntList self) -> SbIntList
__init__(SbIntList self, int const sizehint) -> SbIntList
"""
this = _coin.new_SbIntList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def append(self, item):
"""append(SbIntList self, int const item)"""
return _coin.SbIntList_append(self, item)
def find(self, item):
"""find(SbIntList self, int const item) -> int"""
return _coin.SbIntList_find(self, item)
def insert(self, item, addbefore):
"""insert(SbIntList self, int const item, int const addbefore)"""
return _coin.SbIntList_insert(self, item, addbefore)
def __setitem__(self, i, value):
"""__setitem__(SbIntList self, int const i, int * value)"""
return _coin.SbIntList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SbIntList self, int const i) -> int &"""
return _coin.SbIntList___getitem__(self, i)
def get(self, i):
"""get(SbIntList self, int const i) -> int"""
return _coin.SbIntList_get(self, i)
__swig_destroy__ = _coin.delete_SbIntList
__del__ = lambda self: None
SbIntList_swigregister = _coin.SbIntList_swigregister
SbIntList_swigregister(SbIntList)
class SbString(object):
"""Proxy of C++ SbString class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args):
"""
__init__(SbString self) -> SbString
__init__(SbString self, char const * s) -> SbString
__init__(SbString self, char const * s, int start, int end) -> SbString
__init__(SbString self, SbString s) -> SbString
__init__(SbString self, int const digits) -> SbString
"""
this = _coin.new_SbString(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SbString
__del__ = lambda self: None
def hash(*args):
"""
hash() -> uint32_t
hash(char const * s) -> uint32_t
"""
return _coin.SbString_hash(*args)
hash = staticmethod(hash)
def getLength(self):
"""getLength(SbString self) -> int"""
return _coin.SbString_getLength(self)
def makeEmpty(self, freeold=1):
"""
makeEmpty(SbString self, SbBool freeold=1)
makeEmpty(SbString self)
"""
return _coin.SbString_makeEmpty(self, freeold)
def getString(self):
"""getString(SbString self) -> char const *"""
return _coin.SbString_getString(self)
def getSubString(self, startidx, endidx=-1):
"""
getSubString(SbString self, int startidx, int endidx=-1) -> SbString
getSubString(SbString self, int startidx) -> SbString
"""
return _coin.SbString_getSubString(self, startidx, endidx)
def deleteSubString(self, startidx, endidx=-1):
"""
deleteSubString(SbString self, int startidx, int endidx=-1)
deleteSubString(SbString self, int startidx)
"""
return _coin.SbString_deleteSubString(self, startidx, endidx)
def addIntString(self, value):
"""addIntString(SbString self, int const value)"""
return _coin.SbString_addIntString(self, value)
def __iadd__(self, *args):
"""
__iadd__(SbString self, char const * s) -> SbString
__iadd__(SbString self, SbString s) -> SbString
__iadd__(SbString self, char const c) -> SbString
"""
return _coin.SbString___iadd__(self, *args)
def compareSubString(self, text, offset=0):
"""
compareSubString(SbString self, char const * text, int offset=0) -> int
compareSubString(SbString self, char const * text) -> int
"""
return _coin.SbString_compareSubString(self, text, offset)
def sprintf(self, formatstr):
"""sprintf(SbString self, char const * formatstr) -> SbString"""
return _coin.SbString_sprintf(self, formatstr)
def apply(self, func):
"""apply(SbString self, char (*)(char) func)"""
return _coin.SbString_apply(self, func)
def find(self, s):
"""find(SbString self, SbString s) -> int"""
return _coin.SbString_find(self, s)
def findAll(self, s, found):
"""findAll(SbString self, SbString s, SbIntList found) -> SbBool"""
return _coin.SbString_findAll(self, s, found)
def lower(self):
"""lower(SbString self) -> SbString"""
return _coin.SbString_lower(self)
def upper(self):
"""upper(SbString self) -> SbString"""
return _coin.SbString_upper(self)
def _print(self, fp):
"""_print(SbString self, std::FILE * fp)"""
return _coin.SbString__print(self, fp)
def __eq__(self, *args):
"""
__eq__(SbString self, SbString u) -> int
__eq__(SbString self, char * u) -> int
"""
return _coin.SbString___eq__(self, *args)
def __nq__(self, *args):
"""
__nq__(SbString self, SbString u) -> int
__nq__(SbString self, char * u) -> int
"""
return _coin.SbString___nq__(self, *args)
def __getitem__(self, i):
"""__getitem__(SbString self, int i) -> char"""
return _coin.SbString___getitem__(self, i)
def __iter__(self):
return getString().__iter__()
def __repr__(self):
"""__repr__(SbString self) -> char const *"""
return _coin.SbString___repr__(self)
SbString_swigregister = _coin.SbString_swigregister
SbString_swigregister(SbString)
def SbString_hash(*args):
"""
hash() -> uint32_t
SbString_hash(char const * s) -> uint32_t
"""
return _coin.SbString_hash(*args)
class SbName(object):
"""Proxy of C++ SbName class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args):
"""
__init__(SbName self) -> SbName
__init__(SbName self, char const * namestring) -> SbName
__init__(SbName self, SbString str) -> SbName
__init__(SbName self, SbName name) -> SbName
"""
this = _coin.new_SbName(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SbName
__del__ = lambda self: None
def getString(self):
"""getString(SbName self) -> char const *"""
return _coin.SbName_getString(self)
def getLength(self):
"""getLength(SbName self) -> int"""
return _coin.SbName_getLength(self)
def isIdentStartChar(c):
"""isIdentStartChar(char const c) -> SbBool"""
return _coin.SbName_isIdentStartChar(c)
isIdentStartChar = staticmethod(isIdentStartChar)
def isIdentChar(c):
"""isIdentChar(char const c) -> SbBool"""
return _coin.SbName_isIdentChar(c)
isIdentChar = staticmethod(isIdentChar)
def isBaseNameStartChar(c):
"""isBaseNameStartChar(char const c) -> SbBool"""
return _coin.SbName_isBaseNameStartChar(c)
isBaseNameStartChar = staticmethod(isBaseNameStartChar)
def isBaseNameChar(c):
"""isBaseNameChar(char const c) -> SbBool"""
return _coin.SbName_isBaseNameChar(c)
isBaseNameChar = staticmethod(isBaseNameChar)
def empty():
"""empty() -> SbName"""
return _coin.SbName_empty()
empty = staticmethod(empty)
def __eq__(self, *args):
"""
__eq__(SbName self, SbName u) -> int
__eq__(SbName self, char * u) -> int
__eq__(SbName self, SbString u) -> int
"""
return _coin.SbName___eq__(self, *args)
def __nq__(self, *args):
"""
__nq__(SbName self, SbName u) -> int
__nq__(SbName self, char * u) -> int
__nq__(SbName self, SbString u) -> int
"""
return _coin.SbName___nq__(self, *args)
def __getitem__(self, i):
"""__getitem__(SbName self, int i) -> char"""
return _coin.SbName___getitem__(self, i)
def __iter__(self):
return getString().__iter__()
def __repr__(self):
"""__repr__(SbName self) -> char const *"""
return _coin.SbName___repr__(self)
SbName_swigregister = _coin.SbName_swigregister
SbName_swigregister(SbName)
def SbName_isIdentStartChar(c):
"""SbName_isIdentStartChar(char const c) -> SbBool"""
return _coin.SbName_isIdentStartChar(c)
def SbName_isIdentChar(c):
"""SbName_isIdentChar(char const c) -> SbBool"""
return _coin.SbName_isIdentChar(c)
def SbName_isBaseNameStartChar(c):
"""SbName_isBaseNameStartChar(char const c) -> SbBool"""
return _coin.SbName_isBaseNameStartChar(c)
def SbName_isBaseNameChar(c):
"""SbName_isBaseNameChar(char const c) -> SbBool"""
return _coin.SbName_isBaseNameChar(c)
def SbName_empty():
"""SbName_empty() -> SbName"""
return _coin.SbName_empty()
class SoError(object):
"""Proxy of C++ SoError class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoError self) -> SoError"""
this = _coin.new_SoError()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoError
__del__ = lambda self: None
def setHandlerCallback(func, data):
"""setHandlerCallback(SoErrorCB *const func, void *const data)"""
return _coin.SoError_setHandlerCallback(func, data)
setHandlerCallback = staticmethod(setHandlerCallback)
def getHandlerCallback():
"""getHandlerCallback() -> SoErrorCB *"""
return _coin.SoError_getHandlerCallback()
getHandlerCallback = staticmethod(getHandlerCallback)
def getHandlerData():
"""getHandlerData() -> void *"""
return _coin.SoError_getHandlerData()
getHandlerData = staticmethod(getHandlerData)
def getDebugString(self):
"""getDebugString(SoError self) -> SbString"""
return _coin.SoError_getDebugString(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoError_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoError self) -> SoType"""
return _coin.SoError_getTypeId(self)
def isOfType(self, type):
"""isOfType(SoError self, SoType type) -> SbBool"""
return _coin.SoError_isOfType(self, type)
def post(format):
"""post(char const *const format)"""
return _coin.SoError_post(format)
post = staticmethod(post)
def getString(*args):
"""
getString(SoNode node) -> SbString
getString(SoPath path) -> SbString
getString(SoEngine engine) -> SbString
"""
return _coin.SoError_getString(*args)
getString = staticmethod(getString)
def initClass():
"""initClass()"""
return _coin.SoError_initClass()
initClass = staticmethod(initClass)
def initClasses():
"""initClasses()"""
return _coin.SoError_initClasses()
initClasses = staticmethod(initClasses)
SoError_swigregister = _coin.SoError_swigregister
SoError_swigregister(SoError)
def SoError_setHandlerCallback(func, data):
"""SoError_setHandlerCallback(SoErrorCB *const func, void *const data)"""
return _coin.SoError_setHandlerCallback(func, data)
def SoError_getHandlerCallback():
"""SoError_getHandlerCallback() -> SoErrorCB *"""
return _coin.SoError_getHandlerCallback()
def SoError_getHandlerData():
"""SoError_getHandlerData() -> void *"""
return _coin.SoError_getHandlerData()
def SoError_getClassTypeId():
"""SoError_getClassTypeId() -> SoType"""
return _coin.SoError_getClassTypeId()
def SoError_post(format):
"""SoError_post(char const *const format)"""
return _coin.SoError_post(format)
def SoError_getString(*args):
"""
getString(SoNode node) -> SbString
getString(SoPath path) -> SbString
SoError_getString(SoEngine engine) -> SbString
"""
return _coin.SoError_getString(*args)
def SoError_initClass():
"""SoError_initClass()"""
return _coin.SoError_initClass()
def SoError_initClasses():
"""SoError_initClasses()"""
return _coin.SoError_initClasses()
class SoDebugError(SoError):
"""Proxy of C++ SoDebugError class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
ERROR = _coin.SoDebugError_ERROR
WARNING = _coin.SoDebugError_WARNING
INFO = _coin.SoDebugError_INFO
def setHandlerCallback(function, data):
"""setHandlerCallback(SoErrorCB *const function, void *const data)"""
return _coin.SoDebugError_setHandlerCallback(function, data)
setHandlerCallback = staticmethod(setHandlerCallback)
def getHandlerCallback():
"""getHandlerCallback() -> SoErrorCB *"""
return _coin.SoDebugError_getHandlerCallback()
getHandlerCallback = staticmethod(getHandlerCallback)
def getHandlerData():
"""getHandlerData() -> void *"""
return _coin.SoDebugError_getHandlerData()
getHandlerData = staticmethod(getHandlerData)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoDebugError_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoDebugError self) -> SoType"""
return _coin.SoDebugError_getTypeId(self)
def getSeverity(self):
"""getSeverity(SoDebugError self) -> SoDebugError::Severity"""
return _coin.SoDebugError_getSeverity(self)
def post(source, format):
"""post(char const *const source, char const *const format)"""
return _coin.SoDebugError_post(source, format)
post = staticmethod(post)
def postWarning(source, format):
"""postWarning(char const *const source, char const *const format)"""
return _coin.SoDebugError_postWarning(source, format)
postWarning = staticmethod(postWarning)
def postInfo(source, format):
"""postInfo(char const *const source, char const *const format)"""
return _coin.SoDebugError_postInfo(source, format)
postInfo = staticmethod(postInfo)
def initClass():
"""initClass()"""
return _coin.SoDebugError_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoDebugError self) -> SoDebugError"""
this = _coin.new_SoDebugError()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoDebugError
__del__ = lambda self: None
SoDebugError_swigregister = _coin.SoDebugError_swigregister
SoDebugError_swigregister(SoDebugError)
def SoDebugError_setHandlerCallback(function, data):
"""SoDebugError_setHandlerCallback(SoErrorCB *const function, void *const data)"""
return _coin.SoDebugError_setHandlerCallback(function, data)
def SoDebugError_getHandlerCallback():
"""SoDebugError_getHandlerCallback() -> SoErrorCB *"""
return _coin.SoDebugError_getHandlerCallback()
def SoDebugError_getHandlerData():
"""SoDebugError_getHandlerData() -> void *"""
return _coin.SoDebugError_getHandlerData()
def SoDebugError_getClassTypeId():
"""SoDebugError_getClassTypeId() -> SoType"""
return _coin.SoDebugError_getClassTypeId()
def SoDebugError_post(source, format):
"""SoDebugError_post(char const *const source, char const *const format)"""
return _coin.SoDebugError_post(source, format)
def SoDebugError_postWarning(source, format):
"""SoDebugError_postWarning(char const *const source, char const *const format)"""
return _coin.SoDebugError_postWarning(source, format)
def SoDebugError_postInfo(source, format):
"""SoDebugError_postInfo(char const *const source, char const *const format)"""
return _coin.SoDebugError_postInfo(source, format)
def SoDebugError_initClass():
"""SoDebugError_initClass()"""
return _coin.SoDebugError_initClass()
class SbVec2s(object):
"""Proxy of C++ SbVec2s class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbVec2s self) -> SbVec2s
__init__(SbVec2s self, short const [2] v) -> SbVec2s
__init__(SbVec2s self, short x, short y) -> SbVec2s
__init__(SbVec2s self, SbVec2us const & v) -> SbVec2s
__init__(SbVec2s self, SbVec2b v) -> SbVec2s
__init__(SbVec2s self, SbVec2i32 v) -> SbVec2s
__init__(SbVec2s self, SbVec2f v) -> SbVec2s
__init__(SbVec2s self, SbVec2d v) -> SbVec2s
"""
this = _coin.new_SbVec2s(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def setValue(self, *args):
"""
setValue(SbVec2s self, short const [2] v) -> SbVec2s
setValue(SbVec2s self, short x, short y) -> SbVec2s
setValue(SbVec2s self, SbVec2us const & v) -> SbVec2s
setValue(SbVec2s self, SbVec2b v) -> SbVec2s
setValue(SbVec2s self, SbVec2i32 v) -> SbVec2s
setValue(SbVec2s self, SbVec2f v) -> SbVec2s
setValue(SbVec2s self, SbVec2d v) -> SbVec2s
"""
return _coin.SbVec2s_setValue(self, *args)
def getValue(self):
"""getValue(SbVec2s self)"""
return _coin.SbVec2s_getValue(self)
def dot(self, v):
"""dot(SbVec2s self, SbVec2s v) -> int32_t"""
return _coin.SbVec2s_dot(self, v)
def negate(self):
"""negate(SbVec2s self)"""
return _coin.SbVec2s_negate(self)
def __imul__(self, *args):
"""
__imul__(SbVec2s self, int d) -> SbVec2s
__imul__(SbVec2s self, double d) -> SbVec2s
"""
return _coin.SbVec2s___imul__(self, *args)
def __idiv__(self, *args):
"""
__idiv__(SbVec2s self, int d) -> SbVec2s
__idiv__(SbVec2s self, double d) -> SbVec2s
"""
return _coin.SbVec2s___idiv__(self, *args)
def __iadd__(self, v):
"""__iadd__(SbVec2s self, SbVec2s v) -> SbVec2s"""
return _coin.SbVec2s___iadd__(self, v)
def __isub__(self, v):
"""__isub__(SbVec2s self, SbVec2s v) -> SbVec2s"""
return _coin.SbVec2s___isub__(self, v)
def __neg__(self):
"""__neg__(SbVec2s self) -> SbVec2s"""
return _coin.SbVec2s___neg__(self)
def toString(self):
"""toString(SbVec2s self) -> SbString"""
return _coin.SbVec2s_toString(self)
def fromString(self, str):
"""fromString(SbVec2s self, SbString str) -> SbBool"""
return _coin.SbVec2s_fromString(self, str)
def output(self, fp):
"""output(SbVec2s self, FILE * fp)"""
return _coin.SbVec2s_output(self, fp)
def __add__(self, u):
"""__add__(SbVec2s self, SbVec2s u) -> SbVec2s"""
return _coin.SbVec2s___add__(self, u)
def __sub__(self, u):
"""__sub__(SbVec2s self, SbVec2s u) -> SbVec2s"""
return _coin.SbVec2s___sub__(self, u)
def __mul__(self, d):
"""__mul__(SbVec2s self, double const d) -> SbVec2s"""
return _coin.SbVec2s___mul__(self, d)
def __rmul__(self, d):
"""__rmul__(SbVec2s self, double const d) -> SbVec2s"""
return _coin.SbVec2s___rmul__(self, d)
def __div__(self, d):
"""__div__(SbVec2s self, double const d) -> SbVec2s"""
return _coin.SbVec2s___div__(self, d)
def __truediv__(self, d):
"""__truediv__(SbVec2s self, double const d) -> SbVec2s"""
return _coin.SbVec2s___truediv__(self, d)
def __eq__(self, u):
"""__eq__(SbVec2s self, SbVec2s u) -> int"""
return _coin.SbVec2s___eq__(self, u)
def __nq__(self, u):
"""__nq__(SbVec2s self, SbVec2s u) -> int"""
return _coin.SbVec2s___nq__(self, u)
def __getitem__(self, i):
"""__getitem__(SbVec2s self, int i) -> short"""
return _coin.SbVec2s___getitem__(self, i)
def __setitem__(self, i, value):
"""__setitem__(SbVec2s self, int i, short value)"""
return _coin.SbVec2s___setitem__(self, i, value)
def __iter__(self):
for i in range(2):
yield self[i]
def __len__(self):
return 2
__swig_destroy__ = _coin.delete_SbVec2s
__del__ = lambda self: None
SbVec2s_swigregister = _coin.SbVec2s_swigregister
SbVec2s_swigregister(SbVec2s)
class SbTime(object):
"""Proxy of C++ SbTime class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbTime self) -> SbTime
__init__(SbTime self, double const sec) -> SbTime
__init__(SbTime self, int32_t const sec, long const usec) -> SbTime
__init__(SbTime self, timeval const *const tv) -> SbTime
"""
this = _coin.new_SbTime(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def getTimeOfDay():
"""getTimeOfDay() -> SbTime"""
return _coin.SbTime_getTimeOfDay()
getTimeOfDay = staticmethod(getTimeOfDay)
def setToTimeOfDay(self):
"""setToTimeOfDay(SbTime self)"""
return _coin.SbTime_setToTimeOfDay(self)
def zero():
"""zero() -> SbTime"""
return _coin.SbTime_zero()
zero = staticmethod(zero)
def max():
"""max() -> SbTime"""
return _coin.SbTime_max()
max = staticmethod(max)
def maxTime():
"""maxTime() -> SbTime"""
return _coin.SbTime_maxTime()
maxTime = staticmethod(maxTime)
def sleep(msec):
"""sleep(int msec)"""
return _coin.SbTime_sleep(msec)
sleep = staticmethod(sleep)
def setValue(self, *args):
"""
setValue(SbTime self, double const sec)
setValue(SbTime self, int32_t const sec, long const usec)
setValue(SbTime self, timeval const *const tv)
"""
return _coin.SbTime_setValue(self, *args)
def setMsecValue(self, msec):
"""setMsecValue(SbTime self, unsigned long const msec)"""
return _coin.SbTime_setMsecValue(self, msec)
def getValue(self, *args):
"""
getValue(SbTime self) -> double
getValue(SbTime self, time_t & sec, long & usec)
getValue(SbTime self, timeval * tv)
"""
return _coin.SbTime_getValue(self, *args)
def getMsecValue(self):
"""getMsecValue(SbTime self) -> unsigned long"""
return _coin.SbTime_getMsecValue(self)
def format(self, *args):
"""
format(SbTime self, char const *const fmt) -> SbString
format(SbTime self) -> SbString
"""
return _coin.SbTime_format(self, *args)
def formatDate(self, fmt=None):
"""
formatDate(SbTime self, char const *const fmt=None) -> SbString
formatDate(SbTime self) -> SbString
"""
return _coin.SbTime_formatDate(self, fmt)
def parsedate(self, date):
"""parsedate(SbTime self, char const *const date) -> SbBool"""
return _coin.SbTime_parsedate(self, date)
def __iadd__(self, tm):
"""__iadd__(SbTime self, SbTime tm) -> SbTime"""
return _coin.SbTime___iadd__(self, tm)
def __isub__(self, tm):
"""__isub__(SbTime self, SbTime tm) -> SbTime"""
return _coin.SbTime___isub__(self, tm)
def __neg__(self):
"""__neg__(SbTime self) -> SbTime"""
return _coin.SbTime___neg__(self)
def __imul__(self, s):
"""__imul__(SbTime self, double const s) -> SbTime"""
return _coin.SbTime___imul__(self, s)
def __idiv__(self, s):
"""__idiv__(SbTime self, double const s) -> SbTime"""
return _coin.SbTime___idiv__(self, s)
def __mod__(self, tm):
"""__mod__(SbTime self, SbTime tm) -> SbTime"""
return _coin.SbTime___mod__(self, tm)
def __eq__(self, tm):
"""__eq__(SbTime self, SbTime tm) -> int"""
return _coin.SbTime___eq__(self, tm)
def __ne__(self, tm):
"""__ne__(SbTime self, SbTime tm) -> int"""
return _coin.SbTime___ne__(self, tm)
def __lt__(self, tm):
"""__lt__(SbTime self, SbTime tm) -> SbBool"""
return _coin.SbTime___lt__(self, tm)
def __gt__(self, tm):
"""__gt__(SbTime self, SbTime tm) -> SbBool"""
return _coin.SbTime___gt__(self, tm)
def __le__(self, tm):
"""__le__(SbTime self, SbTime tm) -> SbBool"""
return _coin.SbTime___le__(self, tm)
def __ge__(self, tm):
"""__ge__(SbTime self, SbTime tm) -> SbBool"""
return _coin.SbTime___ge__(self, tm)
def output(self, fp):
"""output(SbTime self, FILE * fp)"""
return _coin.SbTime_output(self, fp)
def __add__(self, u):
"""__add__(SbTime self, SbTime u) -> SbTime"""
return _coin.SbTime___add__(self, u)
def __sub__(self, u):
"""__sub__(SbTime self, SbTime u) -> SbTime"""
return _coin.SbTime___sub__(self, u)
def __mul__(self, d):
"""__mul__(SbTime self, double const d) -> SbTime"""
return _coin.SbTime___mul__(self, d)
def __rmul__(self, d):
"""__rmul__(SbTime self, double const d) -> SbTime"""
return _coin.SbTime___rmul__(self, d)
def __div__(self, *args):
"""
__div__(SbTime self, SbTime tm) -> double
__div__(SbTime self, double const d) -> SbTime
"""
return _coin.SbTime___div__(self, *args)
__swig_destroy__ = _coin.delete_SbTime
__del__ = lambda self: None
SbTime_swigregister = _coin.SbTime_swigregister
SbTime_swigregister(SbTime)
def SbTime_getTimeOfDay():
"""SbTime_getTimeOfDay() -> SbTime"""
return _coin.SbTime_getTimeOfDay()
def SbTime_zero():
"""SbTime_zero() -> SbTime"""
return _coin.SbTime_zero()
def SbTime_max():
"""SbTime_max() -> SbTime"""
return _coin.SbTime_max()
def SbTime_maxTime():
"""SbTime_maxTime() -> SbTime"""
return _coin.SbTime_maxTime()
def SbTime_sleep(msec):
"""SbTime_sleep(int msec)"""
return _coin.SbTime_sleep(msec)
class SoEvent(object):
"""Proxy of C++ SoEvent class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoEvent_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoEvent self) -> SoType"""
return _coin.SoEvent_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoEvent_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoEvent self) -> SoEvent"""
this = _coin.new_SoEvent()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoEvent
__del__ = lambda self: None
def isOfType(self, type):
"""isOfType(SoEvent self, SoType type) -> SbBool"""
return _coin.SoEvent_isOfType(self, type)
def setTime(self, t):
"""setTime(SoEvent self, SbTime t)"""
return _coin.SoEvent_setTime(self, t)
def getTime(self):
"""getTime(SoEvent self) -> SbTime"""
return _coin.SoEvent_getTime(self)
def setPosition(self, p):
"""setPosition(SoEvent self, SbVec2s p)"""
return _coin.SoEvent_setPosition(self, p)
def getPosition(self, *args):
"""
getPosition(SoEvent self) -> SbVec2s
getPosition(SoEvent self, SbViewportRegion vpRgn) -> SbVec2s
"""
return _coin.SoEvent_getPosition(self, *args)
def getNormalizedPosition(self, vpRgn):
"""getNormalizedPosition(SoEvent self, SbViewportRegion vpRgn) -> SbVec2f"""
return _coin.SoEvent_getNormalizedPosition(self, vpRgn)
def setShiftDown(self, isDown):
"""setShiftDown(SoEvent self, SbBool isDown)"""
return _coin.SoEvent_setShiftDown(self, isDown)
def wasShiftDown(self):
"""wasShiftDown(SoEvent self) -> SbBool"""
return _coin.SoEvent_wasShiftDown(self)
def setCtrlDown(self, isDown):
"""setCtrlDown(SoEvent self, SbBool isDown)"""
return _coin.SoEvent_setCtrlDown(self, isDown)
def wasCtrlDown(self):
"""wasCtrlDown(SoEvent self) -> SbBool"""
return _coin.SoEvent_wasCtrlDown(self)
def setAltDown(self, isDown):
"""setAltDown(SoEvent self, SbBool isDown)"""
return _coin.SoEvent_setAltDown(self, isDown)
def wasAltDown(self):
"""wasAltDown(SoEvent self) -> SbBool"""
return _coin.SoEvent_wasAltDown(self)
SoEvent_swigregister = _coin.SoEvent_swigregister
SoEvent_swigregister(SoEvent)
def SoEvent_getClassTypeId():
"""SoEvent_getClassTypeId() -> SoType"""
return _coin.SoEvent_getClassTypeId()
def SoEvent_initClass():
"""SoEvent_initClass()"""
return _coin.SoEvent_initClass()
class SoNotRec(object):
"""Proxy of C++ SoNotRec class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
CONTAINER = _coin.SoNotRec_CONTAINER
PARENT = _coin.SoNotRec_PARENT
SENSOR = _coin.SoNotRec_SENSOR
FIELD = _coin.SoNotRec_FIELD
ENGINE = _coin.SoNotRec_ENGINE
UNSPECIFIED = _coin.SoNotRec_UNSPECIFIED
FIELD_UPDATE = _coin.SoNotRec_FIELD_UPDATE
GROUP_ADDCHILD = _coin.SoNotRec_GROUP_ADDCHILD
GROUP_INSERTCHILD = _coin.SoNotRec_GROUP_INSERTCHILD
GROUP_REPLACECHILD = _coin.SoNotRec_GROUP_REPLACECHILD
GROUP_REMOVECHILD = _coin.SoNotRec_GROUP_REMOVECHILD
GROUP_REMOVEALLCHILDREN = _coin.SoNotRec_GROUP_REMOVEALLCHILDREN
def __init__(self, notifbase):
"""__init__(SoNotRec self, SoBase notifbase) -> SoNotRec"""
this = _coin.new_SoNotRec(notifbase)
try:
self.this.append(this)
except Exception:
self.this = this
def setType(self, type):
"""setType(SoNotRec self, SoNotRec::Type const type)"""
return _coin.SoNotRec_setType(self, type)
def getBase(self):
"""getBase(SoNotRec self) -> SoBase"""
return _coin.SoNotRec_getBase(self)
def getType(self):
"""getType(SoNotRec self) -> SoNotRec::Type"""
return _coin.SoNotRec_getType(self)
def getPrevious(self):
"""getPrevious(SoNotRec self) -> SoNotRec"""
return _coin.SoNotRec_getPrevious(self)
def setPrevious(self, prev):
"""setPrevious(SoNotRec self, SoNotRec prev)"""
return _coin.SoNotRec_setPrevious(self, prev)
def output(self, file):
"""output(SoNotRec self, FILE *const file)"""
return _coin.SoNotRec_output(self, file)
def getOperationType(self):
"""getOperationType(SoNotRec self) -> SoNotRec::OperationType"""
return _coin.SoNotRec_getOperationType(self)
def getIndex(self):
"""getIndex(SoNotRec self) -> int"""
return _coin.SoNotRec_getIndex(self)
def getFieldNumIndices(self):
"""getFieldNumIndices(SoNotRec self) -> int"""
return _coin.SoNotRec_getFieldNumIndices(self)
def getGroupChild(self):
"""getGroupChild(SoNotRec self) -> SoBase"""
return _coin.SoNotRec_getGroupChild(self)
def getGroupPrevChild(self):
"""getGroupPrevChild(SoNotRec self) -> SoBase"""
return _coin.SoNotRec_getGroupPrevChild(self)
def setOperationType(self, opType):
"""setOperationType(SoNotRec self, SoNotRec::OperationType const opType)"""
return _coin.SoNotRec_setOperationType(self, opType)
def setIndex(self, idx):
"""setIndex(SoNotRec self, int const idx)"""
return _coin.SoNotRec_setIndex(self, idx)
def setFieldNumIndices(self, fldnumind):
"""setFieldNumIndices(SoNotRec self, int const fldnumind)"""
return _coin.SoNotRec_setFieldNumIndices(self, fldnumind)
def setGroupChild(self, gc):
"""setGroupChild(SoNotRec self, SoBase gc)"""
return _coin.SoNotRec_setGroupChild(self, gc)
def setGroupPrevChild(self, pc):
"""setGroupPrevChild(SoNotRec self, SoBase pc)"""
return _coin.SoNotRec_setGroupPrevChild(self, pc)
__swig_destroy__ = _coin.delete_SoNotRec
__del__ = lambda self: None
SoNotRec_swigregister = _coin.SoNotRec_swigregister
SoNotRec_swigregister(SoNotRec)
class SoNotList(object):
"""Proxy of C++ SoNotList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoNotList self) -> SoNotList
__init__(SoNotList self, SoNotList nl) -> SoNotList
"""
this = _coin.new_SoNotList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def append(self, *args):
"""
append(SoNotList self, SoNotRec rec)
append(SoNotList self, SoNotRec rec, SoField field)
append(SoNotList self, SoNotRec rec, SoEngineOutput engineout)
"""
return _coin.SoNotList_append(self, *args)
def setLastType(self, type):
"""setLastType(SoNotList self, SoNotRec::Type const type)"""
return _coin.SoNotList_setLastType(self, type)
def getFirstRec(self):
"""getFirstRec(SoNotList self) -> SoNotRec"""
return _coin.SoNotList_getFirstRec(self)
def getLastRec(self):
"""getLastRec(SoNotList self) -> SoNotRec"""
return _coin.SoNotList_getLastRec(self)
def getFirstRecAtNode(self):
"""getFirstRecAtNode(SoNotList self) -> SoNotRec"""
return _coin.SoNotList_getFirstRecAtNode(self)
def getLastField(self):
"""getLastField(SoNotList self) -> SoField"""
return _coin.SoNotList_getLastField(self)
def getLastEngineOutput(self):
"""getLastEngineOutput(SoNotList self) -> SoEngineOutput"""
return _coin.SoNotList_getLastEngineOutput(self)
def getTimeStamp(self):
"""getTimeStamp(SoNotList self) -> uint32_t"""
return _coin.SoNotList_getTimeStamp(self)
def output(self, *args):
"""
output(SoNotList self, FILE *const file)
output(SoNotList self)
"""
return _coin.SoNotList_output(self, *args)
__swig_destroy__ = _coin.delete_SoNotList
__del__ = lambda self: None
SoNotList_swigregister = _coin.SoNotList_swigregister
SoNotList_swigregister(SoNotList)
class SoField(object):
"""Proxy of C++ SoField class."""
thisown = _swig_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__ = _coin.delete_SoField
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoField_initClass()
initClass = staticmethod(initClass)
def initClasses():
"""initClasses()"""
return _coin.SoField_initClasses()
initClasses = staticmethod(initClasses)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoField_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def setIgnored(self, ignore):
"""setIgnored(SoField self, SbBool ignore)"""
return _coin.SoField_setIgnored(self, ignore)
def isIgnored(self):
"""isIgnored(SoField self) -> SbBool"""
return _coin.SoField_isIgnored(self)
def setDefault(self, defaultVal):
"""setDefault(SoField self, SbBool defaultVal)"""
return _coin.SoField_setDefault(self, defaultVal)
def isDefault(self):
"""isDefault(SoField self) -> SbBool"""
return _coin.SoField_isDefault(self)
def getTypeId(self):
"""getTypeId(SoField self) -> SoType"""
return _coin.SoField_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoField_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def isOfType(self, type):
"""isOfType(SoField self, SoType type) -> SbBool"""
return _coin.SoField_isOfType(self, type)
def enableConnection(self, flag):
"""enableConnection(SoField self, SbBool flag)"""
return _coin.SoField_enableConnection(self, flag)
def isConnectionEnabled(self):
"""isConnectionEnabled(SoField self) -> SbBool"""
return _coin.SoField_isConnectionEnabled(self)
def isConnectedFromEngine(self):
"""isConnectedFromEngine(SoField self) -> SbBool"""
return _coin.SoField_isConnectedFromEngine(self)
def getConnectedEngine(self, master):
"""getConnectedEngine(SoField self, SoEngineOutput *& master) -> SbBool"""
return _coin.SoField_getConnectedEngine(self, master)
def connectFrom(self, *args):
"""
connectFrom(SoField self, SoEngineOutput master, SbBool notnotify=0, SbBool append=0) -> SbBool
connectFrom(SoField self, SoEngineOutput master, SbBool notnotify=0) -> SbBool
connectFrom(SoField self, SoEngineOutput master) -> SbBool
connectFrom(SoField self, SoField master, SbBool notnotify=0, SbBool append=0) -> SbBool
connectFrom(SoField self, SoField master, SbBool notnotify=0) -> SbBool
connectFrom(SoField self, SoField master) -> SbBool
"""
return _coin.SoField_connectFrom(self, *args)
def appendConnection(self, *args):
"""
appendConnection(SoField self, SoEngineOutput master, SbBool notnotify=0) -> SbBool
appendConnection(SoField self, SoEngineOutput master) -> SbBool
appendConnection(SoField self, SoField master, SbBool notnotify=0) -> SbBool
appendConnection(SoField self, SoField master) -> SbBool
"""
return _coin.SoField_appendConnection(self, *args)
def isConnectedFromField(self):
"""isConnectedFromField(SoField self) -> SbBool"""
return _coin.SoField_isConnectedFromField(self)
def getConnectedField(self, master):
"""getConnectedField(SoField self, SoField *& master) -> SbBool"""
return _coin.SoField_getConnectedField(self, master)
def getNumConnections(self):
"""getNumConnections(SoField self) -> int"""
return _coin.SoField_getNumConnections(self)
def getForwardConnections(self, slavelist):
"""getForwardConnections(SoField self, SoFieldList slavelist) -> int"""
return _coin.SoField_getForwardConnections(self, slavelist)
def getConnections(self, masterlist):
"""getConnections(SoField self, SoFieldList masterlist) -> int"""
return _coin.SoField_getConnections(self, masterlist)
def disconnect(self, *args):
"""
disconnect(SoField self, SoEngineOutput engineoutput)
disconnect(SoField self, SoField field)
disconnect(SoField self)
"""
return _coin.SoField_disconnect(self, *args)
def isConnected(self):
"""isConnected(SoField self) -> SbBool"""
return _coin.SoField_isConnected(self)
def setContainer(self, cont):
"""setContainer(SoField self, SoFieldContainer cont)"""
return _coin.SoField_setContainer(self, cont)
def getContainer(self):
"""getContainer(SoField self) -> SoFieldContainer"""
return _coin.SoField_getContainer(self)
def set(self, valuestring):
"""set(SoField self, char const * valuestring) -> SbBool"""
return _coin.SoField_set(self, valuestring)
def shouldWrite(self):
"""shouldWrite(SoField self) -> SbBool"""
return _coin.SoField_shouldWrite(self)
def touch(self):
"""touch(SoField self)"""
return _coin.SoField_touch(self)
def startNotify(self):
"""startNotify(SoField self)"""
return _coin.SoField_startNotify(self)
def notify(self, nlist):
"""notify(SoField self, SoNotList nlist)"""
return _coin.SoField_notify(self, nlist)
def enableNotify(self, on):
"""enableNotify(SoField self, SbBool on) -> SbBool"""
return _coin.SoField_enableNotify(self, on)
def isNotifyEnabled(self):
"""isNotifyEnabled(SoField self) -> SbBool"""
return _coin.SoField_isNotifyEnabled(self)
def addAuditor(self, f, type):
"""addAuditor(SoField self, void * f, SoNotRec::Type type)"""
return _coin.SoField_addAuditor(self, f, type)
def removeAuditor(self, f, type):
"""removeAuditor(SoField self, void * f, SoNotRec::Type type)"""
return _coin.SoField_removeAuditor(self, f, type)
def __eq__(self, f):
"""__eq__(SoField self, SoField f) -> int"""
return _coin.SoField___eq__(self, f)
def __ne__(self, f):
"""__ne__(SoField self, SoField f) -> int"""
return _coin.SoField___ne__(self, f)
def connectionStatusChanged(self, numconnections):
"""connectionStatusChanged(SoField self, int numconnections)"""
return _coin.SoField_connectionStatusChanged(self, numconnections)
def isReadOnly(self):
"""isReadOnly(SoField self) -> SbBool"""
return _coin.SoField_isReadOnly(self)
def isSame(self, f):
"""isSame(SoField self, SoField f) -> SbBool"""
return _coin.SoField_isSame(self, f)
def copyFrom(self, f):
"""copyFrom(SoField self, SoField f)"""
return _coin.SoField_copyFrom(self, f)
def fixCopy(self, copyconnections):
"""fixCopy(SoField self, SbBool copyconnections)"""
return _coin.SoField_fixCopy(self, copyconnections)
def referencesCopy(self):
"""referencesCopy(SoField self) -> SbBool"""
return _coin.SoField_referencesCopy(self)
def copyConnection(self, fromfield):
"""copyConnection(SoField self, SoField fromfield)"""
return _coin.SoField_copyConnection(self, fromfield)
def read(self, input, name):
"""read(SoField self, SoInput input, SbName name) -> SbBool"""
return _coin.SoField_read(self, input, name)
def write(self, out, name):
"""write(SoField self, SoOutput out, SbName name)"""
return _coin.SoField_write(self, out, name)
def countWriteRefs(self, out):
"""countWriteRefs(SoField self, SoOutput out)"""
return _coin.SoField_countWriteRefs(self, out)
NORMAL_FIELD = _coin.SoField_NORMAL_FIELD
EVENTIN_FIELD = _coin.SoField_EVENTIN_FIELD
EVENTOUT_FIELD = _coin.SoField_EVENTOUT_FIELD
EXPOSED_FIELD = _coin.SoField_EXPOSED_FIELD
def setFieldType(self, type):
"""setFieldType(SoField self, int type)"""
return _coin.SoField_setFieldType(self, type)
def getFieldType(self):
"""getFieldType(SoField self) -> int"""
return _coin.SoField_getFieldType(self)
def getDirty(self):
"""getDirty(SoField self) -> SbBool"""
return _coin.SoField_getDirty(self)
def setDirty(self, dirty):
"""setDirty(SoField self, SbBool dirty)"""
return _coin.SoField_setDirty(self, dirty)
def evaluate(self):
"""evaluate(SoField self)"""
return _coin.SoField_evaluate(self)
def get(self):
"""get(SoField self) -> SbString"""
return _coin.SoField_get(self)
@property
def values(self):
def _values(obj):
for value in obj:
if hasattr(value, "__iter__"):
yield list(_values(value))
else:
yield value
out = _values(self)
return list(out)
@values.setter
def values(self, arr):
self.deleteValues(0)
self.setValues(0, len(arr), arr)
SoField_swigregister = _coin.SoField_swigregister
SoField_swigregister(SoField)
def SoField_initClass():
"""SoField_initClass()"""
return _coin.SoField_initClass()
def SoField_initClasses():
"""SoField_initClasses()"""
return _coin.SoField_initClasses()
def SoField_cleanupClass():
"""SoField_cleanupClass()"""
return _coin.SoField_cleanupClass()
def SoField_getClassTypeId():
"""SoField_getClassTypeId() -> SoType"""
return _coin.SoField_getClassTypeId()
class SoSField(SoField):
"""Proxy of C++ SoSField class."""
thisown = _swig_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__ = _coin.delete_SoSField
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoSField_initClass()
initClass = staticmethod(initClass)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSField_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def atexit_cleanup():
"""atexit_cleanup()"""
return _coin.SoSField_atexit_cleanup()
atexit_cleanup = staticmethod(atexit_cleanup)
SoSField_swigregister = _coin.SoSField_swigregister
SoSField_swigregister(SoSField)
def SoSField_initClass():
"""SoSField_initClass()"""
return _coin.SoSField_initClass()
def SoSField_getClassTypeId():
"""SoSField_getClassTypeId() -> SoType"""
return _coin.SoSField_getClassTypeId()
def SoSField_atexit_cleanup():
"""SoSField_atexit_cleanup()"""
return _coin.SoSField_atexit_cleanup()
class SoMField(SoField):
"""Proxy of C++ SoMField class."""
thisown = _swig_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__ = _coin.delete_SoMField
__del__ = lambda self: None
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoMField_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def atexit_cleanup():
"""atexit_cleanup()"""
return _coin.SoMField_atexit_cleanup()
atexit_cleanup = staticmethod(atexit_cleanup)
def getNum(self):
"""getNum(SoMField self) -> int"""
return _coin.SoMField_getNum(self)
def setNum(self, num):
"""setNum(SoMField self, int const num)"""
return _coin.SoMField_setNum(self, num)
def deleteValues(self, start, num=-1):
"""
deleteValues(SoMField self, int start, int num=-1)
deleteValues(SoMField self, int start)
"""
return _coin.SoMField_deleteValues(self, start, num)
def insertSpace(self, start, num):
"""insertSpace(SoMField self, int start, int num)"""
return _coin.SoMField_insertSpace(self, start, num)
def set1(self, index, valuestring):
"""set1(SoMField self, int const index, char const *const valuestring) -> SbBool"""
return _coin.SoMField_set1(self, index, valuestring)
def initClass():
"""initClass()"""
return _coin.SoMField_initClass()
initClass = staticmethod(initClass)
def enableDeleteValues(self):
"""enableDeleteValues(SoMField self)"""
return _coin.SoMField_enableDeleteValues(self)
def isDeleteValuesEnabled(self):
"""isDeleteValuesEnabled(SoMField self) -> SbBool"""
return _coin.SoMField_isDeleteValuesEnabled(self)
def __iter__(self):
i = 0
while i < self.getNum():
yield self[i]
i += 1
def __len__(self):
"""__len__(SoMField self) -> int"""
return _coin.SoMField___len__(self)
def get1(self, index):
"""get1(SoMField self, int const index) -> SbString"""
return _coin.SoMField_get1(self, index)
SoMField_swigregister = _coin.SoMField_swigregister
SoMField_swigregister(SoMField)
def SoMField_getClassTypeId():
"""SoMField_getClassTypeId() -> SoType"""
return _coin.SoMField_getClassTypeId()
def SoMField_atexit_cleanup():
"""SoMField_atexit_cleanup()"""
return _coin.SoMField_atexit_cleanup()
def SoMField_initClass():
"""SoMField_initClass()"""
return _coin.SoMField_initClass()
class SoAuditorList(object):
"""Proxy of C++ SoAuditorList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoAuditorList self) -> SoAuditorList"""
this = _coin.new_SoAuditorList()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoAuditorList
__del__ = lambda self: None
def append(self, auditor, type):
"""append(SoAuditorList self, void *const auditor, SoNotRec::Type const type)"""
return _coin.SoAuditorList_append(self, auditor, type)
def set(self, index, auditor, type):
"""set(SoAuditorList self, int const index, void *const auditor, SoNotRec::Type const type)"""
return _coin.SoAuditorList_set(self, index, auditor, type)
def getObject(self, index):
"""getObject(SoAuditorList self, int const index) -> void *"""
return _coin.SoAuditorList_getObject(self, index)
def getType(self, index):
"""getType(SoAuditorList self, int const index) -> SoNotRec::Type"""
return _coin.SoAuditorList_getType(self, index)
def getLength(self):
"""getLength(SoAuditorList self) -> int"""
return _coin.SoAuditorList_getLength(self)
def find(self, auditor, type):
"""find(SoAuditorList self, void *const auditor, SoNotRec::Type const type) -> int"""
return _coin.SoAuditorList_find(self, auditor, type)
def remove(self, *args):
"""
remove(SoAuditorList self, int const index)
remove(SoAuditorList self, void *const auditor, SoNotRec::Type const type)
"""
return _coin.SoAuditorList_remove(self, *args)
def notify(self, l):
"""notify(SoAuditorList self, SoNotList l)"""
return _coin.SoAuditorList_notify(self, l)
SoAuditorList_swigregister = _coin.SoAuditorList_swigregister
SoAuditorList_swigregister(SoAuditorList)
class SoBase(object):
"""Proxy of C++ SoBase class."""
thisown = _swig_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 initClass():
"""initClass()"""
return _coin.SoBase_initClass()
initClass = staticmethod(initClass)
def ref(self):
"""ref(SoBase self)"""
return _coin.SoBase_ref(self)
def unref(self):
"""unref(SoBase self)"""
return _coin.SoBase_unref(self)
def unrefNoDelete(self):
"""unrefNoDelete(SoBase self)"""
return _coin.SoBase_unrefNoDelete(self)
def getRefCount(self):
"""getRefCount(SoBase self) -> int32_t"""
return _coin.SoBase_getRefCount(self)
def touch(self):
"""touch(SoBase self)"""
return _coin.SoBase_touch(self)
def getTypeId(self):
"""getTypeId(SoBase self) -> SoType"""
return _coin.SoBase_getTypeId(self)
def isOfType(self, type):
"""isOfType(SoBase self, SoType type) -> SbBool"""
return _coin.SoBase_isOfType(self, type)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoBase_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getName(self):
"""getName(SoBase self) -> SbName"""
return _coin.SoBase_getName(self)
def setName(self, newname):
"""setName(SoBase self, SbName newname)"""
return _coin.SoBase_setName(self, newname)
def addName(base, name):
"""addName(SoBase base, char const *const name)"""
return _coin.SoBase_addName(base, name)
addName = staticmethod(addName)
def removeName(base, name):
"""removeName(SoBase base, char const *const name)"""
return _coin.SoBase_removeName(base, name)
removeName = staticmethod(removeName)
def startNotify(self):
"""startNotify(SoBase self)"""
return _coin.SoBase_startNotify(self)
def notify(self, l):
"""notify(SoBase self, SoNotList l)"""
return _coin.SoBase_notify(self, l)
def addAuditor(self, auditor, type):
"""addAuditor(SoBase self, void *const auditor, SoNotRec::Type const type)"""
return _coin.SoBase_addAuditor(self, auditor, type)
def removeAuditor(self, auditor, type):
"""removeAuditor(SoBase self, void *const auditor, SoNotRec::Type const type)"""
return _coin.SoBase_removeAuditor(self, auditor, type)
def getAuditors(self):
"""getAuditors(SoBase self) -> SoAuditorList"""
return _coin.SoBase_getAuditors(self)
def addWriteReference(self, out, isfromfield=0):
"""
addWriteReference(SoBase self, SoOutput out, SbBool isfromfield=0)
addWriteReference(SoBase self, SoOutput out)
"""
return _coin.SoBase_addWriteReference(self, out, isfromfield)
def shouldWrite(self):
"""shouldWrite(SoBase self) -> SbBool"""
return _coin.SoBase_shouldWrite(self)
def incrementCurrentWriteCounter():
"""incrementCurrentWriteCounter()"""
return _coin.SoBase_incrementCurrentWriteCounter()
incrementCurrentWriteCounter = staticmethod(incrementCurrentWriteCounter)
def decrementCurrentWriteCounter():
"""decrementCurrentWriteCounter()"""
return _coin.SoBase_decrementCurrentWriteCounter()
decrementCurrentWriteCounter = staticmethod(decrementCurrentWriteCounter)
def getNamedBase(name, type):
"""getNamedBase(SbName name, SoType type) -> SoBase"""
return _coin.SoBase_getNamedBase(name, type)
getNamedBase = staticmethod(getNamedBase)
def getNamedBases(name, baselist, type):
"""getNamedBases(SbName name, SoBaseList baselist, SoType type) -> int"""
return _coin.SoBase_getNamedBases(name, baselist, type)
getNamedBases = staticmethod(getNamedBases)
def read(input, base, expectedtype):
"""read(SoInput input, SoBase *& base, SoType expectedtype) -> SbBool"""
return _coin.SoBase_read(input, base, expectedtype)
read = staticmethod(read)
def setInstancePrefix(c):
"""setInstancePrefix(SbString c)"""
return _coin.SoBase_setInstancePrefix(c)
setInstancePrefix = staticmethod(setInstancePrefix)
def setTraceRefs(trace):
"""setTraceRefs(SbBool trace)"""
return _coin.SoBase_setTraceRefs(trace)
setTraceRefs = staticmethod(setTraceRefs)
def getTraceRefs():
"""getTraceRefs() -> SbBool"""
return _coin.SoBase_getTraceRefs()
getTraceRefs = staticmethod(getTraceRefs)
def connectRoute(input, fromnodename, fromfieldname, tonodename, tofieldname):
"""connectRoute(SoInput input, SbName fromnodename, SbName fromfieldname, SbName tonodename, SbName tofieldname) -> SbBool"""
return _coin.SoBase_connectRoute(input, fromnodename, fromfieldname, tonodename, tofieldname)
connectRoute = staticmethod(connectRoute)
def assertAlive(self):
"""assertAlive(SoBase self)"""
return _coin.SoBase_assertAlive(self)
def readRoute(input):
"""readRoute(SoInput input) -> SbBool"""
return _coin.SoBase_readRoute(input)
readRoute = staticmethod(readRoute)
__swig_destroy__ = _coin.delete_SoBase
__del__ = lambda self: None
def __hash__(self):
"""__hash__(SoBase self) -> size_t"""
return _coin.SoBase___hash__(self)
def __eq__(self,other):
return (self.this == other.this) if other is not None else False
def __ne__(self,other):
return (self.this != other.this) if other is not None else True
def __nonzero__(self):
return True
SoBase_swigregister = _coin.SoBase_swigregister
SoBase_swigregister(SoBase)
def SoBase_initClass():
"""SoBase_initClass()"""
return _coin.SoBase_initClass()
def SoBase_getClassTypeId():
"""SoBase_getClassTypeId() -> SoType"""
return _coin.SoBase_getClassTypeId()
def SoBase_addName(base, name):
"""SoBase_addName(SoBase base, char const *const name)"""
return _coin.SoBase_addName(base, name)
def SoBase_removeName(base, name):
"""SoBase_removeName(SoBase base, char const *const name)"""
return _coin.SoBase_removeName(base, name)
def SoBase_incrementCurrentWriteCounter():
"""SoBase_incrementCurrentWriteCounter()"""
return _coin.SoBase_incrementCurrentWriteCounter()
def SoBase_decrementCurrentWriteCounter():
"""SoBase_decrementCurrentWriteCounter()"""
return _coin.SoBase_decrementCurrentWriteCounter()
def SoBase_getNamedBase(name, type):
"""SoBase_getNamedBase(SbName name, SoType type) -> SoBase"""
return _coin.SoBase_getNamedBase(name, type)
def SoBase_getNamedBases(name, baselist, type):
"""SoBase_getNamedBases(SbName name, SoBaseList baselist, SoType type) -> int"""
return _coin.SoBase_getNamedBases(name, baselist, type)
def SoBase_read(input, base, expectedtype):
"""SoBase_read(SoInput input, SoBase *& base, SoType expectedtype) -> SbBool"""
return _coin.SoBase_read(input, base, expectedtype)
def SoBase_setInstancePrefix(c):
"""SoBase_setInstancePrefix(SbString c)"""
return _coin.SoBase_setInstancePrefix(c)
def SoBase_setTraceRefs(trace):
"""SoBase_setTraceRefs(SbBool trace)"""
return _coin.SoBase_setTraceRefs(trace)
def SoBase_getTraceRefs():
"""SoBase_getTraceRefs() -> SbBool"""
return _coin.SoBase_getTraceRefs()
def SoBase_connectRoute(input, fromnodename, fromfieldname, tonodename, tofieldname):
"""SoBase_connectRoute(SoInput input, SbName fromnodename, SbName fromfieldname, SbName tonodename, SbName tofieldname) -> SbBool"""
return _coin.SoBase_connectRoute(input, fromnodename, fromfieldname, tonodename, tofieldname)
def SoBase_readRoute(input):
"""SoBase_readRoute(SoInput input) -> SbBool"""
return _coin.SoBase_readRoute(input)
def intrusive_ptr_add_ref(obj):
"""intrusive_ptr_add_ref(SoBase obj)"""
return _coin.intrusive_ptr_add_ref(obj)
def intrusive_ptr_release(obj):
"""intrusive_ptr_release(SoBase obj)"""
return _coin.intrusive_ptr_release(obj)
class SoBaseList(SbPList):
"""Proxy of C++ SoBaseList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoBaseList self) -> SoBaseList
__init__(SoBaseList self, int const size) -> SoBaseList
__init__(SoBaseList self, SoBaseList l) -> SoBaseList
"""
this = _coin.new_SoBaseList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoBaseList
__del__ = lambda self: None
def append(self, ptr):
"""append(SoBaseList self, SoBase ptr)"""
return _coin.SoBaseList_append(self, ptr)
def insert(self, ptr, addbefore):
"""insert(SoBaseList self, SoBase ptr, int const addbefore)"""
return _coin.SoBaseList_insert(self, ptr, addbefore)
def remove(self, index):
"""remove(SoBaseList self, int const index)"""
return _coin.SoBaseList_remove(self, index)
def removeItem(self, item):
"""removeItem(SoBaseList self, SoBase item)"""
return _coin.SoBaseList_removeItem(self, item)
def truncate(self, length):
"""truncate(SoBaseList self, int const length)"""
return _coin.SoBaseList_truncate(self, length)
def copy(self, l):
"""copy(SoBaseList self, SoBaseList l)"""
return _coin.SoBaseList_copy(self, l)
def set(self, i, ptr):
"""set(SoBaseList self, int const i, SoBase ptr)"""
return _coin.SoBaseList_set(self, i, ptr)
def addReferences(self, flag):
"""addReferences(SoBaseList self, SbBool const flag)"""
return _coin.SoBaseList_addReferences(self, flag)
def isReferencing(self):
"""isReferencing(SoBaseList self) -> SbBool"""
return _coin.SoBaseList_isReferencing(self)
def __setitem__(self, i, value):
"""__setitem__(SoBaseList self, int const i, SoBase value)"""
return _coin.SoBaseList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SoBaseList self, int const i) -> SoBase"""
return _coin.SoBaseList___getitem__(self, i)
def get(self, i):
"""get(SoBaseList self, int const i) -> SoBase"""
return _coin.SoBaseList_get(self, i)
SoBaseList_swigregister = _coin.SoBaseList_swigregister
SoBaseList_swigregister(SoBaseList)
class SoNodeList(SoBaseList):
"""Proxy of C++ SoNodeList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoNodeList self) -> SoNodeList
__init__(SoNodeList self, int const size) -> SoNodeList
__init__(SoNodeList self, SoNodeList nl) -> SoNodeList
"""
this = _coin.new_SoNodeList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoNodeList
__del__ = lambda self: None
def append(self, ptr):
"""append(SoNodeList self, SoNode ptr)"""
return _coin.SoNodeList_append(self, ptr)
def __setitem__(self, i, value):
"""__setitem__(SoNodeList self, int const i, SoNode value)"""
return _coin.SoNodeList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SoNodeList self, int const i) -> SoNode"""
return _coin.SoNodeList___getitem__(self, i)
def get(self, i):
"""get(SoNodeList self, int const i) -> SoNode"""
return _coin.SoNodeList_get(self, i)
SoNodeList_swigregister = _coin.SoNodeList_swigregister
SoNodeList_swigregister(SoNodeList)
class SoDetailList(SbPList):
"""Proxy of C++ SoDetailList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoDetailList self) -> SoDetailList
__init__(SoDetailList self, int const sizehint) -> SoDetailList
__init__(SoDetailList self, SoDetailList l) -> SoDetailList
"""
this = _coin.new_SoDetailList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoDetailList
__del__ = lambda self: None
def append(self, detail):
"""append(SoDetailList self, SoDetail detail)"""
return _coin.SoDetailList_append(self, detail)
def insert(self, detail, insertbefore):
"""insert(SoDetailList self, SoDetail detail, int const insertbefore)"""
return _coin.SoDetailList_insert(self, detail, insertbefore)
def truncate(self, length, fit=0):
"""
truncate(SoDetailList self, int const length, int const fit=0)
truncate(SoDetailList self, int const length)
"""
return _coin.SoDetailList_truncate(self, length, fit)
def copy(self, l):
"""copy(SoDetailList self, SoDetailList l)"""
return _coin.SoDetailList_copy(self, l)
def set(self, index, item):
"""set(SoDetailList self, int const index, SoDetail item)"""
return _coin.SoDetailList_set(self, index, item)
def __setitem__(self, i, value):
"""__setitem__(SoDetailList self, int const i, SoDetail value)"""
return _coin.SoDetailList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SoDetailList self, int const i) -> SoDetail"""
return _coin.SoDetailList___getitem__(self, i)
def get(self, i):
"""get(SoDetailList self, int const i) -> SoDetail"""
return _coin.SoDetailList_get(self, i)
SoDetailList_swigregister = _coin.SoDetailList_swigregister
SoDetailList_swigregister(SoDetailList)
class SoTypeList(SbPList):
"""Proxy of C++ SoTypeList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoTypeList self) -> SoTypeList
__init__(SoTypeList self, int const sizehint) -> SoTypeList
__init__(SoTypeList self, SoTypeList l) -> SoTypeList
"""
this = _coin.new_SoTypeList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def append(self, type):
"""append(SoTypeList self, SoType type)"""
return _coin.SoTypeList_append(self, type)
def find(self, type):
"""find(SoTypeList self, SoType type) -> int"""
return _coin.SoTypeList_find(self, type)
def insert(self, type, insertbefore):
"""insert(SoTypeList self, SoType type, int const insertbefore)"""
return _coin.SoTypeList_insert(self, type, insertbefore)
def set(self, index, item):
"""set(SoTypeList self, int const index, SoType item)"""
return _coin.SoTypeList_set(self, index, item)
def __setitem__(self, i, value):
"""__setitem__(SoTypeList self, int const i, SoType value)"""
return _coin.SoTypeList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SoTypeList self, int const i) -> SoType"""
return _coin.SoTypeList___getitem__(self, i)
def get(self, i):
"""get(SoTypeList self, int const i) -> SoType"""
return _coin.SoTypeList_get(self, i)
__swig_destroy__ = _coin.delete_SoTypeList
__del__ = lambda self: None
SoTypeList_swigregister = _coin.SoTypeList_swigregister
SoTypeList_swigregister(SoTypeList)
class SoEnabledElementsList(object):
"""Proxy of C++ SoEnabledElementsList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, parentlist):
"""__init__(SoEnabledElementsList self, SoEnabledElementsList parentlist) -> SoEnabledElementsList"""
this = _coin.new_SoEnabledElementsList(parentlist)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoEnabledElementsList
__del__ = lambda self: None
def getElements(self):
"""getElements(SoEnabledElementsList self) -> SoTypeList"""
return _coin.SoEnabledElementsList_getElements(self)
def enable(self, elementtype, stackindex):
"""enable(SoEnabledElementsList self, SoType elementtype, int const stackindex)"""
return _coin.SoEnabledElementsList_enable(self, elementtype, stackindex)
def merge(self, eel):
"""merge(SoEnabledElementsList self, SoEnabledElementsList eel)"""
return _coin.SoEnabledElementsList_merge(self, eel)
def getCounter():
"""getCounter() -> int"""
return _coin.SoEnabledElementsList_getCounter()
getCounter = staticmethod(getCounter)
SoEnabledElementsList_swigregister = _coin.SoEnabledElementsList_swigregister
SoEnabledElementsList_swigregister(SoEnabledElementsList)
def SoEnabledElementsList_getCounter():
"""SoEnabledElementsList_getCounter() -> int"""
return _coin.SoEnabledElementsList_getCounter()
class SoEngineOutputList(SbPList):
"""Proxy of C++ SoEngineOutputList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoEngineOutputList self) -> SoEngineOutputList
__init__(SoEngineOutputList self, int const sizehint) -> SoEngineOutputList
__init__(SoEngineOutputList self, SoEngineOutputList l) -> SoEngineOutputList
"""
this = _coin.new_SoEngineOutputList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def append(self, output):
"""append(SoEngineOutputList self, SoEngineOutput output)"""
return _coin.SoEngineOutputList_append(self, output)
def insert(self, output, insertbefore):
"""insert(SoEngineOutputList self, SoEngineOutput output, int const insertbefore)"""
return _coin.SoEngineOutputList_insert(self, output, insertbefore)
def set(self, idx, item):
"""set(SoEngineOutputList self, int const idx, SoEngineOutput item)"""
return _coin.SoEngineOutputList_set(self, idx, item)
def __setitem__(self, i, value):
"""__setitem__(SoEngineOutputList self, int const i, SoEngineOutput value)"""
return _coin.SoEngineOutputList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SoEngineOutputList self, int const i) -> SoEngineOutput"""
return _coin.SoEngineOutputList___getitem__(self, i)
def get(self, i):
"""get(SoEngineOutputList self, int const i) -> SoEngineOutput"""
return _coin.SoEngineOutputList_get(self, i)
__swig_destroy__ = _coin.delete_SoEngineOutputList
__del__ = lambda self: None
SoEngineOutputList_swigregister = _coin.SoEngineOutputList_swigregister
SoEngineOutputList_swigregister(SoEngineOutputList)
class SoEngineList(SoBaseList):
"""Proxy of C++ SoEngineList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoEngineList self) -> SoEngineList
__init__(SoEngineList self, int const size) -> SoEngineList
__init__(SoEngineList self, SoEngineList el) -> SoEngineList
"""
this = _coin.new_SoEngineList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoEngineList
__del__ = lambda self: None
def append(self, ptr):
"""append(SoEngineList self, SoEngine ptr)"""
return _coin.SoEngineList_append(self, ptr)
def __setitem__(self, i, value):
"""__setitem__(SoEngineList self, int const i, SoEngine value)"""
return _coin.SoEngineList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SoEngineList self, int const i) -> SoEngine"""
return _coin.SoEngineList___getitem__(self, i)
def get(self, i):
"""get(SoEngineList self, int const i) -> SoEngine"""
return _coin.SoEngineList_get(self, i)
SoEngineList_swigregister = _coin.SoEngineList_swigregister
SoEngineList_swigregister(SoEngineList)
class SoFieldList(SbPList):
"""Proxy of C++ SoFieldList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoFieldList self) -> SoFieldList
__init__(SoFieldList self, int const sizehint) -> SoFieldList
__init__(SoFieldList self, SoFieldList l) -> SoFieldList
"""
this = _coin.new_SoFieldList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def append(self, field):
"""append(SoFieldList self, SoField field)"""
return _coin.SoFieldList_append(self, field)
def insert(self, field, insertbefore):
"""insert(SoFieldList self, SoField field, int const insertbefore)"""
return _coin.SoFieldList_insert(self, field, insertbefore)
def set(self, idx, field):
"""set(SoFieldList self, int const idx, SoField field)"""
return _coin.SoFieldList_set(self, idx, field)
def __setitem__(self, i, value):
"""__setitem__(SoFieldList self, int const i, SoField value)"""
return _coin.SoFieldList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SoFieldList self, int const i) -> SoField"""
return _coin.SoFieldList___getitem__(self, i)
def get(self, *args):
"""
get(SoFieldList self, int const idx) -> SoField
get(SoFieldList self, int const i) -> SoField
"""
return _coin.SoFieldList_get(self, *args)
__swig_destroy__ = _coin.delete_SoFieldList
__del__ = lambda self: None
SoFieldList_swigregister = _coin.SoFieldList_swigregister
SoFieldList_swigregister(SoFieldList)
class SoPathList(SoBaseList):
"""Proxy of C++ SoPathList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoPathList self) -> SoPathList
__init__(SoPathList self, int const size) -> SoPathList
__init__(SoPathList self, SoPathList pl) -> SoPathList
"""
this = _coin.new_SoPathList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoPathList
__del__ = lambda self: None
def append(self, path):
"""append(SoPathList self, SoPath path)"""
return _coin.SoPathList_append(self, path)
def findPath(self, path):
"""findPath(SoPathList self, SoPath path) -> int"""
return _coin.SoPathList_findPath(self, path)
def sort(self):
"""sort(SoPathList self)"""
return _coin.SoPathList_sort(self)
def uniquify(self):
"""uniquify(SoPathList self)"""
return _coin.SoPathList_uniquify(self)
def __setitem__(self, i, value):
"""__setitem__(SoPathList self, int const i, SoPath value)"""
return _coin.SoPathList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SoPathList self, int i) -> SoPath"""
return _coin.SoPathList___getitem__(self, i)
def get(self, i):
"""get(SoPathList self, int const i) -> SoPath"""
return _coin.SoPathList_get(self, i)
SoPathList_swigregister = _coin.SoPathList_swigregister
SoPathList_swigregister(SoPathList)
class SoPickedPointList(SbPList):
"""Proxy of C++ SoPickedPointList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoPickedPointList self) -> SoPickedPointList
__init__(SoPickedPointList self, int const sizehint) -> SoPickedPointList
__init__(SoPickedPointList self, SoPickedPointList l) -> SoPickedPointList
"""
this = _coin.new_SoPickedPointList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoPickedPointList
__del__ = lambda self: None
def append(self, pp):
"""append(SoPickedPointList self, SoPickedPoint pp)"""
return _coin.SoPickedPointList_append(self, pp)
def insert(self, pp, insertbefore):
"""insert(SoPickedPointList self, SoPickedPoint pp, int const insertbefore)"""
return _coin.SoPickedPointList_insert(self, pp, insertbefore)
def truncate(self, start, fit=0):
"""
truncate(SoPickedPointList self, int const start, int const fit=0)
truncate(SoPickedPointList self, int const start)
"""
return _coin.SoPickedPointList_truncate(self, start, fit)
def set(self, idx, pp):
"""set(SoPickedPointList self, int const idx, SoPickedPoint pp)"""
return _coin.SoPickedPointList_set(self, idx, pp)
def __setitem__(self, i, value):
"""__setitem__(SoPickedPointList self, int const i, SoPickedPoint value)"""
return _coin.SoPickedPointList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SoPickedPointList self, int const i) -> SoPickedPoint"""
return _coin.SoPickedPointList___getitem__(self, i)
def get(self, i):
"""get(SoPickedPointList self, int const i) -> SoPickedPoint"""
return _coin.SoPickedPointList_get(self, i)
SoPickedPointList_swigregister = _coin.SoPickedPointList_swigregister
SoPickedPointList_swigregister(SoPickedPointList)
class SoPath(SoBase):
"""Proxy of C++ SoPath class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def initClass():
"""initClass()"""
return _coin.SoPath_initClass()
initClass = staticmethod(initClass)
def __init__(self, *args):
"""
__init__(SoPath self, int const approxlength=4) -> SoPath
__init__(SoPath self) -> SoPath
__init__(SoPath self, SoNode head) -> SoPath
__init__(SoPath self, SoPath rhs) -> SoPath
"""
this = _coin.new_SoPath(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoPath_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoPath self) -> SoType"""
return _coin.SoPath_getTypeId(self)
def setHead(self, head):
"""setHead(SoPath self, SoNode head)"""
return _coin.SoPath_setHead(self, head)
def getHead(self):
"""getHead(SoPath self) -> SoNode"""
return _coin.SoPath_getHead(self)
def append(self, *args):
"""
append(SoPath self, int const childindex)
append(SoPath self, SoNode node)
append(SoPath self, SoPath frompath)
"""
return _coin.SoPath_append(self, *args)
def push(self, childindex):
"""push(SoPath self, int const childindex)"""
return _coin.SoPath_push(self, childindex)
def pop(self):
"""pop(SoPath self)"""
return _coin.SoPath_pop(self)
def getTail(self):
"""getTail(SoPath self) -> SoNode"""
return _coin.SoPath_getTail(self)
def getNode(self, index):
"""getNode(SoPath self, int const index) -> SoNode"""
return _coin.SoPath_getNode(self, index)
def getNodeFromTail(self, index):
"""getNodeFromTail(SoPath self, int const index) -> SoNode"""
return _coin.SoPath_getNodeFromTail(self, index)
def getIndex(self, index):
"""getIndex(SoPath self, int const index) -> int"""
return _coin.SoPath_getIndex(self, index)
def getIndexFromTail(self, index):
"""getIndexFromTail(SoPath self, int const index) -> int"""
return _coin.SoPath_getIndexFromTail(self, index)
def getLength(self):
"""getLength(SoPath self) -> int"""
return _coin.SoPath_getLength(self)
def truncate(self, length):
"""truncate(SoPath self, int const length)"""
return _coin.SoPath_truncate(self, length)
def findFork(self, path):
"""findFork(SoPath self, SoPath path) -> int"""
return _coin.SoPath_findFork(self, path)
def findNode(self, node):
"""findNode(SoPath self, SoNode node) -> int"""
return _coin.SoPath_findNode(self, node)
def containsNode(self, node):
"""containsNode(SoPath self, SoNode node) -> SbBool"""
return _coin.SoPath_containsNode(self, node)
def containsPath(self, path):
"""containsPath(SoPath self, SoPath path) -> SbBool"""
return _coin.SoPath_containsPath(self, path)
def copy(self, startfromnodeindex=0, numnodes=0):
"""
copy(SoPath self, int const startfromnodeindex=0, int numnodes=0) -> SoPath
copy(SoPath self, int const startfromnodeindex=0) -> SoPath
copy(SoPath self) -> SoPath
"""
return _coin.SoPath_copy(self, startfromnodeindex, numnodes)
def getByName(*args):
"""
getByName(SbName name) -> SoPath
getByName(SbName name, SoPathList l) -> int
"""
return _coin.SoPath_getByName(*args)
getByName = staticmethod(getByName)
def insertIndex(self, parent, newindex):
"""insertIndex(SoPath self, SoNode parent, int const newindex)"""
return _coin.SoPath_insertIndex(self, parent, newindex)
def removeIndex(self, parent, oldindex):
"""removeIndex(SoPath self, SoNode parent, int const oldindex)"""
return _coin.SoPath_removeIndex(self, parent, oldindex)
def replaceIndex(self, parent, index, newchild):
"""replaceIndex(SoPath self, SoNode parent, int const index, SoNode newchild)"""
return _coin.SoPath_replaceIndex(self, parent, index, newchild)
def isRelevantNotification(self, l):
"""isRelevantNotification(SoPath self, SoNotList l) -> SbBool"""
return _coin.SoPath_isRelevantNotification(self, l)
def write(self, action):
"""write(SoPath self, SoWriteAction action)"""
return _coin.SoPath_write(self, action)
def __iter__(self):
for i in range(self.getLength()):
yield self.getNode(i)
def index(self):
for i in range(self.getLength()):
yield self.getIndex(i)
def __eq__(self, u):
"""__eq__(SoPath self, SoPath u) -> int"""
return _coin.SoPath___eq__(self, u)
def __nq__(self, u):
"""__nq__(SoPath self, SoPath u) -> int"""
return _coin.SoPath___nq__(self, u)
SoPath_swigregister = _coin.SoPath_swigregister
SoPath_swigregister(SoPath)
def SoPath_initClass():
"""SoPath_initClass()"""
return _coin.SoPath_initClass()
def SoPath_getClassTypeId():
"""SoPath_getClassTypeId() -> SoType"""
return _coin.SoPath_getClassTypeId()
def SoPath_getByName(*args):
"""
getByName(SbName name) -> SoPath
SoPath_getByName(SbName name, SoPathList l) -> int
"""
return _coin.SoPath_getByName(*args)
class SoLightPath(object):
"""Proxy of C++ SoLightPath class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoLightPath self, SoNode node, int const approxlength) -> SoLightPath
__init__(SoLightPath self, int const approxlength) -> SoLightPath
"""
this = _coin.new_SoLightPath(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoLightPath
__del__ = lambda self: None
def setHead(self, node):
"""setHead(SoLightPath self, SoNode node)"""
return _coin.SoLightPath_setHead(self, node)
def append(self, childindex):
"""append(SoLightPath self, int const childindex)"""
return _coin.SoLightPath_append(self, childindex)
def push(self, childindex):
"""push(SoLightPath self, int const childindex)"""
return _coin.SoLightPath_push(self, childindex)
def pop(self):
"""pop(SoLightPath self)"""
return _coin.SoLightPath_pop(self)
def setTail(self, childindex):
"""setTail(SoLightPath self, int const childindex)"""
return _coin.SoLightPath_setTail(self, childindex)
def getTail(self):
"""getTail(SoLightPath self) -> SoNode"""
return _coin.SoLightPath_getTail(self)
def getHead(self):
"""getHead(SoLightPath self) -> SoNode"""
return _coin.SoLightPath_getHead(self)
def getNode(self, index):
"""getNode(SoLightPath self, int const index) -> SoNode"""
return _coin.SoLightPath_getNode(self, index)
def getIndex(self, index):
"""getIndex(SoLightPath self, int const index) -> int"""
return _coin.SoLightPath_getIndex(self, index)
def getFullLength(self):
"""getFullLength(SoLightPath self) -> int"""
return _coin.SoLightPath_getFullLength(self)
def truncate(self, startindex):
"""truncate(SoLightPath self, int const startindex)"""
return _coin.SoLightPath_truncate(self, startindex)
def makeTempPath(self, path):
"""makeTempPath(SoLightPath self, SoTempPath path)"""
return _coin.SoLightPath_makeTempPath(self, path)
SoLightPath_swigregister = _coin.SoLightPath_swigregister
SoLightPath_swigregister(SoLightPath)
class SoFullPath(SoPath):
"""Proxy of C++ SoFullPath class."""
thisown = _swig_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")
__repr__ = _swig_repr
def pop(self):
"""pop(SoFullPath self)"""
return _coin.SoFullPath_pop(self)
def getTail(self):
"""getTail(SoFullPath self) -> SoNode"""
return _coin.SoFullPath_getTail(self)
def getNodeFromTail(self, index):
"""getNodeFromTail(SoFullPath self, int const index) -> SoNode"""
return _coin.SoFullPath_getNodeFromTail(self, index)
def getIndexFromTail(self, index):
"""getIndexFromTail(SoFullPath self, int const index) -> int"""
return _coin.SoFullPath_getIndexFromTail(self, index)
def getLength(self):
"""getLength(SoFullPath self) -> int"""
return _coin.SoFullPath_getLength(self)
def fromSoPath(path):
"""fromSoPath(SoPath path) -> SoFullPath"""
return _coin.SoFullPath_fromSoPath(path)
fromSoPath = staticmethod(fromSoPath)
SoFullPath_swigregister = _coin.SoFullPath_swigregister
SoFullPath_swigregister(SoFullPath)
def SoFullPath_fromSoPath(path):
"""SoFullPath_fromSoPath(SoPath path) -> SoFullPath"""
return _coin.SoFullPath_fromSoPath(path)
class SoTempPath(SoFullPath):
"""Proxy of C++ SoTempPath class."""
thisown = _swig_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")
__repr__ = _swig_repr
def simpleAppend(self, node, index):
"""simpleAppend(SoTempPath self, SoNode node, int const index)"""
return _coin.SoTempPath_simpleAppend(self, node, index)
def replaceTail(self, node, index):
"""replaceTail(SoTempPath self, SoNode node, int const index)"""
return _coin.SoTempPath_replaceTail(self, node, index)
SoTempPath_swigregister = _coin.SoTempPath_swigregister
SoTempPath_swigregister(SoTempPath)
class SoActionMethodList(SbPList):
"""Proxy of C++ SoActionMethodList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, parentlist):
"""__init__(SoActionMethodList self, SoActionMethodList parentlist) -> SoActionMethodList"""
this = _coin.new_SoActionMethodList(parentlist)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoActionMethodList
__del__ = lambda self: None
def addMethod(self, node, method):
"""addMethod(SoActionMethodList self, SoType node, SoActionMethod const method)"""
return _coin.SoActionMethodList_addMethod(self, node, method)
def setUp(self):
"""setUp(SoActionMethodList self)"""
return _coin.SoActionMethodList_setUp(self)
def __setitem__(self, i, value):
"""__setitem__(SoActionMethodList self, int const i, SoActionMethod * value)"""
return _coin.SoActionMethodList___setitem__(self, i, value)
def __getitem__(self, i):
"""__getitem__(SoActionMethodList self, int const i) -> SoActionMethod &"""
return _coin.SoActionMethodList___getitem__(self, i)
def get(self, i):
"""get(SoActionMethodList self, int const i) -> SoActionMethod"""
return _coin.SoActionMethodList_get(self, i)
SoActionMethodList_swigregister = _coin.SoActionMethodList_swigregister
SoActionMethodList_swigregister(SoActionMethodList)
class SoAction(object):
"""Proxy of C++ SoAction class."""
thisown = _swig_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 initClass():
"""initClass()"""
return _coin.SoAction_initClass()
initClass = staticmethod(initClass)
def initClasses():
"""initClasses()"""
return _coin.SoAction_initClasses()
initClasses = staticmethod(initClasses)
NODE = _coin.SoAction_NODE
PATH = _coin.SoAction_PATH
PATH_LIST = _coin.SoAction_PATH_LIST
NO_PATH = _coin.SoAction_NO_PATH
IN_PATH = _coin.SoAction_IN_PATH
BELOW_PATH = _coin.SoAction_BELOW_PATH
OFF_PATH = _coin.SoAction_OFF_PATH
__swig_destroy__ = _coin.delete_SoAction
__del__ = lambda self: None
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoAction self) -> SoType"""
return _coin.SoAction_getTypeId(self)
def isOfType(self, type):
"""isOfType(SoAction self, SoType type) -> SbBool"""
return _coin.SoAction_isOfType(self, type)
def apply(self, *args):
"""
apply(SoAction self, SoNode root)
apply(SoAction self, SoPath path)
apply(SoAction self, SoPathList pathlist, SbBool obeysrules=0)
apply(SoAction self, SoPathList pathlist)
apply(SoAction self, SoAction beingApplied)
"""
return _coin.SoAction_apply(self, *args)
def invalidateState(self):
"""invalidateState(SoAction self)"""
return _coin.SoAction_invalidateState(self)
def nullAction(action, node):
"""nullAction(SoAction action, SoNode node)"""
return _coin.SoAction_nullAction(action, node)
nullAction = staticmethod(nullAction)
def getWhatAppliedTo(self):
"""getWhatAppliedTo(SoAction self) -> SoAction::AppliedCode"""
return _coin.SoAction_getWhatAppliedTo(self)
def getNodeAppliedTo(self):
"""getNodeAppliedTo(SoAction self) -> SoNode"""
return _coin.SoAction_getNodeAppliedTo(self)
def getPathAppliedTo(self):
"""getPathAppliedTo(SoAction self) -> SoPath"""
return _coin.SoAction_getPathAppliedTo(self)
def getPathListAppliedTo(self):
"""getPathListAppliedTo(SoAction self) -> SoPathList"""
return _coin.SoAction_getPathListAppliedTo(self)
def getOriginalPathListAppliedTo(self):
"""getOriginalPathListAppliedTo(SoAction self) -> SoPathList"""
return _coin.SoAction_getOriginalPathListAppliedTo(self)
def isLastPathListAppliedTo(self):
"""isLastPathListAppliedTo(SoAction self) -> SbBool"""
return _coin.SoAction_isLastPathListAppliedTo(self)
def getPathCode(self, numindices, indices):
"""getPathCode(SoAction self, int & numindices, int const *& indices) -> SoAction::PathCode"""
return _coin.SoAction_getPathCode(self, numindices, indices)
def traverse(self, node):
"""traverse(SoAction self, SoNode node)"""
return _coin.SoAction_traverse(self, node)
def hasTerminated(self):
"""hasTerminated(SoAction self) -> SbBool"""
return _coin.SoAction_hasTerminated(self)
def getCurPath(self):
"""getCurPath(SoAction self) -> SoPath"""
return _coin.SoAction_getCurPath(self)
def getState(self):
"""getState(SoAction self) -> SoState"""
return _coin.SoAction_getState(self)
def getCurPathCode(self):
"""getCurPathCode(SoAction self) -> SoAction::PathCode"""
return _coin.SoAction_getCurPathCode(self)
def getCurPathTail(self):
"""getCurPathTail(SoAction self) -> SoNode"""
return _coin.SoAction_getCurPathTail(self)
def usePathCode(self, numindices, indices):
"""usePathCode(SoAction self, int & numindices, int const *& indices)"""
return _coin.SoAction_usePathCode(self, numindices, indices)
def pushCurPath(self, *args):
"""
pushCurPath(SoAction self, int const childindex, SoNode node=None)
pushCurPath(SoAction self, int const childindex)
pushCurPath(SoAction self)
"""
return _coin.SoAction_pushCurPath(self, *args)
def popPushCurPath(self, childindex, node=None):
"""
popPushCurPath(SoAction self, int const childindex, SoNode node=None)
popPushCurPath(SoAction self, int const childindex)
"""
return _coin.SoAction_popPushCurPath(self, childindex, node)
def popCurPath(self, *args):
"""
popCurPath(SoAction self, SoAction::PathCode const prevpathcode)
popCurPath(SoAction self)
"""
return _coin.SoAction_popCurPath(self, *args)
def switchToPathTraversal(self, path):
"""switchToPathTraversal(SoAction self, SoPath path)"""
return _coin.SoAction_switchToPathTraversal(self, path)
def switchToNodeTraversal(self, node):
"""switchToNodeTraversal(SoAction self, SoNode node)"""
return _coin.SoAction_switchToNodeTraversal(self, node)
SoAction_swigregister = _coin.SoAction_swigregister
SoAction_swigregister(SoAction)
def SoAction_initClass():
"""SoAction_initClass()"""
return _coin.SoAction_initClass()
def SoAction_initClasses():
"""SoAction_initClasses()"""
return _coin.SoAction_initClasses()
def SoAction_getClassTypeId():
"""SoAction_getClassTypeId() -> SoType"""
return _coin.SoAction_getClassTypeId()
def SoAction_nullAction(action, node):
"""SoAction_nullAction(SoAction action, SoNode node)"""
return _coin.SoAction_nullAction(action, node)
class SoState(object):
"""Proxy of C++ SoState class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, action, enabledelements):
"""__init__(SoState self, SoAction action, SoTypeList enabledelements) -> SoState"""
this = _coin.new_SoState(action, enabledelements)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoState
__del__ = lambda self: None
def getAction(self):
"""getAction(SoState self) -> SoAction"""
return _coin.SoState_getAction(self)
def getElement(self, stackindex):
"""getElement(SoState self, int const stackindex) -> SoElement"""
return _coin.SoState_getElement(self, stackindex)
def getConstElement(self, stackindex):
"""getConstElement(SoState self, int const stackindex) -> SoElement"""
return _coin.SoState_getConstElement(self, stackindex)
def push(self):
"""push(SoState self)"""
return _coin.SoState_push(self)
def pop(self):
"""pop(SoState self)"""
return _coin.SoState_pop(self)
def output(self, *args):
"""
output(SoState self, FILE *const file)
output(SoState self)
"""
return _coin.SoState_output(self, *args)
def isElementEnabled(self, stackindex):
"""isElementEnabled(SoState self, int const stackindex) -> SbBool"""
return _coin.SoState_isElementEnabled(self, stackindex)
def getDepth(self):
"""getDepth(SoState self) -> int"""
return _coin.SoState_getDepth(self)
def setCacheOpen(self, flag):
"""setCacheOpen(SoState self, SbBool const flag)"""
return _coin.SoState_setCacheOpen(self, flag)
def isCacheOpen(self):
"""isCacheOpen(SoState self) -> SbBool"""
return _coin.SoState_isCacheOpen(self)
def getElementNoPush(self, stackindex):
"""getElementNoPush(SoState self, int const stackindex) -> SoElement"""
return _coin.SoState_getElementNoPush(self, stackindex)
SoState_swigregister = _coin.SoState_swigregister
SoState_swigregister(SoState)
class SoElement(object):
"""Proxy of C++ SoElement class."""
thisown = _swig_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 initClass():
"""initClass()"""
return _coin.SoElement_initClass()
initClass = staticmethod(initClass)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def getTypeId(self):
"""getTypeId(SoElement self) -> SoType"""
return _coin.SoElement_getTypeId(self)
def getStackIndex(self):
"""getStackIndex(SoElement self) -> int"""
return _coin.SoElement_getStackIndex(self)
def init(self, state):
"""init(SoElement self, SoState state)"""
return _coin.SoElement_init(self, state)
def push(self, state):
"""push(SoElement self, SoState state)"""
return _coin.SoElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoElement_pop(self, state, prevTopElement)
def matches(self, element):
"""matches(SoElement self, SoElement element) -> SbBool"""
return _coin.SoElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoElement self) -> SoElement"""
return _coin.SoElement_copyMatchInfo(self)
def initElements():
"""initElements()"""
return _coin.SoElement_initElements()
initElements = staticmethod(initElements)
def getNumStackIndices():
"""getNumStackIndices() -> int"""
return _coin.SoElement_getNumStackIndices()
getNumStackIndices = staticmethod(getNumStackIndices)
def getIdFromStackIndex(stackIndex):
"""getIdFromStackIndex(int const stackIndex) -> SoType"""
return _coin.SoElement_getIdFromStackIndex(stackIndex)
getIdFromStackIndex = staticmethod(getIdFromStackIndex)
def setDepth(self, depth):
"""setDepth(SoElement self, int const depth)"""
return _coin.SoElement_setDepth(self, depth)
def getDepth(self):
"""getDepth(SoElement self) -> int"""
return _coin.SoElement_getDepth(self)
def output(self, *args):
"""
output(SoElement self, FILE * file)
output(SoElement self)
"""
return _coin.SoElement_output(self, *args)
__swig_destroy__ = _coin.delete_SoElement
__del__ = lambda self: None
SoElement_swigregister = _coin.SoElement_swigregister
SoElement_swigregister(SoElement)
def SoElement_initClass():
"""SoElement_initClass()"""
return _coin.SoElement_initClass()
def SoElement_getClassTypeId():
"""SoElement_getClassTypeId() -> SoType"""
return _coin.SoElement_getClassTypeId()
def SoElement_getClassStackIndex():
"""SoElement_getClassStackIndex() -> int"""
return _coin.SoElement_getClassStackIndex()
def SoElement_initElements():
"""SoElement_initElements()"""
return _coin.SoElement_initElements()
def SoElement_getNumStackIndices():
"""SoElement_getNumStackIndices() -> int"""
return _coin.SoElement_getNumStackIndices()
def SoElement_getIdFromStackIndex(stackIndex):
"""SoElement_getIdFromStackIndex(int const stackIndex) -> SoType"""
return _coin.SoElement_getIdFromStackIndex(stackIndex)
class SoInt32Element(SoElement):
"""Proxy of C++ SoInt32Element class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoInt32Element_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoInt32Element_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def initClass():
"""initClass()"""
return _coin.SoInt32Element_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoInt32Element self, SoState state)"""
return _coin.SoInt32Element_init(self, state)
def matches(self, element):
"""matches(SoInt32Element self, SoElement element) -> SbBool"""
return _coin.SoInt32Element_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoInt32Element self) -> SoElement"""
return _coin.SoInt32Element_copyMatchInfo(self)
def output(self, file):
"""output(SoInt32Element self, FILE * file)"""
return _coin.SoInt32Element_output(self, file)
def set(*args):
"""
set(int const index, SoState state, SoNode node, int32_t const value)
set(int const index, SoState state, int32_t const value)
"""
return _coin.SoInt32Element_set(*args)
set = staticmethod(set)
def get(index, state):
"""get(int const index, SoState state) -> int32_t"""
return _coin.SoInt32Element_get(index, state)
get = staticmethod(get)
def setElt(self, value):
"""setElt(SoInt32Element self, int32_t value)"""
return _coin.SoInt32Element_setElt(self, value)
SoInt32Element_swigregister = _coin.SoInt32Element_swigregister
SoInt32Element_swigregister(SoInt32Element)
def SoInt32Element_getClassTypeId():
"""SoInt32Element_getClassTypeId() -> SoType"""
return _coin.SoInt32Element_getClassTypeId()
def SoInt32Element_getClassStackIndex():
"""SoInt32Element_getClassStackIndex() -> int"""
return _coin.SoInt32Element_getClassStackIndex()
def SoInt32Element_initClass():
"""SoInt32Element_initClass()"""
return _coin.SoInt32Element_initClass()
def SoInt32Element_set(*args):
"""
set(int const index, SoState state, SoNode node, int32_t const value)
SoInt32Element_set(int const index, SoState state, int32_t const value)
"""
return _coin.SoInt32Element_set(*args)
def SoInt32Element_get(index, state):
"""SoInt32Element_get(int const index, SoState state) -> int32_t"""
return _coin.SoInt32Element_get(index, state)
class SoDecimationTypeElement(SoInt32Element):
"""Proxy of C++ SoDecimationTypeElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoDecimationTypeElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoDecimationTypeElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoDecimationTypeElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoDecimationTypeElement_initClass()
initClass = staticmethod(initClass)
AUTOMATIC = _coin.SoDecimationTypeElement_AUTOMATIC
HIGHEST = _coin.SoDecimationTypeElement_HIGHEST
LOWEST = _coin.SoDecimationTypeElement_LOWEST
PERCENTAGE = _coin.SoDecimationTypeElement_PERCENTAGE
def init(self, state):
"""init(SoDecimationTypeElement self, SoState state)"""
return _coin.SoDecimationTypeElement_init(self, state)
def set(*args):
"""
set(SoState state, SoDecimationTypeElement::Type const type)
set(SoState state, SoNode node, SoDecimationTypeElement::Type const type)
"""
return _coin.SoDecimationTypeElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SoDecimationTypeElement::Type"""
return _coin.SoDecimationTypeElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SoDecimationTypeElement::Type"""
return _coin.SoDecimationTypeElement_getDefault()
getDefault = staticmethod(getDefault)
SoDecimationTypeElement_swigregister = _coin.SoDecimationTypeElement_swigregister
SoDecimationTypeElement_swigregister(SoDecimationTypeElement)
def SoDecimationTypeElement_getClassTypeId():
"""SoDecimationTypeElement_getClassTypeId() -> SoType"""
return _coin.SoDecimationTypeElement_getClassTypeId()
def SoDecimationTypeElement_getClassStackIndex():
"""SoDecimationTypeElement_getClassStackIndex() -> int"""
return _coin.SoDecimationTypeElement_getClassStackIndex()
def SoDecimationTypeElement_createInstance():
"""SoDecimationTypeElement_createInstance() -> void *"""
return _coin.SoDecimationTypeElement_createInstance()
def SoDecimationTypeElement_initClass():
"""SoDecimationTypeElement_initClass()"""
return _coin.SoDecimationTypeElement_initClass()
def SoDecimationTypeElement_set(*args):
"""
set(SoState state, SoDecimationTypeElement::Type const type)
SoDecimationTypeElement_set(SoState state, SoNode node, SoDecimationTypeElement::Type const type)
"""
return _coin.SoDecimationTypeElement_set(*args)
def SoDecimationTypeElement_get(state):
"""SoDecimationTypeElement_get(SoState state) -> SoDecimationTypeElement::Type"""
return _coin.SoDecimationTypeElement_get(state)
def SoDecimationTypeElement_getDefault():
"""SoDecimationTypeElement_getDefault() -> SoDecimationTypeElement::Type"""
return _coin.SoDecimationTypeElement_getDefault()
class SoFieldData(object):
"""Proxy of C++ SoFieldData class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoFieldData self) -> SoFieldData
__init__(SoFieldData self, SoFieldData fd) -> SoFieldData
__init__(SoFieldData self, SoFieldData fd) -> SoFieldData
__init__(SoFieldData self, int numfields) -> SoFieldData
"""
this = _coin.new_SoFieldData(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoFieldData
__del__ = lambda self: None
def addField(self, base, name, field):
"""addField(SoFieldData self, SoFieldContainer base, char const * name, SoField field)"""
return _coin.SoFieldData_addField(self, base, name, field)
def overlay(self, to, arg3, copyconnections):
"""overlay(SoFieldData self, SoFieldContainer to, SoFieldContainer arg3, SbBool copyconnections)"""
return _coin.SoFieldData_overlay(self, to, arg3, copyconnections)
def getNumFields(self):
"""getNumFields(SoFieldData self) -> int"""
return _coin.SoFieldData_getNumFields(self)
def getFieldName(self, index):
"""getFieldName(SoFieldData self, int index) -> SbName"""
return _coin.SoFieldData_getFieldName(self, index)
def getField(self, object, index):
"""getField(SoFieldData self, SoFieldContainer object, int index) -> SoField"""
return _coin.SoFieldData_getField(self, object, index)
def getIndex(self, fc, field):
"""getIndex(SoFieldData self, SoFieldContainer fc, SoField field) -> int"""
return _coin.SoFieldData_getIndex(self, fc, field)
def addEnumValue(self, enumname, valuename, value):
"""addEnumValue(SoFieldData self, char const * enumname, char const * valuename, int value)"""
return _coin.SoFieldData_addEnumValue(self, enumname, valuename, value)
def getEnumData(self, enumname, num, values, names):
"""getEnumData(SoFieldData self, char const * enumname, int & num, int const *& values, SbName const *& names)"""
return _coin.SoFieldData_getEnumData(self, enumname, num, values, names)
def read(self, *args):
"""
read(SoFieldData self, SoInput input, SoFieldContainer object, SbBool erroronunknownfield, SbBool & notbuiltin) -> SbBool
read(SoFieldData self, SoInput input, SoFieldContainer object, SbName fieldname, SbBool & foundname) -> SbBool
"""
return _coin.SoFieldData_read(self, *args)
def write(self, out, object):
"""write(SoFieldData self, SoOutput out, SoFieldContainer object)"""
return _coin.SoFieldData_write(self, out, object)
def copy(self, src):
"""copy(SoFieldData self, SoFieldData src)"""
return _coin.SoFieldData_copy(self, src)
def isSame(self, c1, c2):
"""isSame(SoFieldData self, SoFieldContainer c1, SoFieldContainer c2) -> SbBool"""
return _coin.SoFieldData_isSame(self, c1, c2)
def readFieldDescriptions(self, input, object, numdescriptionsexpected, readfieldvalues=1):
"""
readFieldDescriptions(SoFieldData self, SoInput input, SoFieldContainer object, int numdescriptionsexpected, SbBool const readfieldvalues=1) -> SbBool
readFieldDescriptions(SoFieldData self, SoInput input, SoFieldContainer object, int numdescriptionsexpected) -> SbBool
"""
return _coin.SoFieldData_readFieldDescriptions(self, input, object, numdescriptionsexpected, readfieldvalues)
def writeFieldDescriptions(self, out, object):
"""writeFieldDescriptions(SoFieldData self, SoOutput out, SoFieldContainer object)"""
return _coin.SoFieldData_writeFieldDescriptions(self, out, object)
SoFieldData_swigregister = _coin.SoFieldData_swigregister
SoFieldData_swigregister(SoFieldData)
class SoFieldContainer(SoBase):
"""Proxy of C++ SoFieldContainer class."""
thisown = _swig_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 initClass():
"""initClass()"""
return _coin.SoFieldContainer_initClass()
initClass = staticmethod(initClass)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoFieldContainer_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoFieldContainer_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def setToDefaults(self):
"""setToDefaults(SoFieldContainer self)"""
return _coin.SoFieldContainer_setToDefaults(self)
def hasDefaultValues(self):
"""hasDefaultValues(SoFieldContainer self) -> SbBool"""
return _coin.SoFieldContainer_hasDefaultValues(self)
def fieldsAreEqual(self, container):
"""fieldsAreEqual(SoFieldContainer self, SoFieldContainer container) -> SbBool"""
return _coin.SoFieldContainer_fieldsAreEqual(self, container)
def copyFieldValues(self, container, copyconnections=0):
"""
copyFieldValues(SoFieldContainer self, SoFieldContainer container, SbBool copyconnections=0)
copyFieldValues(SoFieldContainer self, SoFieldContainer container)
"""
return _coin.SoFieldContainer_copyFieldValues(self, container, copyconnections)
def getFields(self, l):
"""getFields(SoFieldContainer self, SoFieldList l) -> int"""
return _coin.SoFieldContainer_getFields(self, l)
def getAllFields(self, l):
"""getAllFields(SoFieldContainer self, SoFieldList l) -> int"""
return _coin.SoFieldContainer_getAllFields(self, l)
def getField(self, name):
"""getField(SoFieldContainer self, SbName name) -> SoField"""
return _coin.SoFieldContainer_getField(self, name)
def getEventIn(self, name):
"""getEventIn(SoFieldContainer self, SbName name) -> SoField"""
return _coin.SoFieldContainer_getEventIn(self, name)
def getEventOut(self, name):
"""getEventOut(SoFieldContainer self, SbName name) -> SoField"""
return _coin.SoFieldContainer_getEventOut(self, name)
def enableNotify(self, flag):
"""enableNotify(SoFieldContainer self, SbBool const flag) -> SbBool"""
return _coin.SoFieldContainer_enableNotify(self, flag)
def isNotifyEnabled(self):
"""isNotifyEnabled(SoFieldContainer self) -> SbBool"""
return _coin.SoFieldContainer_isNotifyEnabled(self)
def set(self, *args):
"""
set(SoFieldContainer self, char const *const fielddata) -> SbBool
set(SoFieldContainer self, char const * fielddata, SoInput input) -> SbBool
"""
return _coin.SoFieldContainer_set(self, *args)
def get(self, *args):
"""
get(SoFieldContainer self, SbString fielddata)
get(SoFieldContainer self, SbString fielddata, SoOutput out)
"""
return _coin.SoFieldContainer_get(self, *args)
def notify(self, l):
"""notify(SoFieldContainer self, SoNotList l)"""
return _coin.SoFieldContainer_notify(self, l)
def validateNewFieldValue(self, field, newval):
"""validateNewFieldValue(SoFieldContainer self, SoField field, void * newval) -> SbBool"""
return _coin.SoFieldContainer_validateNewFieldValue(self, field, newval)
def addWriteReference(self, out, isfromfield=0):
"""
addWriteReference(SoFieldContainer self, SoOutput out, SbBool isfromfield=0)
addWriteReference(SoFieldContainer self, SoOutput out)
"""
return _coin.SoFieldContainer_addWriteReference(self, out, isfromfield)
def writeInstance(self, out):
"""writeInstance(SoFieldContainer self, SoOutput out)"""
return _coin.SoFieldContainer_writeInstance(self, out)
def getIsBuiltIn(self):
"""getIsBuiltIn(SoFieldContainer self) -> SbBool"""
return _coin.SoFieldContainer_getIsBuiltIn(self)
def getFieldData(self):
"""getFieldData(SoFieldContainer self) -> SoFieldData"""
return _coin.SoFieldContainer_getFieldData(self)
def copyContents(self, arg2, copyconnections):
"""copyContents(SoFieldContainer self, SoFieldContainer arg2, SbBool copyconnections)"""
return _coin.SoFieldContainer_copyContents(self, arg2, copyconnections)
def copyThroughConnection(self):
"""copyThroughConnection(SoFieldContainer self) -> SoFieldContainer"""
return _coin.SoFieldContainer_copyThroughConnection(self)
def initCopyDict():
"""initCopyDict()"""
return _coin.SoFieldContainer_initCopyDict()
initCopyDict = staticmethod(initCopyDict)
def addCopy(orig, copy):
"""addCopy(SoFieldContainer orig, SoFieldContainer copy)"""
return _coin.SoFieldContainer_addCopy(orig, copy)
addCopy = staticmethod(addCopy)
def checkCopy(orig):
"""checkCopy(SoFieldContainer orig) -> SoFieldContainer"""
return _coin.SoFieldContainer_checkCopy(orig)
checkCopy = staticmethod(checkCopy)
def findCopy(orig, copyconnections):
"""findCopy(SoFieldContainer orig, SbBool const copyconnections) -> SoFieldContainer"""
return _coin.SoFieldContainer_findCopy(orig, copyconnections)
findCopy = staticmethod(findCopy)
def copyDone():
"""copyDone()"""
return _coin.SoFieldContainer_copyDone()
copyDone = staticmethod(copyDone)
def getFieldsMemorySize(self, managed, unmanaged):
"""getFieldsMemorySize(SoFieldContainer self, size_t & managed, size_t & unmanaged)"""
return _coin.SoFieldContainer_getFieldsMemorySize(self, managed, unmanaged)
def setUserData(self, userdata):
"""setUserData(SoFieldContainer self, void * userdata)"""
return _coin.SoFieldContainer_setUserData(self, userdata)
def getUserData(self):
"""getUserData(SoFieldContainer self) -> void *"""
return _coin.SoFieldContainer_getUserData(self)
def getFieldName(self, *args):
"""
getFieldName(SoFieldContainer self, SoField field, SbName name) -> SbBool
getFieldName(SoFieldContainer self, SoField field) -> PyObject *
"""
return _coin.SoFieldContainer_getFieldName(self, *args)
def __getattr__(self, name):
try:
return SoBase.__getattribute__(self, name)
except AttributeError as e:
##############################################################
if name == "this":
raise AttributeError
##############################################################
field = self.getField(name)
if field is None:
raise e
return field
def __setattr__(self, name, value):
# I don't understand why we need this, but otherwise it does not work :/
if name == 'this':
return SoBase.__setattr__(self, name, value)
field = self.getField(name)
if field is None:
return SoBase.__setattr__(self, name, value)
field.setValue(value)
return field
@property
def values(self):
def _values(obj):
for value in obj:
if hasattr(value, "__iter__"):
yield list(_values(value))
else:
yield value
out = _values(self)
return list(out)
@values.setter
def values(self, arr):
self.deleteValues(0)
self.setValues(0, len(arr), arr)
SoFieldContainer_swigregister = _coin.SoFieldContainer_swigregister
SoFieldContainer_swigregister(SoFieldContainer)
def SoFieldContainer_initClass():
"""SoFieldContainer_initClass()"""
return _coin.SoFieldContainer_initClass()
def SoFieldContainer_getClassTypeId():
"""SoFieldContainer_getClassTypeId() -> SoType"""
return _coin.SoFieldContainer_getClassTypeId()
def SoFieldContainer_cleanupClass():
"""SoFieldContainer_cleanupClass()"""
return _coin.SoFieldContainer_cleanupClass()
def SoFieldContainer_initCopyDict():
"""SoFieldContainer_initCopyDict()"""
return _coin.SoFieldContainer_initCopyDict()
def SoFieldContainer_addCopy(orig, copy):
"""SoFieldContainer_addCopy(SoFieldContainer orig, SoFieldContainer copy)"""
return _coin.SoFieldContainer_addCopy(orig, copy)
def SoFieldContainer_checkCopy(orig):
"""SoFieldContainer_checkCopy(SoFieldContainer orig) -> SoFieldContainer"""
return _coin.SoFieldContainer_checkCopy(orig)
def SoFieldContainer_findCopy(orig, copyconnections):
"""SoFieldContainer_findCopy(SoFieldContainer orig, SbBool const copyconnections) -> SoFieldContainer"""
return _coin.SoFieldContainer_findCopy(orig, copyconnections)
def SoFieldContainer_copyDone():
"""SoFieldContainer_copyDone()"""
return _coin.SoFieldContainer_copyDone()
class SoNode(SoFieldContainer):
"""Proxy of C++ SoNode class."""
thisown = _swig_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
FIRST_INSTANCE = _coin.SoNode_FIRST_INSTANCE
PROTO_INSTANCE = _coin.SoNode_PROTO_INSTANCE
OTHER_INSTANCE = _coin.SoNode_OTHER_INSTANCE
def setOverride(self, state):
"""setOverride(SoNode self, SbBool const state)"""
return _coin.SoNode_setOverride(self, state)
def isOverride(self):
"""isOverride(SoNode self) -> SbBool"""
return _coin.SoNode_isOverride(self)
INVENTOR = _coin.SoNode_INVENTOR
VRML1 = _coin.SoNode_VRML1
VRML2 = _coin.SoNode_VRML2
INVENTOR_1 = _coin.SoNode_INVENTOR_1
INVENTOR_2_0 = _coin.SoNode_INVENTOR_2_0
INVENTOR_2_1 = _coin.SoNode_INVENTOR_2_1
INVENTOR_2_5 = _coin.SoNode_INVENTOR_2_5
INVENTOR_2_6 = _coin.SoNode_INVENTOR_2_6
COIN_1_0 = _coin.SoNode_COIN_1_0
COIN_2_0 = _coin.SoNode_COIN_2_0
EXTENSION = _coin.SoNode_EXTENSION
COIN_2_2 = _coin.SoNode_COIN_2_2
COIN_2_3 = _coin.SoNode_COIN_2_3
COIN_2_4 = _coin.SoNode_COIN_2_4
INVENTOR_5_0 = _coin.SoNode_INVENTOR_5_0
COIN_2_5 = _coin.SoNode_COIN_2_5
COIN_3_0 = _coin.SoNode_COIN_3_0
INVENTOR_6_0 = _coin.SoNode_INVENTOR_6_0
COIN_4_0 = _coin.SoNode_COIN_4_0
def getCompatibilityTypes(nodetype):
"""getCompatibilityTypes(SoType nodetype) -> uint32_t"""
return _coin.SoNode_getCompatibilityTypes(nodetype)
getCompatibilityTypes = staticmethod(getCompatibilityTypes)
def setNodeType(self, type):
"""setNodeType(SoNode self, SoNode::NodeType const type)"""
return _coin.SoNode_setNodeType(self, type)
def getNodeType(self):
"""getNodeType(SoNode self) -> SoNode::NodeType"""
return _coin.SoNode_getNodeType(self)
def copy(self, copyconnections=0):
"""
copy(SoNode self, SbBool copyconnections=0) -> SoNode
copy(SoNode self) -> SoNode
"""
return _coin.SoNode_copy(self, copyconnections)
def affectsState(self):
"""affectsState(SoNode self) -> SbBool"""
return _coin.SoNode_affectsState(self)
def doAction(self, action):
"""doAction(SoNode self, SoAction action)"""
return _coin.SoNode_doAction(self, action)
def GLRender(self, action):
"""GLRender(SoNode self, SoGLRenderAction action)"""
return _coin.SoNode_GLRender(self, action)
def GLRenderBelowPath(self, action):
"""GLRenderBelowPath(SoNode self, SoGLRenderAction action)"""
return _coin.SoNode_GLRenderBelowPath(self, action)
def GLRenderInPath(self, action):
"""GLRenderInPath(SoNode self, SoGLRenderAction action)"""
return _coin.SoNode_GLRenderInPath(self, action)
def GLRenderOffPath(self, action):
"""GLRenderOffPath(SoNode self, SoGLRenderAction action)"""
return _coin.SoNode_GLRenderOffPath(self, action)
def callback(self, action):
"""callback(SoNode self, SoCallbackAction action)"""
return _coin.SoNode_callback(self, action)
def getBoundingBox(self, action):
"""getBoundingBox(SoNode self, SoGetBoundingBoxAction action)"""
return _coin.SoNode_getBoundingBox(self, action)
def getMatrix(self, action):
"""getMatrix(SoNode self, SoGetMatrixAction action)"""
return _coin.SoNode_getMatrix(self, action)
def handleEvent(self, action):
"""handleEvent(SoNode self, SoHandleEventAction action)"""
return _coin.SoNode_handleEvent(self, action)
def pick(self, action):
"""pick(SoNode self, SoPickAction action)"""
return _coin.SoNode_pick(self, action)
def rayPick(self, action):
"""rayPick(SoNode self, SoRayPickAction action)"""
return _coin.SoNode_rayPick(self, action)
def search(self, action):
"""search(SoNode self, SoSearchAction action)"""
return _coin.SoNode_search(self, action)
def write(self, action):
"""write(SoNode self, SoWriteAction action)"""
return _coin.SoNode_write(self, action)
def audioRender(self, action):
"""audioRender(SoNode self, SoAudioRenderAction action)"""
return _coin.SoNode_audioRender(self, action)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoNode self, SoGetPrimitiveCountAction action)"""
return _coin.SoNode_getPrimitiveCount(self, action)
def grabEventsSetup(self):
"""grabEventsSetup(SoNode self)"""
return _coin.SoNode_grabEventsSetup(self)
def grabEventsCleanup(self):
"""grabEventsCleanup(SoNode self)"""
return _coin.SoNode_grabEventsCleanup(self)
def startNotify(self):
"""startNotify(SoNode self)"""
return _coin.SoNode_startNotify(self)
def notify(self, l):
"""notify(SoNode self, SoNotList l)"""
return _coin.SoNode_notify(self, l)
def getNodeId(self):
"""getNodeId(SoNode self) -> uint32_t"""
return _coin.SoNode_getNodeId(self)
def getChildren(self):
"""getChildren(SoNode self) -> SoChildList"""
return _coin.SoNode_getChildren(self)
def writeInstance(self, out):
"""writeInstance(SoNode self, SoOutput out)"""
return _coin.SoNode_writeInstance(self, out)
def addToCopyDict(self):
"""addToCopyDict(SoNode self) -> SoNode"""
return _coin.SoNode_addToCopyDict(self)
def copyContents(self, arg2, copyconnections):
"""copyContents(SoNode self, SoFieldContainer arg2, SbBool copyconnections)"""
return _coin.SoNode_copyContents(self, arg2, copyconnections)
def copyThroughConnection(self):
"""copyThroughConnection(SoNode self) -> SoFieldContainer"""
return _coin.SoNode_copyThroughConnection(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoNode_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getByName(*args):
"""
getByName(SbName name) -> SoNode
getByName(SbName name, SoNodeList l) -> int
"""
return _coin.SoNode_getByName(*args)
getByName = staticmethod(getByName)
def initClass():
"""initClass()"""
return _coin.SoNode_initClass()
initClass = staticmethod(initClass)
def initClasses():
"""initClasses()"""
return _coin.SoNode_initClasses()
initClasses = staticmethod(initClasses)
def getNextNodeId():
"""getNextNodeId() -> uint32_t"""
return _coin.SoNode_getNextNodeId()
getNextNodeId = staticmethod(getNextNodeId)
def getActionMethodIndex(type):
"""getActionMethodIndex(SoType type) -> int"""
return _coin.SoNode_getActionMethodIndex(type)
getActionMethodIndex = staticmethod(getActionMethodIndex)
def getBoundingBoxS(action, node):
"""getBoundingBoxS(SoAction action, SoNode node)"""
return _coin.SoNode_getBoundingBoxS(action, node)
getBoundingBoxS = staticmethod(getBoundingBoxS)
def GLRenderS(action, node):
"""GLRenderS(SoAction action, SoNode node)"""
return _coin.SoNode_GLRenderS(action, node)
GLRenderS = staticmethod(GLRenderS)
def callbackS(action, node):
"""callbackS(SoAction action, SoNode node)"""
return _coin.SoNode_callbackS(action, node)
callbackS = staticmethod(callbackS)
def getMatrixS(action, node):
"""getMatrixS(SoAction action, SoNode node)"""
return _coin.SoNode_getMatrixS(action, node)
getMatrixS = staticmethod(getMatrixS)
def handleEventS(action, node):
"""handleEventS(SoAction action, SoNode node)"""
return _coin.SoNode_handleEventS(action, node)
handleEventS = staticmethod(handleEventS)
def pickS(action, node):
"""pickS(SoAction action, SoNode node)"""
return _coin.SoNode_pickS(action, node)
pickS = staticmethod(pickS)
def rayPickS(action, node):
"""rayPickS(SoAction action, SoNode node)"""
return _coin.SoNode_rayPickS(action, node)
rayPickS = staticmethod(rayPickS)
def searchS(action, node):
"""searchS(SoAction action, SoNode node)"""
return _coin.SoNode_searchS(action, node)
searchS = staticmethod(searchS)
def writeS(action, node):
"""writeS(SoAction action, SoNode node)"""
return _coin.SoNode_writeS(action, node)
writeS = staticmethod(writeS)
def audioRenderS(action, node):
"""audioRenderS(SoAction action, SoNode node)"""
return _coin.SoNode_audioRenderS(action, node)
audioRenderS = staticmethod(audioRenderS)
def getPrimitiveCountS(action, node):
"""getPrimitiveCountS(SoAction action, SoNode node)"""
return _coin.SoNode_getPrimitiveCountS(action, node)
getPrimitiveCountS = staticmethod(getPrimitiveCountS)
SoNode_swigregister = _coin.SoNode_swigregister
SoNode_swigregister(SoNode)
def SoNode_getCompatibilityTypes(nodetype):
"""SoNode_getCompatibilityTypes(SoType nodetype) -> uint32_t"""
return _coin.SoNode_getCompatibilityTypes(nodetype)
def SoNode_getClassTypeId():
"""SoNode_getClassTypeId() -> SoType"""
return _coin.SoNode_getClassTypeId()
def SoNode_getByName(*args):
"""
getByName(SbName name) -> SoNode
SoNode_getByName(SbName name, SoNodeList l) -> int
"""
return _coin.SoNode_getByName(*args)
def SoNode_initClass():
"""SoNode_initClass()"""
return _coin.SoNode_initClass()
def SoNode_initClasses():
"""SoNode_initClasses()"""
return _coin.SoNode_initClasses()
def SoNode_getNextNodeId():
"""SoNode_getNextNodeId() -> uint32_t"""
return _coin.SoNode_getNextNodeId()
def SoNode_getActionMethodIndex(type):
"""SoNode_getActionMethodIndex(SoType type) -> int"""
return _coin.SoNode_getActionMethodIndex(type)
def SoNode_getBoundingBoxS(action, node):
"""SoNode_getBoundingBoxS(SoAction action, SoNode node)"""
return _coin.SoNode_getBoundingBoxS(action, node)
def SoNode_GLRenderS(action, node):
"""SoNode_GLRenderS(SoAction action, SoNode node)"""
return _coin.SoNode_GLRenderS(action, node)
def SoNode_callbackS(action, node):
"""SoNode_callbackS(SoAction action, SoNode node)"""
return _coin.SoNode_callbackS(action, node)
def SoNode_getMatrixS(action, node):
"""SoNode_getMatrixS(SoAction action, SoNode node)"""
return _coin.SoNode_getMatrixS(action, node)
def SoNode_handleEventS(action, node):
"""SoNode_handleEventS(SoAction action, SoNode node)"""
return _coin.SoNode_handleEventS(action, node)
def SoNode_pickS(action, node):
"""SoNode_pickS(SoAction action, SoNode node)"""
return _coin.SoNode_pickS(action, node)
def SoNode_rayPickS(action, node):
"""SoNode_rayPickS(SoAction action, SoNode node)"""
return _coin.SoNode_rayPickS(action, node)
def SoNode_searchS(action, node):
"""SoNode_searchS(SoAction action, SoNode node)"""
return _coin.SoNode_searchS(action, node)
def SoNode_writeS(action, node):
"""SoNode_writeS(SoAction action, SoNode node)"""
return _coin.SoNode_writeS(action, node)
def SoNode_audioRenderS(action, node):
"""SoNode_audioRenderS(SoAction action, SoNode node)"""
return _coin.SoNode_audioRenderS(action, node)
def SoNode_getPrimitiveCountS(action, node):
"""SoNode_getPrimitiveCountS(SoAction action, SoNode node)"""
return _coin.SoNode_getPrimitiveCountS(action, node)
class SoSensorManager(object):
"""Proxy of C++ SoSensorManager class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSensorManager self) -> SoSensorManager"""
this = _coin.new_SoSensorManager()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSensorManager
__del__ = lambda self: None
def insertDelaySensor(self, s):
"""insertDelaySensor(SoSensorManager self, SoDelayQueueSensor s)"""
return _coin.SoSensorManager_insertDelaySensor(self, s)
def insertTimerSensor(self, s):
"""insertTimerSensor(SoSensorManager self, SoTimerQueueSensor s)"""
return _coin.SoSensorManager_insertTimerSensor(self, s)
def removeDelaySensor(self, s):
"""removeDelaySensor(SoSensorManager self, SoDelayQueueSensor s)"""
return _coin.SoSensorManager_removeDelaySensor(self, s)
def removeTimerSensor(self, s):
"""removeTimerSensor(SoSensorManager self, SoTimerQueueSensor s)"""
return _coin.SoSensorManager_removeTimerSensor(self, s)
def rescheduleTimer(self, s):
"""rescheduleTimer(SoSensorManager self, SoTimerSensor s)"""
return _coin.SoSensorManager_rescheduleTimer(self, s)
def removeRescheduledTimer(self, s):
"""removeRescheduledTimer(SoSensorManager self, SoTimerQueueSensor s)"""
return _coin.SoSensorManager_removeRescheduledTimer(self, s)
def processDelayQueue(self, isidle):
"""processDelayQueue(SoSensorManager self, SbBool isidle)"""
return _coin.SoSensorManager_processDelayQueue(self, isidle)
def processImmediateQueue(self):
"""processImmediateQueue(SoSensorManager self)"""
return _coin.SoSensorManager_processImmediateQueue(self)
def processTimerQueue(self):
"""processTimerQueue(SoSensorManager self)"""
return _coin.SoSensorManager_processTimerQueue(self)
def isDelaySensorPending(self):
"""isDelaySensorPending(SoSensorManager self) -> SbBool"""
return _coin.SoSensorManager_isDelaySensorPending(self)
def setDelaySensorTimeout(self, t):
"""setDelaySensorTimeout(SoSensorManager self, SbTime t)"""
return _coin.SoSensorManager_setDelaySensorTimeout(self, t)
def getDelaySensorTimeout(self):
"""getDelaySensorTimeout(SoSensorManager self) -> SbTime"""
return _coin.SoSensorManager_getDelaySensorTimeout(self)
def doSelect(self, nfds, readfds, writefds, exceptfds, userTimeOut):
"""doSelect(SoSensorManager self, int nfds, void * readfds, void * writefds, void * exceptfds, timeval * userTimeOut) -> int"""
return _coin.SoSensorManager_doSelect(self, nfds, readfds, writefds, exceptfds, userTimeOut)
def setChangedCallback(self, *args):
"""
setChangedCallback(SoSensorManager self, void (*)(void *) sensorQueueChangedCB, void * data)
setChangedCallback(SoSensorManager self, PyObject * pyfunc, PyObject * data)
"""
return _coin.SoSensorManager_setChangedCallback(self, *args)
def isTimerSensorPending(self, *args):
"""
isTimerSensorPending(SoSensorManager self, SbTime tm) -> SbBool
isTimerSensorPending(SoSensorManager self) -> PyObject *
"""
return _coin.SoSensorManager_isTimerSensorPending(self, *args)
SoSensorManager_swigregister = _coin.SoSensorManager_swigregister
SoSensorManager_swigregister(SoSensorManager)
class SoDB(object):
"""Proxy of C++ SoDB class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def init():
"""init()"""
return _coin.SoDB_init()
init = staticmethod(init)
def finish():
"""finish()"""
return _coin.SoDB_finish()
finish = staticmethod(finish)
def cleanup():
"""cleanup()"""
return _coin.SoDB_cleanup()
cleanup = staticmethod(cleanup)
def getVersion():
"""getVersion() -> char const *"""
return _coin.SoDB_getVersion()
getVersion = staticmethod(getVersion)
def read(*args):
"""
read(SoInput input, SoPath *& path) -> SbBool
read(SoInput input, SoBase *& base) -> SbBool
read(SoInput input, SoNode *& rootnode) -> SbBool
"""
return _coin.SoDB_read(*args)
read = staticmethod(read)
def readAll(input):
"""readAll(SoInput input) -> SoSeparator"""
return _coin.SoDB_readAll(input)
readAll = staticmethod(readAll)
def readAllVRML(input):
"""readAllVRML(SoInput input) -> SoVRMLGroup"""
return _coin.SoDB_readAllVRML(input)
readAllVRML = staticmethod(readAllVRML)
def isValidHeader(teststring):
"""isValidHeader(char const * teststring) -> SbBool"""
return _coin.SoDB_isValidHeader(teststring)
isValidHeader = staticmethod(isValidHeader)
def registerHeader(headerstring, isbinary, ivversion, precallback, postcallback, userdata=None):
"""
registerHeader(SbString headerstring, SbBool isbinary, float ivversion, SoDBHeaderCB * precallback, SoDBHeaderCB * postcallback, void * userdata=None) -> SbBool
registerHeader(SbString headerstring, SbBool isbinary, float ivversion, SoDBHeaderCB * precallback, SoDBHeaderCB * postcallback) -> SbBool
"""
return _coin.SoDB_registerHeader(headerstring, isbinary, ivversion, precallback, postcallback, userdata)
registerHeader = staticmethod(registerHeader)
def getHeaderData(headerstring, isbinary, ivversion, precallback, postcallback, userdata, substringok=0):
"""
getHeaderData(SbString headerstring, SbBool & isbinary, float & ivversion, SoDBHeaderCB *& precallback, SoDBHeaderCB *& postcallback, void *& userdata, SbBool substringok=0) -> SbBool
getHeaderData(SbString headerstring, SbBool & isbinary, float & ivversion, SoDBHeaderCB *& precallback, SoDBHeaderCB *& postcallback, void *& userdata) -> SbBool
"""
return _coin.SoDB_getHeaderData(headerstring, isbinary, ivversion, precallback, postcallback, userdata, substringok)
getHeaderData = staticmethod(getHeaderData)
def getNumHeaders():
"""getNumHeaders() -> int"""
return _coin.SoDB_getNumHeaders()
getNumHeaders = staticmethod(getNumHeaders)
def getHeaderString(i):
"""getHeaderString(int const i) -> SbString"""
return _coin.SoDB_getHeaderString(i)
getHeaderString = staticmethod(getHeaderString)
def createGlobalField(name, type):
"""createGlobalField(SbName name, SoType type) -> SoField"""
return _coin.SoDB_createGlobalField(name, type)
createGlobalField = staticmethod(createGlobalField)
def getGlobalField(name):
"""getGlobalField(SbName name) -> SoField"""
return _coin.SoDB_getGlobalField(name)
getGlobalField = staticmethod(getGlobalField)
def renameGlobalField(arg1, to):
"""renameGlobalField(SbName arg1, SbName to)"""
return _coin.SoDB_renameGlobalField(arg1, to)
renameGlobalField = staticmethod(renameGlobalField)
def setRealTimeInterval(interval):
"""setRealTimeInterval(SbTime interval)"""
return _coin.SoDB_setRealTimeInterval(interval)
setRealTimeInterval = staticmethod(setRealTimeInterval)
def getRealTimeInterval():
"""getRealTimeInterval() -> SbTime"""
return _coin.SoDB_getRealTimeInterval()
getRealTimeInterval = staticmethod(getRealTimeInterval)
def enableRealTimeSensor(on):
"""enableRealTimeSensor(SbBool on)"""
return _coin.SoDB_enableRealTimeSensor(on)
enableRealTimeSensor = staticmethod(enableRealTimeSensor)
def getSensorManager():
"""getSensorManager() -> SoSensorManager"""
return _coin.SoDB_getSensorManager()
getSensorManager = staticmethod(getSensorManager)
def setDelaySensorTimeout(t):
"""setDelaySensorTimeout(SbTime t)"""
return _coin.SoDB_setDelaySensorTimeout(t)
setDelaySensorTimeout = staticmethod(setDelaySensorTimeout)
def getDelaySensorTimeout():
"""getDelaySensorTimeout() -> SbTime"""
return _coin.SoDB_getDelaySensorTimeout()
getDelaySensorTimeout = staticmethod(getDelaySensorTimeout)
def doSelect(nfds, readfds, writefds, exceptfds, usertimeout):
"""doSelect(int nfds, void * readfds, void * writefds, void * exceptfds, timeval * usertimeout) -> int"""
return _coin.SoDB_doSelect(nfds, readfds, writefds, exceptfds, usertimeout)
doSelect = staticmethod(doSelect)
def addConverter(arg1, to, converter):
"""addConverter(SoType arg1, SoType to, SoType converter)"""
return _coin.SoDB_addConverter(arg1, to, converter)
addConverter = staticmethod(addConverter)
def getConverter(arg1, to):
"""getConverter(SoType arg1, SoType to) -> SoType"""
return _coin.SoDB_getConverter(arg1, to)
getConverter = staticmethod(getConverter)
def isInitialized():
"""isInitialized() -> SbBool"""
return _coin.SoDB_isInitialized()
isInitialized = staticmethod(isInitialized)
def startNotify():
"""startNotify()"""
return _coin.SoDB_startNotify()
startNotify = staticmethod(startNotify)
def isNotifying():
"""isNotifying() -> SbBool"""
return _coin.SoDB_isNotifying()
isNotifying = staticmethod(isNotifying)
def endNotify():
"""endNotify()"""
return _coin.SoDB_endNotify()
endNotify = staticmethod(endNotify)
def addProgressCallback(func, userdata):
"""addProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
return _coin.SoDB_addProgressCallback(func, userdata)
addProgressCallback = staticmethod(addProgressCallback)
def removeProgressCallback(func, userdata):
"""removeProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
return _coin.SoDB_removeProgressCallback(func, userdata)
removeProgressCallback = staticmethod(removeProgressCallback)
def isMultiThread():
"""isMultiThread() -> SbBool"""
return _coin.SoDB_isMultiThread()
isMultiThread = staticmethod(isMultiThread)
def readlock():
"""readlock()"""
return _coin.SoDB_readlock()
readlock = staticmethod(readlock)
def readunlock():
"""readunlock()"""
return _coin.SoDB_readunlock()
readunlock = staticmethod(readunlock)
def writelock():
"""writelock()"""
return _coin.SoDB_writelock()
writelock = staticmethod(writelock)
def writeunlock():
"""writeunlock()"""
return _coin.SoDB_writeunlock()
writeunlock = staticmethod(writeunlock)
def createRoute(arg1, eventout, to, eventin):
"""createRoute(SoNode arg1, char const * eventout, SoNode to, char const * eventin)"""
return _coin.SoDB_createRoute(arg1, eventout, to, eventin)
createRoute = staticmethod(createRoute)
def removeRoute(arg1, eventout, to, eventin):
"""removeRoute(SoNode arg1, char const * eventout, SoNode to, char const * eventin)"""
return _coin.SoDB_removeRoute(arg1, eventout, to, eventin)
removeRoute = staticmethod(removeRoute)
def __init__(self):
"""__init__(SoDB self) -> SoDB"""
this = _coin.new_SoDB()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoDB
__del__ = lambda self: None
SoDB_swigregister = _coin.SoDB_swigregister
SoDB_swigregister(SoDB)
def SoDB_init():
"""SoDB_init()"""
return _coin.SoDB_init()
def SoDB_finish():
"""SoDB_finish()"""
return _coin.SoDB_finish()
def SoDB_cleanup():
"""SoDB_cleanup()"""
return _coin.SoDB_cleanup()
def SoDB_getVersion():
"""SoDB_getVersion() -> char const *"""
return _coin.SoDB_getVersion()
def SoDB_read(*args):
"""
read(SoInput input, SoPath *& path) -> SbBool
read(SoInput input, SoBase *& base) -> SbBool
SoDB_read(SoInput input, SoNode *& rootnode) -> SbBool
"""
return _coin.SoDB_read(*args)
def SoDB_readAll(input):
"""SoDB_readAll(SoInput input) -> SoSeparator"""
return _coin.SoDB_readAll(input)
def SoDB_readAllVRML(input):
"""SoDB_readAllVRML(SoInput input) -> SoVRMLGroup"""
return _coin.SoDB_readAllVRML(input)
def SoDB_isValidHeader(teststring):
"""SoDB_isValidHeader(char const * teststring) -> SbBool"""
return _coin.SoDB_isValidHeader(teststring)
def SoDB_registerHeader(headerstring, isbinary, ivversion, precallback, postcallback, userdata=None):
"""
registerHeader(SbString headerstring, SbBool isbinary, float ivversion, SoDBHeaderCB * precallback, SoDBHeaderCB * postcallback, void * userdata=None) -> SbBool
SoDB_registerHeader(SbString headerstring, SbBool isbinary, float ivversion, SoDBHeaderCB * precallback, SoDBHeaderCB * postcallback) -> SbBool
"""
return _coin.SoDB_registerHeader(headerstring, isbinary, ivversion, precallback, postcallback, userdata)
def SoDB_getHeaderData(headerstring, isbinary, ivversion, precallback, postcallback, userdata, substringok=0):
"""
getHeaderData(SbString headerstring, SbBool & isbinary, float & ivversion, SoDBHeaderCB *& precallback, SoDBHeaderCB *& postcallback, void *& userdata, SbBool substringok=0) -> SbBool
SoDB_getHeaderData(SbString headerstring, SbBool & isbinary, float & ivversion, SoDBHeaderCB *& precallback, SoDBHeaderCB *& postcallback, void *& userdata) -> SbBool
"""
return _coin.SoDB_getHeaderData(headerstring, isbinary, ivversion, precallback, postcallback, userdata, substringok)
def SoDB_getNumHeaders():
"""SoDB_getNumHeaders() -> int"""
return _coin.SoDB_getNumHeaders()
def SoDB_getHeaderString(i):
"""SoDB_getHeaderString(int const i) -> SbString"""
return _coin.SoDB_getHeaderString(i)
def SoDB_createGlobalField(name, type):
"""SoDB_createGlobalField(SbName name, SoType type) -> SoField"""
return _coin.SoDB_createGlobalField(name, type)
def SoDB_getGlobalField(name):
"""SoDB_getGlobalField(SbName name) -> SoField"""
return _coin.SoDB_getGlobalField(name)
def SoDB_renameGlobalField(arg2, to):
"""SoDB_renameGlobalField(SbName arg2, SbName to)"""
return _coin.SoDB_renameGlobalField(arg2, to)
def SoDB_setRealTimeInterval(interval):
"""SoDB_setRealTimeInterval(SbTime interval)"""
return _coin.SoDB_setRealTimeInterval(interval)
def SoDB_getRealTimeInterval():
"""SoDB_getRealTimeInterval() -> SbTime"""
return _coin.SoDB_getRealTimeInterval()
def SoDB_enableRealTimeSensor(on):
"""SoDB_enableRealTimeSensor(SbBool on)"""
return _coin.SoDB_enableRealTimeSensor(on)
def SoDB_getSensorManager():
"""SoDB_getSensorManager() -> SoSensorManager"""
return _coin.SoDB_getSensorManager()
def SoDB_setDelaySensorTimeout(t):
"""SoDB_setDelaySensorTimeout(SbTime t)"""
return _coin.SoDB_setDelaySensorTimeout(t)
def SoDB_getDelaySensorTimeout():
"""SoDB_getDelaySensorTimeout() -> SbTime"""
return _coin.SoDB_getDelaySensorTimeout()
def SoDB_doSelect(nfds, readfds, writefds, exceptfds, usertimeout):
"""SoDB_doSelect(int nfds, void * readfds, void * writefds, void * exceptfds, timeval * usertimeout) -> int"""
return _coin.SoDB_doSelect(nfds, readfds, writefds, exceptfds, usertimeout)
def SoDB_addConverter(arg2, to, converter):
"""SoDB_addConverter(SoType arg2, SoType to, SoType converter)"""
return _coin.SoDB_addConverter(arg2, to, converter)
def SoDB_getConverter(arg2, to):
"""SoDB_getConverter(SoType arg2, SoType to) -> SoType"""
return _coin.SoDB_getConverter(arg2, to)
def SoDB_isInitialized():
"""SoDB_isInitialized() -> SbBool"""
return _coin.SoDB_isInitialized()
def SoDB_startNotify():
"""SoDB_startNotify()"""
return _coin.SoDB_startNotify()
def SoDB_isNotifying():
"""SoDB_isNotifying() -> SbBool"""
return _coin.SoDB_isNotifying()
def SoDB_endNotify():
"""SoDB_endNotify()"""
return _coin.SoDB_endNotify()
def SoDB_addProgressCallback(func, userdata):
"""SoDB_addProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
return _coin.SoDB_addProgressCallback(func, userdata)
def SoDB_removeProgressCallback(func, userdata):
"""SoDB_removeProgressCallback(SoDB::ProgressCallbackType * func, void * userdata)"""
return _coin.SoDB_removeProgressCallback(func, userdata)
def SoDB_isMultiThread():
"""SoDB_isMultiThread() -> SbBool"""
return _coin.SoDB_isMultiThread()
def SoDB_readlock():
"""SoDB_readlock()"""
return _coin.SoDB_readlock()
def SoDB_readunlock():
"""SoDB_readunlock()"""
return _coin.SoDB_readunlock()
def SoDB_writelock():
"""SoDB_writelock()"""
return _coin.SoDB_writelock()
def SoDB_writeunlock():
"""SoDB_writeunlock()"""
return _coin.SoDB_writeunlock()
def SoDB_createRoute(arg2, eventout, to, eventin):
"""SoDB_createRoute(SoNode arg2, char const * eventout, SoNode to, char const * eventin)"""
return _coin.SoDB_createRoute(arg2, eventout, to, eventin)
def SoDB_removeRoute(arg2, eventout, to, eventin):
"""SoDB_removeRoute(SoNode arg2, char const * eventout, SoNode to, char const * eventin)"""
return _coin.SoDB_removeRoute(arg2, eventout, to, eventin)
class SoInput(object):
"""Proxy of C++ SoInput class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoInput self) -> SoInput
__init__(SoInput self, SoInput dictIn) -> SoInput
"""
this = _coin.new_SoInput(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def findProto(self, name):
"""findProto(SoInput self, SbName name) -> SoProto"""
return _coin.SoInput_findProto(self, name)
def addProto(self, proto):
"""addProto(SoInput self, SoProto proto)"""
return _coin.SoInput_addProto(self, proto)
def pushProto(self, proto):
"""pushProto(SoInput self, SoProto proto)"""
return _coin.SoInput_pushProto(self, proto)
def getCurrentProto(self):
"""getCurrentProto(SoInput self) -> SoProto"""
return _coin.SoInput_getCurrentProto(self)
def popProto(self):
"""popProto(SoInput self)"""
return _coin.SoInput_popProto(self)
def addRoute(self, fromnode, fromfield, tonode, tofield):
"""addRoute(SoInput self, SbName fromnode, SbName fromfield, SbName tonode, SbName tofield)"""
return _coin.SoInput_addRoute(self, fromnode, fromfield, tonode, tofield)
def checkISReference(self, container, fieldname, readok):
"""checkISReference(SoInput self, SoFieldContainer container, SbName fieldname, SbBool & readok) -> SbBool"""
return _coin.SoInput_checkISReference(self, container, fieldname, readok)
__swig_destroy__ = _coin.delete_SoInput
__del__ = lambda self: None
def setFilePointer(self, newFP):
"""setFilePointer(SoInput self, FILE * newFP)"""
return _coin.SoInput_setFilePointer(self, newFP)
def openFile(self, fileName, okIfNotFound=0):
"""
openFile(SoInput self, char const * fileName, SbBool okIfNotFound=0) -> SbBool
openFile(SoInput self, char const * fileName) -> SbBool
"""
return _coin.SoInput_openFile(self, fileName, okIfNotFound)
def pushFile(self, fileName):
"""pushFile(SoInput self, char const * fileName) -> SbBool"""
return _coin.SoInput_pushFile(self, fileName)
def closeFile(self):
"""closeFile(SoInput self)"""
return _coin.SoInput_closeFile(self)
def isValidFile(self):
"""isValidFile(SoInput self) -> SbBool"""
return _coin.SoInput_isValidFile(self)
def isValidBuffer(self):
"""isValidBuffer(SoInput self) -> SbBool"""
return _coin.SoInput_isValidBuffer(self)
def getCurFile(self):
"""getCurFile(SoInput self) -> FILE *"""
return _coin.SoInput_getCurFile(self)
def getCurFileName(self):
"""getCurFileName(SoInput self) -> char const *"""
return _coin.SoInput_getCurFileName(self)
def setBuffer(self, bufpointer):
"""setBuffer(SoInput self, void const * bufpointer)"""
return _coin.SoInput_setBuffer(self, bufpointer)
def setStringArray(self, strings):
"""setStringArray(SoInput self, char const *[] strings)"""
return _coin.SoInput_setStringArray(self, strings)
def getNumBytesRead(self):
"""getNumBytesRead(SoInput self) -> size_t"""
return _coin.SoInput_getNumBytesRead(self)
def getHeader(self):
"""getHeader(SoInput self) -> SbString"""
return _coin.SoInput_getHeader(self)
def getIVVersion(self):
"""getIVVersion(SoInput self) -> float"""
return _coin.SoInput_getIVVersion(self)
def isBinary(self):
"""isBinary(SoInput self) -> SbBool"""
return _coin.SoInput_isBinary(self)
def get(self, c):
"""get(SoInput self, char & c) -> SbBool"""
return _coin.SoInput_get(self, c)
def getASCIIBuffer(self, c):
"""getASCIIBuffer(SoInput self, char & c) -> SbBool"""
return _coin.SoInput_getASCIIBuffer(self, c)
def getASCIIFile(self, c):
"""getASCIIFile(SoInput self, char & c) -> SbBool"""
return _coin.SoInput_getASCIIFile(self, c)
def readHex(self, l):
"""readHex(SoInput self, uint32_t & l) -> SbBool"""
return _coin.SoInput_readHex(self, l)
def read(self, *args):
"""
read(SoInput self, char & c) -> SbBool
read(SoInput self, char & c, SbBool skip) -> SbBool
read(SoInput self, SbString s) -> SbBool
read(SoInput self, SbName n, SbBool validIdent=0) -> SbBool
read(SoInput self, SbName n) -> SbBool
read(SoInput self, int & i) -> SbBool
read(SoInput self, unsigned int & i) -> SbBool
read(SoInput self, short & s) -> SbBool
read(SoInput self, unsigned short & s) -> SbBool
read(SoInput self, float & f) -> SbBool
read(SoInput self, double & d) -> SbBool
"""
return _coin.SoInput_read(self, *args)
def readByte(self, *args):
"""
readByte(SoInput self, int8_t & b) -> SbBool
readByte(SoInput self, uint8_t & b) -> SbBool
"""
return _coin.SoInput_readByte(self, *args)
def readBinaryArray(self, *args):
"""
readBinaryArray(SoInput self, unsigned char * c, int length) -> SbBool
readBinaryArray(SoInput self, int32_t * l, int length) -> SbBool
readBinaryArray(SoInput self, float * f, int length) -> SbBool
readBinaryArray(SoInput self, double * d, int length) -> SbBool
"""
return _coin.SoInput_readBinaryArray(self, *args)
def eof(self):
"""eof(SoInput self) -> SbBool"""
return _coin.SoInput_eof(self)
def isFileVRML1(self):
"""isFileVRML1(SoInput self) -> SbBool"""
return _coin.SoInput_isFileVRML1(self)
def isFileVRML2(self):
"""isFileVRML2(SoInput self) -> SbBool"""
return _coin.SoInput_isFileVRML2(self)
def resetFilePointer(self, fptr):
"""resetFilePointer(SoInput self, FILE * fptr)"""
return _coin.SoInput_resetFilePointer(self, fptr)
def getLocationString(self, string):
"""getLocationString(SoInput self, SbString string)"""
return _coin.SoInput_getLocationString(self, string)
def putBack(self, *args):
"""
putBack(SoInput self, char const c)
putBack(SoInput self, char const * str)
"""
return _coin.SoInput_putBack(self, *args)
def addReference(self, name, base, addToGlobalDict=1):
"""
addReference(SoInput self, SbName name, SoBase base, SbBool addToGlobalDict=1)
addReference(SoInput self, SbName name, SoBase base)
"""
return _coin.SoInput_addReference(self, name, base, addToGlobalDict)
def removeReference(self, name):
"""removeReference(SoInput self, SbName name)"""
return _coin.SoInput_removeReference(self, name)
def findReference(self, name):
"""findReference(SoInput self, SbName name) -> SoBase"""
return _coin.SoInput_findReference(self, name)
def addDirectoryFirst(dirName):
"""addDirectoryFirst(char const * dirName)"""
return _coin.SoInput_addDirectoryFirst(dirName)
addDirectoryFirst = staticmethod(addDirectoryFirst)
def addDirectoryLast(dirName):
"""addDirectoryLast(char const * dirName)"""
return _coin.SoInput_addDirectoryLast(dirName)
addDirectoryLast = staticmethod(addDirectoryLast)
def addEnvDirectoriesFirst(*args):
"""
addEnvDirectoriesFirst(char const * envVarName, char const * separator)
addEnvDirectoriesFirst(char const * envVarName)
"""
return _coin.SoInput_addEnvDirectoriesFirst(*args)
addEnvDirectoriesFirst = staticmethod(addEnvDirectoriesFirst)
def addEnvDirectoriesLast(*args):
"""
addEnvDirectoriesLast(char const * envVarName, char const * separator)
addEnvDirectoriesLast(char const * envVarName)
"""
return _coin.SoInput_addEnvDirectoriesLast(*args)
addEnvDirectoriesLast = staticmethod(addEnvDirectoriesLast)
def removeDirectory(dirName):
"""removeDirectory(char const * dirName)"""
return _coin.SoInput_removeDirectory(dirName)
removeDirectory = staticmethod(removeDirectory)
def clearDirectories():
"""clearDirectories()"""
return _coin.SoInput_clearDirectories()
clearDirectories = staticmethod(clearDirectories)
def getDirectories():
"""getDirectories() -> SbStringList"""
return _coin.SoInput_getDirectories()
getDirectories = staticmethod(getDirectories)
def init():
"""init()"""
return _coin.SoInput_init()
init = staticmethod(init)
def getPathname(*args):
"""
getPathname(char const *const filename) -> SbString
getPathname(SbString s) -> SbString
"""
return _coin.SoInput_getPathname(*args)
getPathname = staticmethod(getPathname)
def getBasename(*args):
"""
getBasename(char const *const filename) -> SbString
getBasename(SbString s) -> SbString
"""
return _coin.SoInput_getBasename(*args)
getBasename = staticmethod(getBasename)
def searchForFile(basename, directories, subdirectories):
"""searchForFile(SbString basename, SbStringList directories, SbStringList subdirectories) -> SbString"""
return _coin.SoInput_searchForFile(basename, directories, subdirectories)
searchForFile = staticmethod(searchForFile)
SoInput_swigregister = _coin.SoInput_swigregister
SoInput_swigregister(SoInput)
def SoInput_addDirectoryFirst(dirName):
"""SoInput_addDirectoryFirst(char const * dirName)"""
return _coin.SoInput_addDirectoryFirst(dirName)
def SoInput_addDirectoryLast(dirName):
"""SoInput_addDirectoryLast(char const * dirName)"""
return _coin.SoInput_addDirectoryLast(dirName)
def SoInput_addEnvDirectoriesFirst(*args):
"""
addEnvDirectoriesFirst(char const * envVarName, char const * separator)
SoInput_addEnvDirectoriesFirst(char const * envVarName)
"""
return _coin.SoInput_addEnvDirectoriesFirst(*args)
def SoInput_addEnvDirectoriesLast(*args):
"""
addEnvDirectoriesLast(char const * envVarName, char const * separator)
SoInput_addEnvDirectoriesLast(char const * envVarName)
"""
return _coin.SoInput_addEnvDirectoriesLast(*args)
def SoInput_removeDirectory(dirName):
"""SoInput_removeDirectory(char const * dirName)"""
return _coin.SoInput_removeDirectory(dirName)
def SoInput_clearDirectories():
"""SoInput_clearDirectories()"""
return _coin.SoInput_clearDirectories()
def SoInput_getDirectories():
"""SoInput_getDirectories() -> SbStringList"""
return _coin.SoInput_getDirectories()
def SoInput_init():
"""SoInput_init()"""
return _coin.SoInput_init()
def SoInput_getPathname(*args):
"""
getPathname(char const *const filename) -> SbString
SoInput_getPathname(SbString s) -> SbString
"""
return _coin.SoInput_getPathname(*args)
def SoInput_getBasename(*args):
"""
getBasename(char const *const filename) -> SbString
SoInput_getBasename(SbString s) -> SbString
"""
return _coin.SoInput_getBasename(*args)
def SoInput_searchForFile(basename, directories, subdirectories):
"""SoInput_searchForFile(SbString basename, SbStringList directories, SbStringList subdirectories) -> SbString"""
return _coin.SoInput_searchForFile(basename, directories, subdirectories)
class SoOutput(object):
"""Proxy of C++ SoOutput class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
COUNT_REFS = _coin.SoOutput_COUNT_REFS
WRITE = _coin.SoOutput_WRITE
ADDRESSES = _coin.SoOutput_ADDRESSES
REF_COUNTS = _coin.SoOutput_REF_COUNTS
def __init__(self, *args):
"""
__init__(SoOutput self) -> SoOutput
__init__(SoOutput self, SoOutput dictOut) -> SoOutput
"""
this = _coin.new_SoOutput(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoOutput
__del__ = lambda self: None
def setFilePointer(self, newFP):
"""setFilePointer(SoOutput self, FILE * newFP)"""
return _coin.SoOutput_setFilePointer(self, newFP)
def getFilePointer(self):
"""getFilePointer(SoOutput self) -> FILE *"""
return _coin.SoOutput_getFilePointer(self)
def openFile(self, fileName):
"""openFile(SoOutput self, char const *const fileName) -> SbBool"""
return _coin.SoOutput_openFile(self, fileName)
def closeFile(self):
"""closeFile(SoOutput self)"""
return _coin.SoOutput_closeFile(self)
def setCompression(self, compmethod, level=0.5):
"""
setCompression(SoOutput self, SbName compmethod, float const level=0.5) -> SbBool
setCompression(SoOutput self, SbName compmethod) -> SbBool
"""
return _coin.SoOutput_setCompression(self, compmethod, level)
def getAvailableCompressionMethods(num):
"""getAvailableCompressionMethods(unsigned int & num) -> SbName"""
return _coin.SoOutput_getAvailableCompressionMethods(num)
getAvailableCompressionMethods = staticmethod(getAvailableCompressionMethods)
def setBuffer(self, bufPointer, initSize, reallocFunc, offset=0):
"""
setBuffer(SoOutput self, void * bufPointer, size_t initSize, SoOutputReallocCB * reallocFunc, int32_t offset=0)
setBuffer(SoOutput self, void * bufPointer, size_t initSize, SoOutputReallocCB * reallocFunc)
"""
return _coin.SoOutput_setBuffer(self, bufPointer, initSize, reallocFunc, offset)
def getBuffer(self, bufPointer, nBytes):
"""getBuffer(SoOutput self, void *& bufPointer, size_t & nBytes) -> SbBool"""
return _coin.SoOutput_getBuffer(self, bufPointer, nBytes)
def getBufferSize(self):
"""getBufferSize(SoOutput self) -> size_t"""
return _coin.SoOutput_getBufferSize(self)
def resetBuffer(self):
"""resetBuffer(SoOutput self)"""
return _coin.SoOutput_resetBuffer(self)
def setBinary(self, flag):
"""setBinary(SoOutput self, SbBool const flag)"""
return _coin.SoOutput_setBinary(self, flag)
def isBinary(self):
"""isBinary(SoOutput self) -> SbBool"""
return _coin.SoOutput_isBinary(self)
def setHeaderString(self, str):
"""setHeaderString(SoOutput self, SbString str)"""
return _coin.SoOutput_setHeaderString(self, str)
def resetHeaderString(self):
"""resetHeaderString(SoOutput self)"""
return _coin.SoOutput_resetHeaderString(self)
def setFloatPrecision(self, precision):
"""setFloatPrecision(SoOutput self, int const precision)"""
return _coin.SoOutput_setFloatPrecision(self, precision)
def setStage(self, stage):
"""setStage(SoOutput self, SoOutput::Stage stage)"""
return _coin.SoOutput_setStage(self, stage)
def getStage(self):
"""getStage(SoOutput self) -> SoOutput::Stage"""
return _coin.SoOutput_getStage(self)
def incrementIndent(self, levels=1):
"""
incrementIndent(SoOutput self, int const levels=1)
incrementIndent(SoOutput self)
"""
return _coin.SoOutput_incrementIndent(self, levels)
def decrementIndent(self, levels=1):
"""
decrementIndent(SoOutput self, int const levels=1)
decrementIndent(SoOutput self)
"""
return _coin.SoOutput_decrementIndent(self, levels)
def write(self, *args):
"""
write(SoOutput self, char const c)
write(SoOutput self, char const * s)
write(SoOutput self, SbString s)
write(SoOutput self, SbName n)
write(SoOutput self, int const i)
write(SoOutput self, unsigned int const i)
write(SoOutput self, short const s)
write(SoOutput self, unsigned short const s)
write(SoOutput self, float const f)
write(SoOutput self, double const d)
"""
return _coin.SoOutput_write(self, *args)
def writeBinaryArray(self, *args):
"""
writeBinaryArray(SoOutput self, unsigned char const * c, int const length)
writeBinaryArray(SoOutput self, int32_t const *const l, int const length)
writeBinaryArray(SoOutput self, float const *const f, int const length)
writeBinaryArray(SoOutput self, double const *const d, int const length)
"""
return _coin.SoOutput_writeBinaryArray(self, *args)
def indent(self):
"""indent(SoOutput self)"""
return _coin.SoOutput_indent(self)
def reset(self):
"""reset(SoOutput self)"""
return _coin.SoOutput_reset(self)
def setCompact(self, flag):
"""setCompact(SoOutput self, SbBool flag)"""
return _coin.SoOutput_setCompact(self, flag)
def isCompact(self):
"""isCompact(SoOutput self) -> SbBool"""
return _coin.SoOutput_isCompact(self)
def setAnnotation(self, bits):
"""setAnnotation(SoOutput self, uint32_t bits)"""
return _coin.SoOutput_setAnnotation(self, bits)
def getAnnotation(self):
"""getAnnotation(SoOutput self) -> uint32_t"""
return _coin.SoOutput_getAnnotation(self)
def getDefaultASCIIHeader():
"""getDefaultASCIIHeader() -> SbString"""
return _coin.SoOutput_getDefaultASCIIHeader()
getDefaultASCIIHeader = staticmethod(getDefaultASCIIHeader)
def getDefaultBinaryHeader():
"""getDefaultBinaryHeader() -> SbString"""
return _coin.SoOutput_getDefaultBinaryHeader()
getDefaultBinaryHeader = staticmethod(getDefaultBinaryHeader)
def addReference(self, base):
"""addReference(SoOutput self, SoBase base) -> int"""
return _coin.SoOutput_addReference(self, base)
def findReference(self, base):
"""findReference(SoOutput self, SoBase base) -> int"""
return _coin.SoOutput_findReference(self, base)
def setReference(self, base, refid):
"""setReference(SoOutput self, SoBase base, int refid)"""
return _coin.SoOutput_setReference(self, base, refid)
def addDEFNode(self, name):
"""addDEFNode(SoOutput self, SbName name)"""
return _coin.SoOutput_addDEFNode(self, name)
def lookupDEFNode(self, name):
"""lookupDEFNode(SoOutput self, SbName name) -> SbBool"""
return _coin.SoOutput_lookupDEFNode(self, name)
def removeDEFNode(self, name):
"""removeDEFNode(SoOutput self, SbName name)"""
return _coin.SoOutput_removeDEFNode(self, name)
def pushProto(self, proto):
"""pushProto(SoOutput self, SoProto proto)"""
return _coin.SoOutput_pushProto(self, proto)
def getCurrentProto(self):
"""getCurrentProto(SoOutput self) -> SoProto"""
return _coin.SoOutput_getCurrentProto(self)
def popProto(self):
"""popProto(SoOutput self)"""
return _coin.SoOutput_popProto(self)
def addRoute(self, arg2, fromfield, to, tofield):
"""addRoute(SoOutput self, SoFieldContainer arg2, SbName fromfield, SoFieldContainer to, SbName tofield)"""
return _coin.SoOutput_addRoute(self, arg2, fromfield, to, tofield)
def resolveRoutes(self):
"""resolveRoutes(SoOutput self)"""
return _coin.SoOutput_resolveRoutes(self)
SoOutput_swigregister = _coin.SoOutput_swigregister
SoOutput_swigregister(SoOutput)
def SoOutput_getAvailableCompressionMethods(num):
"""SoOutput_getAvailableCompressionMethods(unsigned int & num) -> SbName"""
return _coin.SoOutput_getAvailableCompressionMethods(num)
def SoOutput_getDefaultASCIIHeader():
"""SoOutput_getDefaultASCIIHeader() -> SbString"""
return _coin.SoOutput_getDefaultASCIIHeader()
def SoOutput_getDefaultBinaryHeader():
"""SoOutput_getDefaultBinaryHeader() -> SbString"""
return _coin.SoOutput_getDefaultBinaryHeader()
class SoSFEnum(SoSField):
"""Proxy of C++ SoSFEnum class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFEnum self) -> SoSFEnum"""
this = _coin.new_SoSFEnum()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFEnum
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFEnum_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFEnum_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFEnum self) -> SoType"""
return _coin.SoSFEnum_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFEnum self, SoField field)"""
return _coin.SoSFEnum_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFEnum self, SoField field) -> SbBool"""
return _coin.SoSFEnum_isSame(self, field)
def getValue(self):
"""getValue(SoSFEnum self) -> int"""
return _coin.SoSFEnum_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFEnum self, SoSFEnum field) -> int"""
return _coin.SoSFEnum___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFEnum self, SoSFEnum field) -> int"""
return _coin.SoSFEnum___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFEnum_initClass()
initClass = staticmethod(initClass)
def setEnums(self, num, vals, names):
"""setEnums(SoSFEnum self, int const num, int const * vals, SbName names)"""
return _coin.SoSFEnum_setEnums(self, num, vals, names)
def getNumEnums(self):
"""getNumEnums(SoSFEnum self) -> int"""
return _coin.SoSFEnum_getNumEnums(self)
def getEnum(self, idx, name):
"""getEnum(SoSFEnum self, int const idx, SbName name) -> int"""
return _coin.SoSFEnum_getEnum(self, idx, name)
def setValue(self, *args):
"""
setValue(SoSFEnum self, int newvalue)
setValue(SoSFEnum self, SbName name)
setValue(SoSFEnum self, SoSFEnum other)
"""
return _coin.SoSFEnum_setValue(self, *args)
SoSFEnum_swigregister = _coin.SoSFEnum_swigregister
SoSFEnum_swigregister(SoSFEnum)
def SoSFEnum_createInstance():
"""SoSFEnum_createInstance() -> void *"""
return _coin.SoSFEnum_createInstance()
def SoSFEnum_getClassTypeId():
"""SoSFEnum_getClassTypeId() -> SoType"""
return _coin.SoSFEnum_getClassTypeId()
def SoSFEnum_initClass():
"""SoSFEnum_initClass()"""
return _coin.SoSFEnum_initClass()
class SoSFFloat(SoSField):
"""Proxy of C++ SoSFFloat class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFFloat self) -> SoSFFloat"""
this = _coin.new_SoSFFloat()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFFloat
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFFloat_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFFloat_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFFloat self) -> SoType"""
return _coin.SoSFFloat_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFFloat self, SoField field)"""
return _coin.SoSFFloat_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFFloat self, SoField field) -> SbBool"""
return _coin.SoSFFloat_isSame(self, field)
def getValue(self):
"""getValue(SoSFFloat self) -> float"""
return _coin.SoSFFloat_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFFloat self, SoSFFloat field) -> int"""
return _coin.SoSFFloat___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFFloat self, SoSFFloat field) -> int"""
return _coin.SoSFFloat___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFFloat_initClass()
initClass = staticmethod(initClass)
def setValue(self, *args):
"""
setValue(SoSFFloat self, float newvalue)
setValue(SoSFFloat self, SoSFFloat other)
"""
return _coin.SoSFFloat_setValue(self, *args)
SoSFFloat_swigregister = _coin.SoSFFloat_swigregister
SoSFFloat_swigregister(SoSFFloat)
def SoSFFloat_createInstance():
"""SoSFFloat_createInstance() -> void *"""
return _coin.SoSFFloat_createInstance()
def SoSFFloat_getClassTypeId():
"""SoSFFloat_getClassTypeId() -> SoType"""
return _coin.SoSFFloat_getClassTypeId()
def SoSFFloat_initClass():
"""SoSFFloat_initClass()"""
return _coin.SoSFFloat_initClass()
class SoComplexityTypeElement(SoInt32Element):
"""Proxy of C++ SoComplexityTypeElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoComplexityTypeElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoComplexityTypeElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoComplexityTypeElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoComplexityTypeElement_initClass()
initClass = staticmethod(initClass)
OBJECT_SPACE = _coin.SoComplexityTypeElement_OBJECT_SPACE
SCREEN_SPACE = _coin.SoComplexityTypeElement_SCREEN_SPACE
BOUNDING_BOX = _coin.SoComplexityTypeElement_BOUNDING_BOX
def init(self, state):
"""init(SoComplexityTypeElement self, SoState state)"""
return _coin.SoComplexityTypeElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, SoComplexityTypeElement::Type const type)
set(SoState state, SoComplexityTypeElement::Type const type)
"""
return _coin.SoComplexityTypeElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SoComplexityTypeElement::Type"""
return _coin.SoComplexityTypeElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SoComplexityTypeElement::Type"""
return _coin.SoComplexityTypeElement_getDefault()
getDefault = staticmethod(getDefault)
SoComplexityTypeElement_swigregister = _coin.SoComplexityTypeElement_swigregister
SoComplexityTypeElement_swigregister(SoComplexityTypeElement)
def SoComplexityTypeElement_getClassTypeId():
"""SoComplexityTypeElement_getClassTypeId() -> SoType"""
return _coin.SoComplexityTypeElement_getClassTypeId()
def SoComplexityTypeElement_getClassStackIndex():
"""SoComplexityTypeElement_getClassStackIndex() -> int"""
return _coin.SoComplexityTypeElement_getClassStackIndex()
def SoComplexityTypeElement_createInstance():
"""SoComplexityTypeElement_createInstance() -> void *"""
return _coin.SoComplexityTypeElement_createInstance()
def SoComplexityTypeElement_initClass():
"""SoComplexityTypeElement_initClass()"""
return _coin.SoComplexityTypeElement_initClass()
def SoComplexityTypeElement_set(*args):
"""
set(SoState state, SoNode node, SoComplexityTypeElement::Type const type)
SoComplexityTypeElement_set(SoState state, SoComplexityTypeElement::Type const type)
"""
return _coin.SoComplexityTypeElement_set(*args)
def SoComplexityTypeElement_get(state):
"""SoComplexityTypeElement_get(SoState state) -> SoComplexityTypeElement::Type"""
return _coin.SoComplexityTypeElement_get(state)
def SoComplexityTypeElement_getDefault():
"""SoComplexityTypeElement_getDefault() -> SoComplexityTypeElement::Type"""
return _coin.SoComplexityTypeElement_getDefault()
class SoComplexity(SoNode):
"""Proxy of C++ SoComplexity class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoComplexity_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoComplexity self) -> SoType"""
return _coin.SoComplexity_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoComplexity_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoComplexity self) -> SoComplexity"""
this = _coin.new_SoComplexity()
try:
self.this.append(this)
except Exception:
self.this = this
OBJECT_SPACE = _coin.SoComplexity_OBJECT_SPACE
SCREEN_SPACE = _coin.SoComplexity_SCREEN_SPACE
BOUNDING_BOX = _coin.SoComplexity_BOUNDING_BOX
type = _swig_property(_coin.SoComplexity_type_get, _coin.SoComplexity_type_set)
value = _swig_property(_coin.SoComplexity_value_get, _coin.SoComplexity_value_set)
textureQuality = _swig_property(_coin.SoComplexity_textureQuality_get, _coin.SoComplexity_textureQuality_set)
def doAction(self, action):
"""doAction(SoComplexity self, SoAction action)"""
return _coin.SoComplexity_doAction(self, action)
def callback(self, action):
"""callback(SoComplexity self, SoCallbackAction action)"""
return _coin.SoComplexity_callback(self, action)
def getBoundingBox(self, action):
"""getBoundingBox(SoComplexity self, SoGetBoundingBoxAction action)"""
return _coin.SoComplexity_getBoundingBox(self, action)
def GLRender(self, action):
"""GLRender(SoComplexity self, SoGLRenderAction action)"""
return _coin.SoComplexity_GLRender(self, action)
def pick(self, action):
"""pick(SoComplexity self, SoPickAction action)"""
return _coin.SoComplexity_pick(self, action)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoComplexity self, SoGetPrimitiveCountAction action)"""
return _coin.SoComplexity_getPrimitiveCount(self, action)
SoComplexity_swigregister = _coin.SoComplexity_swigregister
SoComplexity_swigregister(SoComplexity)
def SoComplexity_getClassTypeId():
"""SoComplexity_getClassTypeId() -> SoType"""
return _coin.SoComplexity_getClassTypeId()
def SoComplexity_initClass():
"""SoComplexity_initClass()"""
return _coin.SoComplexity_initClass()
class SoDrawStyleElement(SoInt32Element):
"""Proxy of C++ SoDrawStyleElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoDrawStyleElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoDrawStyleElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoDrawStyleElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoDrawStyleElement_initClass()
initClass = staticmethod(initClass)
FILLED = _coin.SoDrawStyleElement_FILLED
LINES = _coin.SoDrawStyleElement_LINES
POINTS = _coin.SoDrawStyleElement_POINTS
INVISIBLE = _coin.SoDrawStyleElement_INVISIBLE
def init(self, state):
"""init(SoDrawStyleElement self, SoState state)"""
return _coin.SoDrawStyleElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, SoDrawStyleElement::Style const style)
set(SoState state, SoDrawStyleElement::Style const style)
"""
return _coin.SoDrawStyleElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SoDrawStyleElement::Style"""
return _coin.SoDrawStyleElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SoDrawStyleElement::Style"""
return _coin.SoDrawStyleElement_getDefault()
getDefault = staticmethod(getDefault)
SoDrawStyleElement_swigregister = _coin.SoDrawStyleElement_swigregister
SoDrawStyleElement_swigregister(SoDrawStyleElement)
def SoDrawStyleElement_getClassTypeId():
"""SoDrawStyleElement_getClassTypeId() -> SoType"""
return _coin.SoDrawStyleElement_getClassTypeId()
def SoDrawStyleElement_getClassStackIndex():
"""SoDrawStyleElement_getClassStackIndex() -> int"""
return _coin.SoDrawStyleElement_getClassStackIndex()
def SoDrawStyleElement_createInstance():
"""SoDrawStyleElement_createInstance() -> void *"""
return _coin.SoDrawStyleElement_createInstance()
def SoDrawStyleElement_initClass():
"""SoDrawStyleElement_initClass()"""
return _coin.SoDrawStyleElement_initClass()
def SoDrawStyleElement_set(*args):
"""
set(SoState state, SoNode node, SoDrawStyleElement::Style const style)
SoDrawStyleElement_set(SoState state, SoDrawStyleElement::Style const style)
"""
return _coin.SoDrawStyleElement_set(*args)
def SoDrawStyleElement_get(state):
"""SoDrawStyleElement_get(SoState state) -> SoDrawStyleElement::Style"""
return _coin.SoDrawStyleElement_get(state)
def SoDrawStyleElement_getDefault():
"""SoDrawStyleElement_getDefault() -> SoDrawStyleElement::Style"""
return _coin.SoDrawStyleElement_getDefault()
class SoSFUShort(SoSField):
"""Proxy of C++ SoSFUShort class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFUShort self) -> SoSFUShort"""
this = _coin.new_SoSFUShort()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFUShort
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFUShort_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFUShort_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFUShort self) -> SoType"""
return _coin.SoSFUShort_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFUShort self, SoField field)"""
return _coin.SoSFUShort_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFUShort self, SoField field) -> SbBool"""
return _coin.SoSFUShort_isSame(self, field)
def getValue(self):
"""getValue(SoSFUShort self) -> unsigned short"""
return _coin.SoSFUShort_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFUShort self, SoSFUShort field) -> int"""
return _coin.SoSFUShort___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFUShort self, SoSFUShort field) -> int"""
return _coin.SoSFUShort___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFUShort_initClass()
initClass = staticmethod(initClass)
def setValue(self, *args):
"""
setValue(SoSFUShort self, unsigned short newvalue)
setValue(SoSFUShort self, SoSFUShort other)
"""
return _coin.SoSFUShort_setValue(self, *args)
SoSFUShort_swigregister = _coin.SoSFUShort_swigregister
SoSFUShort_swigregister(SoSFUShort)
def SoSFUShort_createInstance():
"""SoSFUShort_createInstance() -> void *"""
return _coin.SoSFUShort_createInstance()
def SoSFUShort_getClassTypeId():
"""SoSFUShort_getClassTypeId() -> SoType"""
return _coin.SoSFUShort_getClassTypeId()
def SoSFUShort_initClass():
"""SoSFUShort_initClass()"""
return _coin.SoSFUShort_initClass()
class SoSFInt32(SoSField):
"""Proxy of C++ SoSFInt32 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFInt32 self) -> SoSFInt32"""
this = _coin.new_SoSFInt32()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFInt32
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFInt32_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFInt32_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFInt32 self) -> SoType"""
return _coin.SoSFInt32_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFInt32 self, SoField field)"""
return _coin.SoSFInt32_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFInt32 self, SoField field) -> SbBool"""
return _coin.SoSFInt32_isSame(self, field)
def getValue(self):
"""getValue(SoSFInt32 self) -> int32_t"""
return _coin.SoSFInt32_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFInt32 self, SoSFInt32 field) -> int"""
return _coin.SoSFInt32___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFInt32 self, SoSFInt32 field) -> int"""
return _coin.SoSFInt32___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFInt32_initClass()
initClass = staticmethod(initClass)
def setValue(self, *args):
"""
setValue(SoSFInt32 self, int32_t newvalue)
setValue(SoSFInt32 self, SoSFInt32 other)
"""
return _coin.SoSFInt32_setValue(self, *args)
SoSFInt32_swigregister = _coin.SoSFInt32_swigregister
SoSFInt32_swigregister(SoSFInt32)
def SoSFInt32_createInstance():
"""SoSFInt32_createInstance() -> void *"""
return _coin.SoSFInt32_createInstance()
def SoSFInt32_getClassTypeId():
"""SoSFInt32_getClassTypeId() -> SoType"""
return _coin.SoSFInt32_getClassTypeId()
def SoSFInt32_initClass():
"""SoSFInt32_initClass()"""
return _coin.SoSFInt32_initClass()
class SoDrawStyle(SoNode):
"""Proxy of C++ SoDrawStyle class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoDrawStyle_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoDrawStyle self) -> SoType"""
return _coin.SoDrawStyle_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoDrawStyle_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoDrawStyle self) -> SoDrawStyle"""
this = _coin.new_SoDrawStyle()
try:
self.this.append(this)
except Exception:
self.this = this
FILLED = _coin.SoDrawStyle_FILLED
LINES = _coin.SoDrawStyle_LINES
POINTS = _coin.SoDrawStyle_POINTS
INVISIBLE = _coin.SoDrawStyle_INVISIBLE
style = _swig_property(_coin.SoDrawStyle_style_get, _coin.SoDrawStyle_style_set)
pointSize = _swig_property(_coin.SoDrawStyle_pointSize_get, _coin.SoDrawStyle_pointSize_set)
lineWidth = _swig_property(_coin.SoDrawStyle_lineWidth_get, _coin.SoDrawStyle_lineWidth_set)
linePattern = _swig_property(_coin.SoDrawStyle_linePattern_get, _coin.SoDrawStyle_linePattern_set)
linePatternScaleFactor = _swig_property(_coin.SoDrawStyle_linePatternScaleFactor_get, _coin.SoDrawStyle_linePatternScaleFactor_set)
def doAction(self, action):
"""doAction(SoDrawStyle self, SoAction action)"""
return _coin.SoDrawStyle_doAction(self, action)
def GLRender(self, action):
"""GLRender(SoDrawStyle self, SoGLRenderAction action)"""
return _coin.SoDrawStyle_GLRender(self, action)
def callback(self, action):
"""callback(SoDrawStyle self, SoCallbackAction action)"""
return _coin.SoDrawStyle_callback(self, action)
SoDrawStyle_swigregister = _coin.SoDrawStyle_swigregister
SoDrawStyle_swigregister(SoDrawStyle)
def SoDrawStyle_getClassTypeId():
"""SoDrawStyle_getClassTypeId() -> SoType"""
return _coin.SoDrawStyle_getClassTypeId()
def SoDrawStyle_initClass():
"""SoDrawStyle_initClass()"""
return _coin.SoDrawStyle_initClass()
class SbByteBuffer(object):
"""Proxy of C++ SbByteBuffer class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbByteBuffer self, char const * buffer) -> SbByteBuffer
__init__(SbByteBuffer self, SbByteBuffer buffer) -> SbByteBuffer
__init__(SbByteBuffer self, size_t size=0, char const * buffer=None) -> SbByteBuffer
__init__(SbByteBuffer self, size_t size=0) -> SbByteBuffer
__init__(SbByteBuffer self) -> SbByteBuffer
__init__(SbByteBuffer self, size_t size, unsigned char const * buffer) -> SbByteBuffer
"""
this = _coin.new_SbByteBuffer(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SbByteBuffer
__del__ = lambda self: None
def isValid(self):
"""isValid(SbByteBuffer self) -> SbBool"""
return _coin.SbByteBuffer_isValid(self)
def size(self):
"""size(SbByteBuffer self) -> size_t"""
return _coin.SbByteBuffer_size(self)
def empty(self):
"""empty(SbByteBuffer self) -> SbBool"""
return _coin.SbByteBuffer_empty(self)
def __eq__(self, that):
"""__eq__(SbByteBuffer self, SbByteBuffer that) -> SbBool"""
return _coin.SbByteBuffer___eq__(self, that)
def __iadd__(self, buf):
"""__iadd__(SbByteBuffer self, SbByteBuffer buf) -> SbByteBuffer"""
return _coin.SbByteBuffer___iadd__(self, buf)
def push(self, buf):
"""push(SbByteBuffer self, SbByteBuffer buf)"""
return _coin.SbByteBuffer_push(self, buf)
def constData(self):
"""constData(SbByteBuffer self) -> char const *"""
return _coin.SbByteBuffer_constData(self)
def data(self):
"""data(SbByteBuffer self) -> char *"""
return _coin.SbByteBuffer_data(self)
def invalidBuffer():
"""invalidBuffer() -> SbByteBuffer"""
return _coin.SbByteBuffer_invalidBuffer()
invalidBuffer = staticmethod(invalidBuffer)
def makeUnique(self):
"""makeUnique(SbByteBuffer self)"""
return _coin.SbByteBuffer_makeUnique(self)
SbByteBuffer_swigregister = _coin.SbByteBuffer_swigregister
SbByteBuffer_swigregister(SbByteBuffer)
def SbByteBuffer_invalidBuffer():
"""SbByteBuffer_invalidBuffer() -> SbByteBuffer"""
return _coin.SbByteBuffer_invalidBuffer()
class SbVec3f(object):
"""Proxy of C++ SbVec3f class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbVec3f self) -> SbVec3f
__init__(SbVec3f self, float const [3] v) -> SbVec3f
__init__(SbVec3f self, float x, float y, float z) -> SbVec3f
__init__(SbVec3f self, SbVec3d v) -> SbVec3f
__init__(SbVec3f self, SbVec3b v) -> SbVec3f
__init__(SbVec3f self, SbVec3s v) -> SbVec3f
__init__(SbVec3f self, SbVec3i32 v) -> SbVec3f
__init__(SbVec3f self, SbPlane p0, SbPlane p1, SbPlane p2) -> SbVec3f
"""
this = _coin.new_SbVec3f(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def setValue(self, *args):
"""
setValue(SbVec3f self, float const [3] v) -> SbVec3f
setValue(SbVec3f self, float x, float y, float z) -> SbVec3f
setValue(SbVec3f self, SbVec3f barycentric, SbVec3f v0, SbVec3f v1, SbVec3f v2) -> SbVec3f
setValue(SbVec3f self, SbVec3d v) -> SbVec3f
setValue(SbVec3f self, SbVec3b v) -> SbVec3f
setValue(SbVec3f self, SbVec3s v) -> SbVec3f
setValue(SbVec3f self, SbVec3i32 v) -> SbVec3f
"""
return _coin.SbVec3f_setValue(self, *args)
def getValue(self):
"""getValue(SbVec3f self) -> float const *"""
return _coin.SbVec3f_getValue(self)
def equals(self, v, tolerance):
"""equals(SbVec3f self, SbVec3f v, float tolerance) -> SbBool"""
return _coin.SbVec3f_equals(self, v, tolerance)
def cross(self, v):
"""cross(SbVec3f self, SbVec3f v) -> SbVec3f"""
return _coin.SbVec3f_cross(self, v)
def dot(self, v):
"""dot(SbVec3f self, SbVec3f v) -> float"""
return _coin.SbVec3f_dot(self, v)
def getClosestAxis(self):
"""getClosestAxis(SbVec3f self) -> SbVec3f"""
return _coin.SbVec3f_getClosestAxis(self)
def length(self):
"""length(SbVec3f self) -> float"""
return _coin.SbVec3f_length(self)
def sqrLength(self):
"""sqrLength(SbVec3f self) -> float"""
return _coin.SbVec3f_sqrLength(self)
def normalize(self):
"""normalize(SbVec3f self) -> float"""
return _coin.SbVec3f_normalize(self)
def negate(self):
"""negate(SbVec3f self)"""
return _coin.SbVec3f_negate(self)
def __imul__(self, d):
"""__imul__(SbVec3f self, float d) -> SbVec3f"""
return _coin.SbVec3f___imul__(self, d)
def __idiv__(self, d):
"""__idiv__(SbVec3f self, float d) -> SbVec3f"""
return _coin.SbVec3f___idiv__(self, d)
def __iadd__(self, v):
"""__iadd__(SbVec3f self, SbVec3f v) -> SbVec3f"""
return _coin.SbVec3f___iadd__(self, v)
def __isub__(self, v):
"""__isub__(SbVec3f self, SbVec3f v) -> SbVec3f"""
return _coin.SbVec3f___isub__(self, v)
def __neg__(self):
"""__neg__(SbVec3f self) -> SbVec3f"""
return _coin.SbVec3f___neg__(self)
def toString(self):
"""toString(SbVec3f self) -> SbString"""
return _coin.SbVec3f_toString(self)
def fromString(self, str):
"""fromString(SbVec3f self, SbString str) -> SbBool"""
return _coin.SbVec3f_fromString(self, str)
def output(self, fp):
"""output(SbVec3f self, FILE * fp)"""
return _coin.SbVec3f_output(self, fp)
def __add__(self, u):
"""__add__(SbVec3f self, SbVec3f u) -> SbVec3f"""
return _coin.SbVec3f___add__(self, u)
def __sub__(self, u):
"""__sub__(SbVec3f self, SbVec3f u) -> SbVec3f"""
return _coin.SbVec3f___sub__(self, u)
def __mul__(self, *args):
"""
__mul__(SbVec3f self, float const d) -> SbVec3f
__mul__(SbVec3f self, SbMatrix m) -> SbVec3f
"""
return _coin.SbVec3f___mul__(self, *args)
def __rmul__(self, d):
"""__rmul__(SbVec3f self, float const d) -> SbVec3f"""
return _coin.SbVec3f___rmul__(self, d)
def __div__(self, d):
"""__div__(SbVec3f self, float const d) -> SbVec3f"""
return _coin.SbVec3f___div__(self, d)
def __truediv__(self, d):
"""__truediv__(SbVec3f self, float const d) -> SbVec3f"""
return _coin.SbVec3f___truediv__(self, d)
def __eq__(self, u):
"""__eq__(SbVec3f self, SbVec3f u) -> int"""
return _coin.SbVec3f___eq__(self, u)
def __nq__(self, u):
"""__nq__(SbVec3f self, SbVec3f u) -> int"""
return _coin.SbVec3f___nq__(self, u)
def __getitem__(self, i):
"""__getitem__(SbVec3f self, int i) -> float"""
return _coin.SbVec3f___getitem__(self, i)
def __setitem__(self, i, value):
"""__setitem__(SbVec3f self, int i, float value)"""
return _coin.SbVec3f___setitem__(self, i, value)
def __iter__(self):
for i in range(3):
yield self[i]
def __len__(self):
return 3
__swig_destroy__ = _coin.delete_SbVec3f
__del__ = lambda self: None
SbVec3f_swigregister = _coin.SbVec3f_swigregister
SbVec3f_swigregister(SbVec3f)
class SbColor(SbVec3f):
"""Proxy of C++ SbColor class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbColor self) -> SbColor
__init__(SbColor self, SbVec3f v) -> SbColor
__init__(SbColor self, float const *const rgb) -> SbColor
__init__(SbColor self, float const r, float const g, float const b) -> SbColor
"""
this = _coin.new_SbColor(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def setHSVValue(self, *args):
"""
setHSVValue(SbColor self, float h, float s, float v) -> SbColor
setHSVValue(SbColor self, float const [3] hsv) -> SbColor
"""
return _coin.SbColor_setHSVValue(self, *args)
def getHSVValue(self):
"""getHSVValue(SbColor self)"""
return _coin.SbColor_getHSVValue(self)
def setPackedValue(self, rgba, transparency):
"""setPackedValue(SbColor self, uint32_t const rgba, float & transparency) -> SbColor"""
return _coin.SbColor_setPackedValue(self, rgba, transparency)
def getPackedValue(self, transparency=0.0):
"""
getPackedValue(SbColor self, float const transparency=0.0) -> uint32_t
getPackedValue(SbColor self) -> uint32_t
"""
return _coin.SbColor_getPackedValue(self, transparency)
def __add__(self, u):
"""__add__(SbColor self, SbColor u) -> SbColor"""
return _coin.SbColor___add__(self, u)
def __sub__(self, u):
"""__sub__(SbColor self, SbColor u) -> SbColor"""
return _coin.SbColor___sub__(self, u)
def __mul__(self, d):
"""__mul__(SbColor self, float const d) -> SbColor"""
return _coin.SbColor___mul__(self, d)
def __rmul__(self, d):
"""__rmul__(SbColor self, float const d) -> SbColor"""
return _coin.SbColor___rmul__(self, d)
def __div__(self, d):
"""__div__(SbColor self, float const d) -> SbColor"""
return _coin.SbColor___div__(self, d)
def __eq__(self, u):
"""__eq__(SbColor self, SbColor u) -> int"""
return _coin.SbColor___eq__(self, u)
def __nq__(self, u):
"""__nq__(SbColor self, SbColor u) -> int"""
return _coin.SbColor___nq__(self, u)
def __getitem__(self, i):
"""__getitem__(SbColor self, int i) -> float"""
return _coin.SbColor___getitem__(self, i)
def __setitem__(self, i, value):
"""__setitem__(SbColor self, int i, float value)"""
return _coin.SbColor___setitem__(self, i, value)
__swig_destroy__ = _coin.delete_SbColor
__del__ = lambda self: None
SbColor_swigregister = _coin.SbColor_swigregister
SbColor_swigregister(SbColor)
_coin.SO_LAZY_SHINY_THRESHOLD_swigconstant(_coin)
SO_LAZY_SHINY_THRESHOLD = _coin.SO_LAZY_SHINY_THRESHOLD
class SoLazyElement(SoElement):
"""Proxy of C++ SoLazyElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoLazyElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoLazyElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoLazyElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoLazyElement_initClass()
initClass = staticmethod(initClass)
LIGHT_MODEL_CASE = _coin.SoLazyElement_LIGHT_MODEL_CASE
COLOR_MATERIAL_CASE = _coin.SoLazyElement_COLOR_MATERIAL_CASE
DIFFUSE_CASE = _coin.SoLazyElement_DIFFUSE_CASE
AMBIENT_CASE = _coin.SoLazyElement_AMBIENT_CASE
EMISSIVE_CASE = _coin.SoLazyElement_EMISSIVE_CASE
SPECULAR_CASE = _coin.SoLazyElement_SPECULAR_CASE
SHININESS_CASE = _coin.SoLazyElement_SHININESS_CASE
BLENDING_CASE = _coin.SoLazyElement_BLENDING_CASE
TRANSPARENCY_CASE = _coin.SoLazyElement_TRANSPARENCY_CASE
VERTEXORDERING_CASE = _coin.SoLazyElement_VERTEXORDERING_CASE
TWOSIDE_CASE = _coin.SoLazyElement_TWOSIDE_CASE
CULLING_CASE = _coin.SoLazyElement_CULLING_CASE
SHADE_MODEL_CASE = _coin.SoLazyElement_SHADE_MODEL_CASE
ALPHATEST_CASE = _coin.SoLazyElement_ALPHATEST_CASE
GLIMAGE_CASE = _coin.SoLazyElement_GLIMAGE_CASE
LAZYCASES_LAST = _coin.SoLazyElement_LAZYCASES_LAST
LIGHT_MODEL_MASK = _coin.SoLazyElement_LIGHT_MODEL_MASK
COLOR_MATERIAL_MASK = _coin.SoLazyElement_COLOR_MATERIAL_MASK
DIFFUSE_MASK = _coin.SoLazyElement_DIFFUSE_MASK
AMBIENT_MASK = _coin.SoLazyElement_AMBIENT_MASK
EMISSIVE_MASK = _coin.SoLazyElement_EMISSIVE_MASK
SPECULAR_MASK = _coin.SoLazyElement_SPECULAR_MASK
SHININESS_MASK = _coin.SoLazyElement_SHININESS_MASK
TRANSPARENCY_MASK = _coin.SoLazyElement_TRANSPARENCY_MASK
BLENDING_MASK = _coin.SoLazyElement_BLENDING_MASK
VERTEXORDERING_MASK = _coin.SoLazyElement_VERTEXORDERING_MASK
TWOSIDE_MASK = _coin.SoLazyElement_TWOSIDE_MASK
CULLING_MASK = _coin.SoLazyElement_CULLING_MASK
SHADE_MODEL_MASK = _coin.SoLazyElement_SHADE_MODEL_MASK
ALPHATEST_MASK = _coin.SoLazyElement_ALPHATEST_MASK
GLIMAGE_MASK = _coin.SoLazyElement_GLIMAGE_MASK
ALL_MASK = _coin.SoLazyElement_ALL_MASK
OTHER_COLOR_MASK = _coin.SoLazyElement_OTHER_COLOR_MASK
ALL_COLOR_MASK = _coin.SoLazyElement_ALL_COLOR_MASK
NO_COLOR_MASK = _coin.SoLazyElement_NO_COLOR_MASK
ALL_BUT_DIFFUSE_MASK = _coin.SoLazyElement_ALL_BUT_DIFFUSE_MASK
DIFFUSE_ONLY_MASK = _coin.SoLazyElement_DIFFUSE_ONLY_MASK
BASE_COLOR = _coin.SoLazyElement_BASE_COLOR
PHONG = _coin.SoLazyElement_PHONG
CW = _coin.SoLazyElement_CW
CCW = _coin.SoLazyElement_CCW
def init(self, state):
"""init(SoLazyElement self, SoState state)"""
return _coin.SoLazyElement_init(self, state)
def push(self, state):
"""push(SoLazyElement self, SoState state)"""
return _coin.SoLazyElement_push(self, state)
def matches(self, arg2):
"""matches(SoLazyElement self, SoElement arg2) -> SbBool"""
return _coin.SoLazyElement_matches(self, arg2)
def copyMatchInfo(self):
"""copyMatchInfo(SoLazyElement self) -> SoElement"""
return _coin.SoLazyElement_copyMatchInfo(self)
def setToDefault(state):
"""setToDefault(SoState state)"""
return _coin.SoLazyElement_setToDefault(state)
setToDefault = staticmethod(setToDefault)
def setDiffuse(state, node, numcolors, colors, packer):
"""setDiffuse(SoState state, SoNode node, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
return _coin.SoLazyElement_setDiffuse(state, node, numcolors, colors, packer)
setDiffuse = staticmethod(setDiffuse)
def setTransparency(state, node, numvalues, transparency, packer):
"""setTransparency(SoState state, SoNode node, int32_t numvalues, float const * transparency, SoColorPacker packer)"""
return _coin.SoLazyElement_setTransparency(state, node, numvalues, transparency, packer)
setTransparency = staticmethod(setTransparency)
def setColorIndices(state, node, numindices, indices):
"""setColorIndices(SoState state, SoNode node, int32_t numindices, int32_t const * indices)"""
return _coin.SoLazyElement_setColorIndices(state, node, numindices, indices)
setColorIndices = staticmethod(setColorIndices)
def setAmbient(state, color):
"""setAmbient(SoState state, SbColor color)"""
return _coin.SoLazyElement_setAmbient(state, color)
setAmbient = staticmethod(setAmbient)
def setEmissive(state, color):
"""setEmissive(SoState state, SbColor color)"""
return _coin.SoLazyElement_setEmissive(state, color)
setEmissive = staticmethod(setEmissive)
def setSpecular(state, color):
"""setSpecular(SoState state, SbColor color)"""
return _coin.SoLazyElement_setSpecular(state, color)
setSpecular = staticmethod(setSpecular)
def setShininess(state, value):
"""setShininess(SoState state, float value)"""
return _coin.SoLazyElement_setShininess(state, value)
setShininess = staticmethod(setShininess)
def setColorMaterial(state, value):
"""setColorMaterial(SoState state, SbBool value)"""
return _coin.SoLazyElement_setColorMaterial(state, value)
setColorMaterial = staticmethod(setColorMaterial)
def enableBlending(state, sfactor, dfactor):
"""enableBlending(SoState state, int sfactor, int dfactor)"""
return _coin.SoLazyElement_enableBlending(state, sfactor, dfactor)
enableBlending = staticmethod(enableBlending)
def enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor):
"""enableSeparateBlending(SoState state, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
return _coin.SoLazyElement_enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor)
enableSeparateBlending = staticmethod(enableSeparateBlending)
def disableBlending(state):
"""disableBlending(SoState state)"""
return _coin.SoLazyElement_disableBlending(state)
disableBlending = staticmethod(disableBlending)
def setLightModel(state, model):
"""setLightModel(SoState state, int32_t const model)"""
return _coin.SoLazyElement_setLightModel(state, model)
setLightModel = staticmethod(setLightModel)
def setVertexOrdering(state, ordering):
"""setVertexOrdering(SoState state, SoLazyElement::VertexOrdering ordering)"""
return _coin.SoLazyElement_setVertexOrdering(state, ordering)
setVertexOrdering = staticmethod(setVertexOrdering)
def setBackfaceCulling(state, onoff):
"""setBackfaceCulling(SoState state, SbBool onoff)"""
return _coin.SoLazyElement_setBackfaceCulling(state, onoff)
setBackfaceCulling = staticmethod(setBackfaceCulling)
def setTwosideLighting(state, onoff):
"""setTwosideLighting(SoState state, SbBool onoff)"""
return _coin.SoLazyElement_setTwosideLighting(state, onoff)
setTwosideLighting = staticmethod(setTwosideLighting)
def setShadeModel(state, flatshading):
"""setShadeModel(SoState state, SbBool flatshading)"""
return _coin.SoLazyElement_setShadeModel(state, flatshading)
setShadeModel = staticmethod(setShadeModel)
def setAlphaTest(state, func, value):
"""setAlphaTest(SoState state, int func, float value)"""
return _coin.SoLazyElement_setAlphaTest(state, func, value)
setAlphaTest = staticmethod(setAlphaTest)
def getDiffuse(state, index):
"""getDiffuse(SoState state, int index) -> SbColor"""
return _coin.SoLazyElement_getDiffuse(state, index)
getDiffuse = staticmethod(getDiffuse)
def getTransparency(arg1, index):
"""getTransparency(SoState arg1, int index) -> float"""
return _coin.SoLazyElement_getTransparency(arg1, index)
getTransparency = staticmethod(getTransparency)
def getPackedColors(arg1):
"""getPackedColors(SoState arg1) -> uint32_t const *"""
return _coin.SoLazyElement_getPackedColors(arg1)
getPackedColors = staticmethod(getPackedColors)
def getColorIndices(arg1):
"""getColorIndices(SoState arg1) -> int32_t const *"""
return _coin.SoLazyElement_getColorIndices(arg1)
getColorIndices = staticmethod(getColorIndices)
def getColorIndex(arg1, num):
"""getColorIndex(SoState arg1, int num) -> int32_t"""
return _coin.SoLazyElement_getColorIndex(arg1, num)
getColorIndex = staticmethod(getColorIndex)
def getAmbient(arg1):
"""getAmbient(SoState arg1) -> SbColor"""
return _coin.SoLazyElement_getAmbient(arg1)
getAmbient = staticmethod(getAmbient)
def getEmissive(arg1):
"""getEmissive(SoState arg1) -> SbColor"""
return _coin.SoLazyElement_getEmissive(arg1)
getEmissive = staticmethod(getEmissive)
def getSpecular(arg1):
"""getSpecular(SoState arg1) -> SbColor"""
return _coin.SoLazyElement_getSpecular(arg1)
getSpecular = staticmethod(getSpecular)
def getShininess(arg1):
"""getShininess(SoState arg1) -> float"""
return _coin.SoLazyElement_getShininess(arg1)
getShininess = staticmethod(getShininess)
def getColorMaterial(arg1):
"""getColorMaterial(SoState arg1) -> SbBool"""
return _coin.SoLazyElement_getColorMaterial(arg1)
getColorMaterial = staticmethod(getColorMaterial)
def getBlending(arg1, sfactor, dfactor):
"""getBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"""
return _coin.SoLazyElement_getBlending(arg1, sfactor, dfactor)
getBlending = staticmethod(getBlending)
def getAlphaBlending(arg1, sfactor, dfactor):
"""getAlphaBlending(SoState arg1, int & sfactor, int & dfactor) -> SbBool"""
return _coin.SoLazyElement_getAlphaBlending(arg1, sfactor, dfactor)
getAlphaBlending = staticmethod(getAlphaBlending)
def getLightModel(arg1):
"""getLightModel(SoState arg1) -> int32_t"""
return _coin.SoLazyElement_getLightModel(arg1)
getLightModel = staticmethod(getLightModel)
def getAlphaTest(state, value):
"""getAlphaTest(SoState state, float & value) -> int"""
return _coin.SoLazyElement_getAlphaTest(state, value)
getAlphaTest = staticmethod(getAlphaTest)
def getTwoSidedLighting(state):
"""getTwoSidedLighting(SoState state) -> SbBool"""
return _coin.SoLazyElement_getTwoSidedLighting(state)
getTwoSidedLighting = staticmethod(getTwoSidedLighting)
def getNumDiffuse(self):
"""getNumDiffuse(SoLazyElement self) -> int32_t"""
return _coin.SoLazyElement_getNumDiffuse(self)
def getNumTransparencies(self):
"""getNumTransparencies(SoLazyElement self) -> int32_t"""
return _coin.SoLazyElement_getNumTransparencies(self)
def getNumColorIndices(self):
"""getNumColorIndices(SoLazyElement self) -> int32_t"""
return _coin.SoLazyElement_getNumColorIndices(self)
def isPacked(self):
"""isPacked(SoLazyElement self) -> SbBool"""
return _coin.SoLazyElement_isPacked(self)
def isTransparent(self):
"""isTransparent(SoLazyElement self) -> SbBool"""
return _coin.SoLazyElement_isTransparent(self)
def getInstance(state):
"""getInstance(SoState state) -> SoLazyElement"""
return _coin.SoLazyElement_getInstance(state)
getInstance = staticmethod(getInstance)
def getDefaultAmbientIntensity():
"""getDefaultAmbientIntensity() -> float"""
return _coin.SoLazyElement_getDefaultAmbientIntensity()
getDefaultAmbientIntensity = staticmethod(getDefaultAmbientIntensity)
def getDefaultDiffuse():
"""getDefaultDiffuse() -> SbColor"""
return _coin.SoLazyElement_getDefaultDiffuse()
getDefaultDiffuse = staticmethod(getDefaultDiffuse)
def getDefaultAmbient():
"""getDefaultAmbient() -> SbColor"""
return _coin.SoLazyElement_getDefaultAmbient()
getDefaultAmbient = staticmethod(getDefaultAmbient)
def getDefaultSpecular():
"""getDefaultSpecular() -> SbColor"""
return _coin.SoLazyElement_getDefaultSpecular()
getDefaultSpecular = staticmethod(getDefaultSpecular)
def getDefaultEmissive():
"""getDefaultEmissive() -> SbColor"""
return _coin.SoLazyElement_getDefaultEmissive()
getDefaultEmissive = staticmethod(getDefaultEmissive)
def getDefaultShininess():
"""getDefaultShininess() -> float"""
return _coin.SoLazyElement_getDefaultShininess()
getDefaultShininess = staticmethod(getDefaultShininess)
def getDefaultPacked():
"""getDefaultPacked() -> uint32_t"""
return _coin.SoLazyElement_getDefaultPacked()
getDefaultPacked = staticmethod(getDefaultPacked)
def getDefaultTransparency():
"""getDefaultTransparency() -> float"""
return _coin.SoLazyElement_getDefaultTransparency()
getDefaultTransparency = staticmethod(getDefaultTransparency)
def getDefaultLightModel():
"""getDefaultLightModel() -> int32_t"""
return _coin.SoLazyElement_getDefaultLightModel()
getDefaultLightModel = staticmethod(getDefaultLightModel)
def getDefaultColorIndex():
"""getDefaultColorIndex() -> int32_t"""
return _coin.SoLazyElement_getDefaultColorIndex()
getDefaultColorIndex = staticmethod(getDefaultColorIndex)
def setMaterials(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent):
"""setMaterials(SoState state, SoNode node, uint32_t bitmask, SoColorPacker cPacker, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"""
return _coin.SoLazyElement_setMaterials(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent)
setMaterials = staticmethod(setMaterials)
def getWInstance(state):
"""getWInstance(SoState state) -> SoLazyElement"""
return _coin.SoLazyElement_getWInstance(state)
getWInstance = staticmethod(getWInstance)
def getPackedPointer(self):
"""getPackedPointer(SoLazyElement self) -> uint32_t const *"""
return _coin.SoLazyElement_getPackedPointer(self)
def getDiffusePointer(self):
"""getDiffusePointer(SoLazyElement self) -> SbColor"""
return _coin.SoLazyElement_getDiffusePointer(self)
def getColorIndexPointer(self):
"""getColorIndexPointer(SoLazyElement self) -> int32_t const *"""
return _coin.SoLazyElement_getColorIndexPointer(self)
def getTransparencyPointer(self):
"""getTransparencyPointer(SoLazyElement self) -> float const *"""
return _coin.SoLazyElement_getTransparencyPointer(self)
def setTransparencyType(state, type):
"""setTransparencyType(SoState state, int32_t type)"""
return _coin.SoLazyElement_setTransparencyType(state, type)
setTransparencyType = staticmethod(setTransparencyType)
SoLazyElement_swigregister = _coin.SoLazyElement_swigregister
SoLazyElement_swigregister(SoLazyElement)
def SoLazyElement_getClassTypeId():
"""SoLazyElement_getClassTypeId() -> SoType"""
return _coin.SoLazyElement_getClassTypeId()
def SoLazyElement_getClassStackIndex():
"""SoLazyElement_getClassStackIndex() -> int"""
return _coin.SoLazyElement_getClassStackIndex()
def SoLazyElement_createInstance():
"""SoLazyElement_createInstance() -> void *"""
return _coin.SoLazyElement_createInstance()
def SoLazyElement_initClass():
"""SoLazyElement_initClass()"""
return _coin.SoLazyElement_initClass()
def SoLazyElement_setToDefault(state):
"""SoLazyElement_setToDefault(SoState state)"""
return _coin.SoLazyElement_setToDefault(state)
def SoLazyElement_setDiffuse(state, node, numcolors, colors, packer):
"""SoLazyElement_setDiffuse(SoState state, SoNode node, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
return _coin.SoLazyElement_setDiffuse(state, node, numcolors, colors, packer)
def SoLazyElement_setTransparency(state, node, numvalues, transparency, packer):
"""SoLazyElement_setTransparency(SoState state, SoNode node, int32_t numvalues, float const * transparency, SoColorPacker packer)"""
return _coin.SoLazyElement_setTransparency(state, node, numvalues, transparency, packer)
def SoLazyElement_setColorIndices(state, node, numindices, indices):
"""SoLazyElement_setColorIndices(SoState state, SoNode node, int32_t numindices, int32_t const * indices)"""
return _coin.SoLazyElement_setColorIndices(state, node, numindices, indices)
def SoLazyElement_setAmbient(state, color):
"""SoLazyElement_setAmbient(SoState state, SbColor color)"""
return _coin.SoLazyElement_setAmbient(state, color)
def SoLazyElement_setEmissive(state, color):
"""SoLazyElement_setEmissive(SoState state, SbColor color)"""
return _coin.SoLazyElement_setEmissive(state, color)
def SoLazyElement_setSpecular(state, color):
"""SoLazyElement_setSpecular(SoState state, SbColor color)"""
return _coin.SoLazyElement_setSpecular(state, color)
def SoLazyElement_setShininess(state, value):
"""SoLazyElement_setShininess(SoState state, float value)"""
return _coin.SoLazyElement_setShininess(state, value)
def SoLazyElement_setColorMaterial(state, value):
"""SoLazyElement_setColorMaterial(SoState state, SbBool value)"""
return _coin.SoLazyElement_setColorMaterial(state, value)
def SoLazyElement_enableBlending(state, sfactor, dfactor):
"""SoLazyElement_enableBlending(SoState state, int sfactor, int dfactor)"""
return _coin.SoLazyElement_enableBlending(state, sfactor, dfactor)
def SoLazyElement_enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor):
"""SoLazyElement_enableSeparateBlending(SoState state, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
return _coin.SoLazyElement_enableSeparateBlending(state, sfactor, dfactor, alpha_sfactor, alpha_dfactor)
def SoLazyElement_disableBlending(state):
"""SoLazyElement_disableBlending(SoState state)"""
return _coin.SoLazyElement_disableBlending(state)
def SoLazyElement_setLightModel(state, model):
"""SoLazyElement_setLightModel(SoState state, int32_t const model)"""
return _coin.SoLazyElement_setLightModel(state, model)
def SoLazyElement_setVertexOrdering(state, ordering):
"""SoLazyElement_setVertexOrdering(SoState state, SoLazyElement::VertexOrdering ordering)"""
return _coin.SoLazyElement_setVertexOrdering(state, ordering)
def SoLazyElement_setBackfaceCulling(state, onoff):
"""SoLazyElement_setBackfaceCulling(SoState state, SbBool onoff)"""
return _coin.SoLazyElement_setBackfaceCulling(state, onoff)
def SoLazyElement_setTwosideLighting(state, onoff):
"""SoLazyElement_setTwosideLighting(SoState state, SbBool onoff)"""
return _coin.SoLazyElement_setTwosideLighting(state, onoff)
def SoLazyElement_setShadeModel(state, flatshading):
"""SoLazyElement_setShadeModel(SoState state, SbBool flatshading)"""
return _coin.SoLazyElement_setShadeModel(state, flatshading)
def SoLazyElement_setAlphaTest(state, func, value):
"""SoLazyElement_setAlphaTest(SoState state, int func, float value)"""
return _coin.SoLazyElement_setAlphaTest(state, func, value)
def SoLazyElement_getDiffuse(state, index):
"""SoLazyElement_getDiffuse(SoState state, int index) -> SbColor"""
return _coin.SoLazyElement_getDiffuse(state, index)
def SoLazyElement_getTransparency(arg2, index):
"""SoLazyElement_getTransparency(SoState arg2, int index) -> float"""
return _coin.SoLazyElement_getTransparency(arg2, index)
def SoLazyElement_getPackedColors(arg2):
"""SoLazyElement_getPackedColors(SoState arg2) -> uint32_t const *"""
return _coin.SoLazyElement_getPackedColors(arg2)
def SoLazyElement_getColorIndices(arg2):
"""SoLazyElement_getColorIndices(SoState arg2) -> int32_t const *"""
return _coin.SoLazyElement_getColorIndices(arg2)
def SoLazyElement_getColorIndex(arg2, num):
"""SoLazyElement_getColorIndex(SoState arg2, int num) -> int32_t"""
return _coin.SoLazyElement_getColorIndex(arg2, num)
def SoLazyElement_getAmbient(arg2):
"""SoLazyElement_getAmbient(SoState arg2) -> SbColor"""
return _coin.SoLazyElement_getAmbient(arg2)
def SoLazyElement_getEmissive(arg2):
"""SoLazyElement_getEmissive(SoState arg2) -> SbColor"""
return _coin.SoLazyElement_getEmissive(arg2)
def SoLazyElement_getSpecular(arg2):
"""SoLazyElement_getSpecular(SoState arg2) -> SbColor"""
return _coin.SoLazyElement_getSpecular(arg2)
def SoLazyElement_getShininess(arg2):
"""SoLazyElement_getShininess(SoState arg2) -> float"""
return _coin.SoLazyElement_getShininess(arg2)
def SoLazyElement_getColorMaterial(arg2):
"""SoLazyElement_getColorMaterial(SoState arg2) -> SbBool"""
return _coin.SoLazyElement_getColorMaterial(arg2)
def SoLazyElement_getBlending(arg2, sfactor, dfactor):
"""SoLazyElement_getBlending(SoState arg2, int & sfactor, int & dfactor) -> SbBool"""
return _coin.SoLazyElement_getBlending(arg2, sfactor, dfactor)
def SoLazyElement_getAlphaBlending(arg2, sfactor, dfactor):
"""SoLazyElement_getAlphaBlending(SoState arg2, int & sfactor, int & dfactor) -> SbBool"""
return _coin.SoLazyElement_getAlphaBlending(arg2, sfactor, dfactor)
def SoLazyElement_getLightModel(arg2):
"""SoLazyElement_getLightModel(SoState arg2) -> int32_t"""
return _coin.SoLazyElement_getLightModel(arg2)
def SoLazyElement_getAlphaTest(state, value):
"""SoLazyElement_getAlphaTest(SoState state, float & value) -> int"""
return _coin.SoLazyElement_getAlphaTest(state, value)
def SoLazyElement_getTwoSidedLighting(state):
"""SoLazyElement_getTwoSidedLighting(SoState state) -> SbBool"""
return _coin.SoLazyElement_getTwoSidedLighting(state)
def SoLazyElement_getInstance(state):
"""SoLazyElement_getInstance(SoState state) -> SoLazyElement"""
return _coin.SoLazyElement_getInstance(state)
def SoLazyElement_getDefaultAmbientIntensity():
"""SoLazyElement_getDefaultAmbientIntensity() -> float"""
return _coin.SoLazyElement_getDefaultAmbientIntensity()
def SoLazyElement_getDefaultDiffuse():
"""SoLazyElement_getDefaultDiffuse() -> SbColor"""
return _coin.SoLazyElement_getDefaultDiffuse()
def SoLazyElement_getDefaultAmbient():
"""SoLazyElement_getDefaultAmbient() -> SbColor"""
return _coin.SoLazyElement_getDefaultAmbient()
def SoLazyElement_getDefaultSpecular():
"""SoLazyElement_getDefaultSpecular() -> SbColor"""
return _coin.SoLazyElement_getDefaultSpecular()
def SoLazyElement_getDefaultEmissive():
"""SoLazyElement_getDefaultEmissive() -> SbColor"""
return _coin.SoLazyElement_getDefaultEmissive()
def SoLazyElement_getDefaultShininess():
"""SoLazyElement_getDefaultShininess() -> float"""
return _coin.SoLazyElement_getDefaultShininess()
def SoLazyElement_getDefaultPacked():
"""SoLazyElement_getDefaultPacked() -> uint32_t"""
return _coin.SoLazyElement_getDefaultPacked()
def SoLazyElement_getDefaultTransparency():
"""SoLazyElement_getDefaultTransparency() -> float"""
return _coin.SoLazyElement_getDefaultTransparency()
def SoLazyElement_getDefaultLightModel():
"""SoLazyElement_getDefaultLightModel() -> int32_t"""
return _coin.SoLazyElement_getDefaultLightModel()
def SoLazyElement_getDefaultColorIndex():
"""SoLazyElement_getDefaultColorIndex() -> int32_t"""
return _coin.SoLazyElement_getDefaultColorIndex()
def SoLazyElement_setMaterials(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent):
"""SoLazyElement_setMaterials(SoState state, SoNode node, uint32_t bitmask, SoColorPacker cPacker, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"""
return _coin.SoLazyElement_setMaterials(state, node, bitmask, cPacker, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent)
def SoLazyElement_getWInstance(state):
"""SoLazyElement_getWInstance(SoState state) -> SoLazyElement"""
return _coin.SoLazyElement_getWInstance(state)
def SoLazyElement_setTransparencyType(state, type):
"""SoLazyElement_setTransparencyType(SoState state, int32_t type)"""
return _coin.SoLazyElement_setTransparencyType(state, type)
class SoColorPacker(object):
"""Proxy of C++ SoColorPacker class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoColorPacker self) -> SoColorPacker"""
this = _coin.new_SoColorPacker()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoColorPacker
__del__ = lambda self: None
def getPackedColors(self):
"""getPackedColors(SoColorPacker self) -> uint32_t *"""
return _coin.SoColorPacker_getPackedColors(self)
def diffuseMatch(self, nodeid):
"""diffuseMatch(SoColorPacker self, uint32_t const nodeid) -> SbBool"""
return _coin.SoColorPacker_diffuseMatch(self, nodeid)
def transpMatch(self, nodeid):
"""transpMatch(SoColorPacker self, uint32_t const nodeid) -> SbBool"""
return _coin.SoColorPacker_transpMatch(self, nodeid)
def setNodeIds(self, diffuse, transp):
"""setNodeIds(SoColorPacker self, uint32_t const diffuse, uint32_t const transp)"""
return _coin.SoColorPacker_setNodeIds(self, diffuse, transp)
def getSize(self):
"""getSize(SoColorPacker self) -> int32_t"""
return _coin.SoColorPacker_getSize(self)
def reallocate(self, size):
"""reallocate(SoColorPacker self, int32_t const size)"""
return _coin.SoColorPacker_reallocate(self, size)
def getDiffuseId(self):
"""getDiffuseId(SoColorPacker self) -> uint32_t"""
return _coin.SoColorPacker_getDiffuseId(self)
def getTranspId(self):
"""getTranspId(SoColorPacker self) -> uint32_t"""
return _coin.SoColorPacker_getTranspId(self)
SoColorPacker_swigregister = _coin.SoColorPacker_swigregister
SoColorPacker_swigregister(SoColorPacker)
class SoLightModel(SoNode):
"""Proxy of C++ SoLightModel class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoLightModel_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoLightModel self) -> SoType"""
return _coin.SoLightModel_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoLightModel_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoLightModel self) -> SoLightModel"""
this = _coin.new_SoLightModel()
try:
self.this.append(this)
except Exception:
self.this = this
BASE_COLOR = _coin.SoLightModel_BASE_COLOR
PHONG = _coin.SoLightModel_PHONG
model = _swig_property(_coin.SoLightModel_model_get, _coin.SoLightModel_model_set)
def doAction(self, action):
"""doAction(SoLightModel self, SoAction action)"""
return _coin.SoLightModel_doAction(self, action)
def GLRender(self, action):
"""GLRender(SoLightModel self, SoGLRenderAction action)"""
return _coin.SoLightModel_GLRender(self, action)
def callback(self, action):
"""callback(SoLightModel self, SoCallbackAction action)"""
return _coin.SoLightModel_callback(self, action)
SoLightModel_swigregister = _coin.SoLightModel_swigregister
SoLightModel_swigregister(SoLightModel)
def SoLightModel_getClassTypeId():
"""SoLightModel_getClassTypeId() -> SoType"""
return _coin.SoLightModel_getClassTypeId()
def SoLightModel_initClass():
"""SoLightModel_initClass()"""
return _coin.SoLightModel_initClass()
class SoMaterialBindingElement(SoInt32Element):
"""Proxy of C++ SoMaterialBindingElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoMaterialBindingElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoMaterialBindingElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoMaterialBindingElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoMaterialBindingElement_initClass()
initClass = staticmethod(initClass)
OVERALL = _coin.SoMaterialBindingElement_OVERALL
PER_PART = _coin.SoMaterialBindingElement_PER_PART
PER_PART_INDEXED = _coin.SoMaterialBindingElement_PER_PART_INDEXED
PER_FACE = _coin.SoMaterialBindingElement_PER_FACE
PER_FACE_INDEXED = _coin.SoMaterialBindingElement_PER_FACE_INDEXED
PER_VERTEX = _coin.SoMaterialBindingElement_PER_VERTEX
PER_VERTEX_INDEXED = _coin.SoMaterialBindingElement_PER_VERTEX_INDEXED
DEFAULT = _coin.SoMaterialBindingElement_DEFAULT
NONE = _coin.SoMaterialBindingElement_NONE
def init(self, state):
"""init(SoMaterialBindingElement self, SoState state)"""
return _coin.SoMaterialBindingElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, SoMaterialBindingElement::Binding const binding)
set(SoState state, SoMaterialBindingElement::Binding const binding)
"""
return _coin.SoMaterialBindingElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SoMaterialBindingElement::Binding"""
return _coin.SoMaterialBindingElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SoMaterialBindingElement::Binding"""
return _coin.SoMaterialBindingElement_getDefault()
getDefault = staticmethod(getDefault)
SoMaterialBindingElement_swigregister = _coin.SoMaterialBindingElement_swigregister
SoMaterialBindingElement_swigregister(SoMaterialBindingElement)
def SoMaterialBindingElement_getClassTypeId():
"""SoMaterialBindingElement_getClassTypeId() -> SoType"""
return _coin.SoMaterialBindingElement_getClassTypeId()
def SoMaterialBindingElement_getClassStackIndex():
"""SoMaterialBindingElement_getClassStackIndex() -> int"""
return _coin.SoMaterialBindingElement_getClassStackIndex()
def SoMaterialBindingElement_createInstance():
"""SoMaterialBindingElement_createInstance() -> void *"""
return _coin.SoMaterialBindingElement_createInstance()
def SoMaterialBindingElement_initClass():
"""SoMaterialBindingElement_initClass()"""
return _coin.SoMaterialBindingElement_initClass()
def SoMaterialBindingElement_set(*args):
"""
set(SoState state, SoNode node, SoMaterialBindingElement::Binding const binding)
SoMaterialBindingElement_set(SoState state, SoMaterialBindingElement::Binding const binding)
"""
return _coin.SoMaterialBindingElement_set(*args)
def SoMaterialBindingElement_get(state):
"""SoMaterialBindingElement_get(SoState state) -> SoMaterialBindingElement::Binding"""
return _coin.SoMaterialBindingElement_get(state)
def SoMaterialBindingElement_getDefault():
"""SoMaterialBindingElement_getDefault() -> SoMaterialBindingElement::Binding"""
return _coin.SoMaterialBindingElement_getDefault()
class SoMaterialBinding(SoNode):
"""Proxy of C++ SoMaterialBinding class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoMaterialBinding_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoMaterialBinding self) -> SoType"""
return _coin.SoMaterialBinding_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoMaterialBinding_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoMaterialBinding self) -> SoMaterialBinding"""
this = _coin.new_SoMaterialBinding()
try:
self.this.append(this)
except Exception:
self.this = this
OVERALL = _coin.SoMaterialBinding_OVERALL
PER_PART = _coin.SoMaterialBinding_PER_PART
PER_PART_INDEXED = _coin.SoMaterialBinding_PER_PART_INDEXED
PER_FACE = _coin.SoMaterialBinding_PER_FACE
PER_FACE_INDEXED = _coin.SoMaterialBinding_PER_FACE_INDEXED
PER_VERTEX = _coin.SoMaterialBinding_PER_VERTEX
PER_VERTEX_INDEXED = _coin.SoMaterialBinding_PER_VERTEX_INDEXED
DEFAULT = _coin.SoMaterialBinding_DEFAULT
NONE = _coin.SoMaterialBinding_NONE
value = _swig_property(_coin.SoMaterialBinding_value_get, _coin.SoMaterialBinding_value_set)
def doAction(self, action):
"""doAction(SoMaterialBinding self, SoAction action)"""
return _coin.SoMaterialBinding_doAction(self, action)
def GLRender(self, action):
"""GLRender(SoMaterialBinding self, SoGLRenderAction action)"""
return _coin.SoMaterialBinding_GLRender(self, action)
def callback(self, action):
"""callback(SoMaterialBinding self, SoCallbackAction action)"""
return _coin.SoMaterialBinding_callback(self, action)
def pick(self, action):
"""pick(SoMaterialBinding self, SoPickAction action)"""
return _coin.SoMaterialBinding_pick(self, action)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoMaterialBinding self, SoGetPrimitiveCountAction action)"""
return _coin.SoMaterialBinding_getPrimitiveCount(self, action)
SoMaterialBinding_swigregister = _coin.SoMaterialBinding_swigregister
SoMaterialBinding_swigregister(SoMaterialBinding)
def SoMaterialBinding_getClassTypeId():
"""SoMaterialBinding_getClassTypeId() -> SoType"""
return _coin.SoMaterialBinding_getClassTypeId()
def SoMaterialBinding_initClass():
"""SoMaterialBinding_initClass()"""
return _coin.SoMaterialBinding_initClass()
class SoNormalBindingElement(SoInt32Element):
"""Proxy of C++ SoNormalBindingElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoNormalBindingElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoNormalBindingElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoNormalBindingElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoNormalBindingElement_initClass()
initClass = staticmethod(initClass)
OVERALL = _coin.SoNormalBindingElement_OVERALL
PER_PART = _coin.SoNormalBindingElement_PER_PART
PER_PART_INDEXED = _coin.SoNormalBindingElement_PER_PART_INDEXED
PER_FACE = _coin.SoNormalBindingElement_PER_FACE
PER_FACE_INDEXED = _coin.SoNormalBindingElement_PER_FACE_INDEXED
PER_VERTEX = _coin.SoNormalBindingElement_PER_VERTEX
PER_VERTEX_INDEXED = _coin.SoNormalBindingElement_PER_VERTEX_INDEXED
DEFAULT = _coin.SoNormalBindingElement_DEFAULT
NONE = _coin.SoNormalBindingElement_NONE
def init(self, state):
"""init(SoNormalBindingElement self, SoState state)"""
return _coin.SoNormalBindingElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, SoNormalBindingElement::Binding const binding)
set(SoState state, SoNormalBindingElement::Binding const binding)
"""
return _coin.SoNormalBindingElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SoNormalBindingElement::Binding"""
return _coin.SoNormalBindingElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SoNormalBindingElement::Binding"""
return _coin.SoNormalBindingElement_getDefault()
getDefault = staticmethod(getDefault)
SoNormalBindingElement_swigregister = _coin.SoNormalBindingElement_swigregister
SoNormalBindingElement_swigregister(SoNormalBindingElement)
def SoNormalBindingElement_getClassTypeId():
"""SoNormalBindingElement_getClassTypeId() -> SoType"""
return _coin.SoNormalBindingElement_getClassTypeId()
def SoNormalBindingElement_getClassStackIndex():
"""SoNormalBindingElement_getClassStackIndex() -> int"""
return _coin.SoNormalBindingElement_getClassStackIndex()
def SoNormalBindingElement_createInstance():
"""SoNormalBindingElement_createInstance() -> void *"""
return _coin.SoNormalBindingElement_createInstance()
def SoNormalBindingElement_initClass():
"""SoNormalBindingElement_initClass()"""
return _coin.SoNormalBindingElement_initClass()
def SoNormalBindingElement_set(*args):
"""
set(SoState state, SoNode node, SoNormalBindingElement::Binding const binding)
SoNormalBindingElement_set(SoState state, SoNormalBindingElement::Binding const binding)
"""
return _coin.SoNormalBindingElement_set(*args)
def SoNormalBindingElement_get(state):
"""SoNormalBindingElement_get(SoState state) -> SoNormalBindingElement::Binding"""
return _coin.SoNormalBindingElement_get(state)
def SoNormalBindingElement_getDefault():
"""SoNormalBindingElement_getDefault() -> SoNormalBindingElement::Binding"""
return _coin.SoNormalBindingElement_getDefault()
class SoNormalBinding(SoNode):
"""Proxy of C++ SoNormalBinding class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoNormalBinding_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoNormalBinding self) -> SoType"""
return _coin.SoNormalBinding_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoNormalBinding_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoNormalBinding self) -> SoNormalBinding"""
this = _coin.new_SoNormalBinding()
try:
self.this.append(this)
except Exception:
self.this = this
OVERALL = _coin.SoNormalBinding_OVERALL
PER_PART = _coin.SoNormalBinding_PER_PART
PER_PART_INDEXED = _coin.SoNormalBinding_PER_PART_INDEXED
PER_FACE = _coin.SoNormalBinding_PER_FACE
PER_FACE_INDEXED = _coin.SoNormalBinding_PER_FACE_INDEXED
PER_VERTEX = _coin.SoNormalBinding_PER_VERTEX
PER_VERTEX_INDEXED = _coin.SoNormalBinding_PER_VERTEX_INDEXED
DEFAULT = _coin.SoNormalBinding_DEFAULT
NONE = _coin.SoNormalBinding_NONE
value = _swig_property(_coin.SoNormalBinding_value_get, _coin.SoNormalBinding_value_set)
def doAction(self, action):
"""doAction(SoNormalBinding self, SoAction action)"""
return _coin.SoNormalBinding_doAction(self, action)
def GLRender(self, action):
"""GLRender(SoNormalBinding self, SoGLRenderAction action)"""
return _coin.SoNormalBinding_GLRender(self, action)
def callback(self, action):
"""callback(SoNormalBinding self, SoCallbackAction action)"""
return _coin.SoNormalBinding_callback(self, action)
def pick(self, action):
"""pick(SoNormalBinding self, SoPickAction action)"""
return _coin.SoNormalBinding_pick(self, action)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoNormalBinding self, SoGetPrimitiveCountAction action)"""
return _coin.SoNormalBinding_getPrimitiveCount(self, action)
SoNormalBinding_swigregister = _coin.SoNormalBinding_swigregister
SoNormalBinding_swigregister(SoNormalBinding)
def SoNormalBinding_getClassTypeId():
"""SoNormalBinding_getClassTypeId() -> SoType"""
return _coin.SoNormalBinding_getClassTypeId()
def SoNormalBinding_initClass():
"""SoNormalBinding_initClass()"""
return _coin.SoNormalBinding_initClass()
class SoPickStyleElement(SoInt32Element):
"""Proxy of C++ SoPickStyleElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoPickStyleElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoPickStyleElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoPickStyleElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoPickStyleElement_initClass()
initClass = staticmethod(initClass)
SHAPE = _coin.SoPickStyleElement_SHAPE
BOUNDING_BOX = _coin.SoPickStyleElement_BOUNDING_BOX
UNPICKABLE = _coin.SoPickStyleElement_UNPICKABLE
SHAPE_ON_TOP = _coin.SoPickStyleElement_SHAPE_ON_TOP
BOUNDING_BOX_ON_TOP = _coin.SoPickStyleElement_BOUNDING_BOX_ON_TOP
SHAPE_FRONTFACES = _coin.SoPickStyleElement_SHAPE_FRONTFACES
def init(self, state):
"""init(SoPickStyleElement self, SoState state)"""
return _coin.SoPickStyleElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, int32_t const style)
set(SoState state, SoPickStyleElement::Style const style)
"""
return _coin.SoPickStyleElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SoPickStyleElement::Style"""
return _coin.SoPickStyleElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SoPickStyleElement::Style"""
return _coin.SoPickStyleElement_getDefault()
getDefault = staticmethod(getDefault)
SoPickStyleElement_swigregister = _coin.SoPickStyleElement_swigregister
SoPickStyleElement_swigregister(SoPickStyleElement)
def SoPickStyleElement_getClassTypeId():
"""SoPickStyleElement_getClassTypeId() -> SoType"""
return _coin.SoPickStyleElement_getClassTypeId()
def SoPickStyleElement_getClassStackIndex():
"""SoPickStyleElement_getClassStackIndex() -> int"""
return _coin.SoPickStyleElement_getClassStackIndex()
def SoPickStyleElement_createInstance():
"""SoPickStyleElement_createInstance() -> void *"""
return _coin.SoPickStyleElement_createInstance()
def SoPickStyleElement_initClass():
"""SoPickStyleElement_initClass()"""
return _coin.SoPickStyleElement_initClass()
def SoPickStyleElement_set(*args):
"""
set(SoState state, SoNode node, int32_t const style)
SoPickStyleElement_set(SoState state, SoPickStyleElement::Style const style)
"""
return _coin.SoPickStyleElement_set(*args)
def SoPickStyleElement_get(state):
"""SoPickStyleElement_get(SoState state) -> SoPickStyleElement::Style"""
return _coin.SoPickStyleElement_get(state)
def SoPickStyleElement_getDefault():
"""SoPickStyleElement_getDefault() -> SoPickStyleElement::Style"""
return _coin.SoPickStyleElement_getDefault()
class SoPickStyle(SoNode):
"""Proxy of C++ SoPickStyle class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoPickStyle_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoPickStyle self) -> SoType"""
return _coin.SoPickStyle_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoPickStyle_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoPickStyle self) -> SoPickStyle"""
this = _coin.new_SoPickStyle()
try:
self.this.append(this)
except Exception:
self.this = this
SHAPE = _coin.SoPickStyle_SHAPE
BOUNDING_BOX = _coin.SoPickStyle_BOUNDING_BOX
UNPICKABLE = _coin.SoPickStyle_UNPICKABLE
SHAPE_ON_TOP = _coin.SoPickStyle_SHAPE_ON_TOP
BOUNDING_BOX_ON_TOP = _coin.SoPickStyle_BOUNDING_BOX_ON_TOP
SHAPE_FRONTFACES = _coin.SoPickStyle_SHAPE_FRONTFACES
style = _swig_property(_coin.SoPickStyle_style_get, _coin.SoPickStyle_style_set)
def doAction(self, action):
"""doAction(SoPickStyle self, SoAction action)"""
return _coin.SoPickStyle_doAction(self, action)
def callback(self, action):
"""callback(SoPickStyle self, SoCallbackAction action)"""
return _coin.SoPickStyle_callback(self, action)
def pick(self, action):
"""pick(SoPickStyle self, SoPickAction action)"""
return _coin.SoPickStyle_pick(self, action)
SoPickStyle_swigregister = _coin.SoPickStyle_swigregister
SoPickStyle_swigregister(SoPickStyle)
def SoPickStyle_getClassTypeId():
"""SoPickStyle_getClassTypeId() -> SoType"""
return _coin.SoPickStyle_getClassTypeId()
def SoPickStyle_initClass():
"""SoPickStyle_initClass()"""
return _coin.SoPickStyle_initClass()
class SoShapeHintsElement(SoElement):
"""Proxy of C++ SoShapeHintsElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoShapeHintsElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoShapeHintsElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoShapeHintsElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoShapeHintsElement_initClass()
initClass = staticmethod(initClass)
UNKNOWN_ORDERING = _coin.SoShapeHintsElement_UNKNOWN_ORDERING
CLOCKWISE = _coin.SoShapeHintsElement_CLOCKWISE
COUNTERCLOCKWISE = _coin.SoShapeHintsElement_COUNTERCLOCKWISE
ORDERING_AS_IS = _coin.SoShapeHintsElement_ORDERING_AS_IS
UNKNOWN_SHAPE_TYPE = _coin.SoShapeHintsElement_UNKNOWN_SHAPE_TYPE
SOLID = _coin.SoShapeHintsElement_SOLID
SHAPE_TYPE_AS_IS = _coin.SoShapeHintsElement_SHAPE_TYPE_AS_IS
UNKNOWN_FACE_TYPE = _coin.SoShapeHintsElement_UNKNOWN_FACE_TYPE
CONVEX = _coin.SoShapeHintsElement_CONVEX
FACE_TYPE_AS_IS = _coin.SoShapeHintsElement_FACE_TYPE_AS_IS
def init(self, state):
"""init(SoShapeHintsElement self, SoState state)"""
return _coin.SoShapeHintsElement_init(self, state)
def push(self, state):
"""push(SoShapeHintsElement self, SoState state)"""
return _coin.SoShapeHintsElement_push(self, state)
def pop(self, state, prevtopelement):
"""pop(SoShapeHintsElement self, SoState state, SoElement prevtopelement)"""
return _coin.SoShapeHintsElement_pop(self, state, prevtopelement)
def matches(self, element):
"""matches(SoShapeHintsElement self, SoElement element) -> SbBool"""
return _coin.SoShapeHintsElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoShapeHintsElement self) -> SoElement"""
return _coin.SoShapeHintsElement_copyMatchInfo(self)
def set(*args):
"""
set(SoState state, SoNode node, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
set(SoState state, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
"""
return _coin.SoShapeHintsElement_set(*args)
set = staticmethod(set)
def get(state, vertexOrdering, shapeType, faceType):
"""get(SoState state, SoShapeHintsElement::VertexOrdering & vertexOrdering, SoShapeHintsElement::ShapeType & shapeType, SoShapeHintsElement::FaceType & faceType)"""
return _coin.SoShapeHintsElement_get(state, vertexOrdering, shapeType, faceType)
get = staticmethod(get)
def getVertexOrdering(state):
"""getVertexOrdering(SoState state) -> SoShapeHintsElement::VertexOrdering"""
return _coin.SoShapeHintsElement_getVertexOrdering(state)
getVertexOrdering = staticmethod(getVertexOrdering)
def getShapeType(state):
"""getShapeType(SoState state) -> SoShapeHintsElement::ShapeType"""
return _coin.SoShapeHintsElement_getShapeType(state)
getShapeType = staticmethod(getShapeType)
def getFaceType(state):
"""getFaceType(SoState state) -> SoShapeHintsElement::FaceType"""
return _coin.SoShapeHintsElement_getFaceType(state)
getFaceType = staticmethod(getFaceType)
def getDefaultVertexOrdering():
"""getDefaultVertexOrdering() -> SoShapeHintsElement::VertexOrdering"""
return _coin.SoShapeHintsElement_getDefaultVertexOrdering()
getDefaultVertexOrdering = staticmethod(getDefaultVertexOrdering)
def getDefaultShapeType():
"""getDefaultShapeType() -> SoShapeHintsElement::ShapeType"""
return _coin.SoShapeHintsElement_getDefaultShapeType()
getDefaultShapeType = staticmethod(getDefaultShapeType)
def getDefaultFaceType():
"""getDefaultFaceType() -> SoShapeHintsElement::FaceType"""
return _coin.SoShapeHintsElement_getDefaultFaceType()
getDefaultFaceType = staticmethod(getDefaultFaceType)
def output(self, file):
"""output(SoShapeHintsElement self, FILE * file)"""
return _coin.SoShapeHintsElement_output(self, file)
SoShapeHintsElement_swigregister = _coin.SoShapeHintsElement_swigregister
SoShapeHintsElement_swigregister(SoShapeHintsElement)
def SoShapeHintsElement_getClassTypeId():
"""SoShapeHintsElement_getClassTypeId() -> SoType"""
return _coin.SoShapeHintsElement_getClassTypeId()
def SoShapeHintsElement_getClassStackIndex():
"""SoShapeHintsElement_getClassStackIndex() -> int"""
return _coin.SoShapeHintsElement_getClassStackIndex()
def SoShapeHintsElement_createInstance():
"""SoShapeHintsElement_createInstance() -> void *"""
return _coin.SoShapeHintsElement_createInstance()
def SoShapeHintsElement_initClass():
"""SoShapeHintsElement_initClass()"""
return _coin.SoShapeHintsElement_initClass()
def SoShapeHintsElement_set(*args):
"""
set(SoState state, SoNode node, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
SoShapeHintsElement_set(SoState state, SoShapeHintsElement::VertexOrdering const vertexOrdering, SoShapeHintsElement::ShapeType const shapeType, SoShapeHintsElement::FaceType const faceType)
"""
return _coin.SoShapeHintsElement_set(*args)
def SoShapeHintsElement_get(state, vertexOrdering, shapeType, faceType):
"""SoShapeHintsElement_get(SoState state, SoShapeHintsElement::VertexOrdering & vertexOrdering, SoShapeHintsElement::ShapeType & shapeType, SoShapeHintsElement::FaceType & faceType)"""
return _coin.SoShapeHintsElement_get(state, vertexOrdering, shapeType, faceType)
def SoShapeHintsElement_getVertexOrdering(state):
"""SoShapeHintsElement_getVertexOrdering(SoState state) -> SoShapeHintsElement::VertexOrdering"""
return _coin.SoShapeHintsElement_getVertexOrdering(state)
def SoShapeHintsElement_getShapeType(state):
"""SoShapeHintsElement_getShapeType(SoState state) -> SoShapeHintsElement::ShapeType"""
return _coin.SoShapeHintsElement_getShapeType(state)
def SoShapeHintsElement_getFaceType(state):
"""SoShapeHintsElement_getFaceType(SoState state) -> SoShapeHintsElement::FaceType"""
return _coin.SoShapeHintsElement_getFaceType(state)
def SoShapeHintsElement_getDefaultVertexOrdering():
"""SoShapeHintsElement_getDefaultVertexOrdering() -> SoShapeHintsElement::VertexOrdering"""
return _coin.SoShapeHintsElement_getDefaultVertexOrdering()
def SoShapeHintsElement_getDefaultShapeType():
"""SoShapeHintsElement_getDefaultShapeType() -> SoShapeHintsElement::ShapeType"""
return _coin.SoShapeHintsElement_getDefaultShapeType()
def SoShapeHintsElement_getDefaultFaceType():
"""SoShapeHintsElement_getDefaultFaceType() -> SoShapeHintsElement::FaceType"""
return _coin.SoShapeHintsElement_getDefaultFaceType()
class SoSFBool(SoSField):
"""Proxy of C++ SoSFBool class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFBool self) -> SoSFBool"""
this = _coin.new_SoSFBool()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFBool
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFBool_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFBool_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFBool self) -> SoType"""
return _coin.SoSFBool_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFBool self, SoField field)"""
return _coin.SoSFBool_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFBool self, SoField field) -> SbBool"""
return _coin.SoSFBool_isSame(self, field)
def getValue(self):
"""getValue(SoSFBool self) -> SbBool"""
return _coin.SoSFBool_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFBool self, SoSFBool field) -> int"""
return _coin.SoSFBool___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFBool self, SoSFBool field) -> int"""
return _coin.SoSFBool___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFBool_initClass()
initClass = staticmethod(initClass)
def setValue(self, *args):
"""
setValue(SoSFBool self, SbBool newvalue)
setValue(SoSFBool self, SoSFBool other)
"""
return _coin.SoSFBool_setValue(self, *args)
SoSFBool_swigregister = _coin.SoSFBool_swigregister
SoSFBool_swigregister(SoSFBool)
def SoSFBool_createInstance():
"""SoSFBool_createInstance() -> void *"""
return _coin.SoSFBool_createInstance()
def SoSFBool_getClassTypeId():
"""SoSFBool_getClassTypeId() -> SoType"""
return _coin.SoSFBool_getClassTypeId()
def SoSFBool_initClass():
"""SoSFBool_initClass()"""
return _coin.SoSFBool_initClass()
class SoShapeHints(SoNode):
"""Proxy of C++ SoShapeHints class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoShapeHints_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoShapeHints self) -> SoType"""
return _coin.SoShapeHints_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoShapeHints_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoShapeHints self) -> SoShapeHints"""
this = _coin.new_SoShapeHints()
try:
self.this.append(this)
except Exception:
self.this = this
UNKNOWN_ORDERING = _coin.SoShapeHints_UNKNOWN_ORDERING
CLOCKWISE = _coin.SoShapeHints_CLOCKWISE
COUNTERCLOCKWISE = _coin.SoShapeHints_COUNTERCLOCKWISE
UNKNOWN_SHAPE_TYPE = _coin.SoShapeHints_UNKNOWN_SHAPE_TYPE
SOLID = _coin.SoShapeHints_SOLID
UNKNOWN_FACE_TYPE = _coin.SoShapeHints_UNKNOWN_FACE_TYPE
CONVEX = _coin.SoShapeHints_CONVEX
NO_WINDING_TYPE = _coin.SoShapeHints_NO_WINDING_TYPE
vertexOrdering = _swig_property(_coin.SoShapeHints_vertexOrdering_get, _coin.SoShapeHints_vertexOrdering_set)
shapeType = _swig_property(_coin.SoShapeHints_shapeType_get, _coin.SoShapeHints_shapeType_set)
faceType = _swig_property(_coin.SoShapeHints_faceType_get, _coin.SoShapeHints_faceType_set)
windingType = _swig_property(_coin.SoShapeHints_windingType_get, _coin.SoShapeHints_windingType_set)
useVBO = _swig_property(_coin.SoShapeHints_useVBO_get, _coin.SoShapeHints_useVBO_set)
creaseAngle = _swig_property(_coin.SoShapeHints_creaseAngle_get, _coin.SoShapeHints_creaseAngle_set)
def doAction(self, action):
"""doAction(SoShapeHints self, SoAction action)"""
return _coin.SoShapeHints_doAction(self, action)
def GLRender(self, action):
"""GLRender(SoShapeHints self, SoGLRenderAction action)"""
return _coin.SoShapeHints_GLRender(self, action)
def callback(self, action):
"""callback(SoShapeHints self, SoCallbackAction action)"""
return _coin.SoShapeHints_callback(self, action)
def getBoundingBox(self, action):
"""getBoundingBox(SoShapeHints self, SoGetBoundingBoxAction action)"""
return _coin.SoShapeHints_getBoundingBox(self, action)
def pick(self, action):
"""pick(SoShapeHints self, SoPickAction action)"""
return _coin.SoShapeHints_pick(self, action)
SoShapeHints_swigregister = _coin.SoShapeHints_swigregister
SoShapeHints_swigregister(SoShapeHints)
def SoShapeHints_getClassTypeId():
"""SoShapeHints_getClassTypeId() -> SoType"""
return _coin.SoShapeHints_getClassTypeId()
def SoShapeHints_initClass():
"""SoShapeHints_initClass()"""
return _coin.SoShapeHints_initClass()
class SoTexture(SoNode):
"""Proxy of C++ SoTexture class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTexture_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTexture self) -> SoType"""
return _coin.SoTexture_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoTexture_initClass()
initClass = staticmethod(initClass)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoTexture_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def doAction(self, action):
"""doAction(SoTexture self, SoAction action)"""
return _coin.SoTexture_doAction(self, action)
def GLRender(self, action):
"""GLRender(SoTexture self, SoGLRenderAction action)"""
return _coin.SoTexture_GLRender(self, action)
def callback(self, action):
"""callback(SoTexture self, SoCallbackAction action)"""
return _coin.SoTexture_callback(self, action)
SoTexture_swigregister = _coin.SoTexture_swigregister
SoTexture_swigregister(SoTexture)
def SoTexture_getClassTypeId():
"""SoTexture_getClassTypeId() -> SoType"""
return _coin.SoTexture_getClassTypeId()
def SoTexture_initClass():
"""SoTexture_initClass()"""
return _coin.SoTexture_initClass()
def SoTexture_cleanupClass():
"""SoTexture_cleanupClass()"""
return _coin.SoTexture_cleanupClass()
class SoSFImage(SoSField):
"""Proxy of C++ SoSFImage class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFImage self) -> SoSFImage"""
this = _coin.new_SoSFImage()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFImage
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFImage_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFImage_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFImage self) -> SoType"""
return _coin.SoSFImage_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFImage self, SoField field)"""
return _coin.SoSFImage_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFImage self, SoField field) -> SbBool"""
return _coin.SoSFImage_isSame(self, field)
COPY = _coin.SoSFImage_COPY
NO_COPY = _coin.SoSFImage_NO_COPY
NO_COPY_AND_DELETE = _coin.SoSFImage_NO_COPY_AND_DELETE
NO_COPY_AND_FREE = _coin.SoSFImage_NO_COPY_AND_FREE
def initClass():
"""initClass()"""
return _coin.SoSFImage_initClass()
initClass = staticmethod(initClass)
def getValue(self, *args):
"""
getValue(SoSFImage self) -> unsigned char const
getValue(SoSFImage self) -> SbImage
"""
return _coin.SoSFImage_getValue(self, *args)
def __eq__(self, field):
"""__eq__(SoSFImage self, SoSFImage field) -> int"""
return _coin.SoSFImage___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFImage self, SoSFImage field) -> int"""
return _coin.SoSFImage___ne__(self, field)
def startEditing(self):
"""startEditing(SoSFImage self) -> unsigned char *"""
return _coin.SoSFImage_startEditing(self)
def finishEditing(self):
"""finishEditing(SoSFImage self)"""
return _coin.SoSFImage_finishEditing(self)
def setSubValue(self, dims, offset, pixels):
"""setSubValue(SoSFImage self, SbVec2s dims, SbVec2s offset, unsigned char * pixels)"""
return _coin.SoSFImage_setSubValue(self, dims, offset, pixels)
def setSubValues(self, dims, offsets, num, pixelblocks):
"""setSubValues(SoSFImage self, SbVec2s dims, SbVec2s offsets, int num, unsigned char ** pixelblocks)"""
return _coin.SoSFImage_setSubValues(self, dims, offsets, num, pixelblocks)
def getSubTexture(self, idx, dims, offset):
"""getSubTexture(SoSFImage self, int idx, SbVec2s dims, SbVec2s offset) -> unsigned char *"""
return _coin.SoSFImage_getSubTexture(self, idx, dims, offset)
def hasSubTextures(self, numsubtextures):
"""hasSubTextures(SoSFImage self, int & numsubtextures) -> SbBool"""
return _coin.SoSFImage_hasSubTextures(self, numsubtextures)
def setNeverWrite(self, flag):
"""setNeverWrite(SoSFImage self, SbBool flag)"""
return _coin.SoSFImage_setNeverWrite(self, flag)
def isNeverWrite(self):
"""isNeverWrite(SoSFImage self) -> SbBool"""
return _coin.SoSFImage_isNeverWrite(self)
def hasTransparency(self):
"""hasTransparency(SoSFImage self) -> SbBool"""
return _coin.SoSFImage_hasTransparency(self)
def setValue(self, *args):
"""
setValue(SoSFImage self, SbVec2s size, int const nc, unsigned char const * pixels, SoSFImage::CopyPolicy copypolicy)
setValue(SoSFImage self, SbVec2s size, int const nc, unsigned char const * pixels)
setValue(SoSFImage self, SbVec2s size, int const nc, PyObject * pixels)
setValue(SoSFImage self, SoSFImage other)
"""
return _coin.SoSFImage_setValue(self, *args)
SoSFImage_swigregister = _coin.SoSFImage_swigregister
SoSFImage_swigregister(SoSFImage)
def SoSFImage_createInstance():
"""SoSFImage_createInstance() -> void *"""
return _coin.SoSFImage_createInstance()
def SoSFImage_getClassTypeId():
"""SoSFImage_getClassTypeId() -> SoType"""
return _coin.SoSFImage_getClassTypeId()
def SoSFImage_initClass():
"""SoSFImage_initClass()"""
return _coin.SoSFImage_initClass()
class SoSFString(SoSField):
"""Proxy of C++ SoSFString class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFString self) -> SoSFString"""
this = _coin.new_SoSFString()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFString
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFString_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFString_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFString self) -> SoType"""
return _coin.SoSFString_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFString self, SoField field)"""
return _coin.SoSFString_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFString self, SoField field) -> SbBool"""
return _coin.SoSFString_isSame(self, field)
def getValue(self):
"""getValue(SoSFString self) -> SbString"""
return _coin.SoSFString_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFString self, SoSFString field) -> int"""
return _coin.SoSFString___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFString self, SoSFString field) -> int"""
return _coin.SoSFString___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFString_initClass()
initClass = staticmethod(initClass)
def setValue(self, *args):
"""
setValue(SoSFString self, SbString newvalue)
setValue(SoSFString self, char const * str)
setValue(SoSFString self, SoSFString other)
"""
return _coin.SoSFString_setValue(self, *args)
SoSFString_swigregister = _coin.SoSFString_swigregister
SoSFString_swigregister(SoSFString)
def SoSFString_createInstance():
"""SoSFString_createInstance() -> void *"""
return _coin.SoSFString_createInstance()
def SoSFString_getClassTypeId():
"""SoSFString_getClassTypeId() -> SoType"""
return _coin.SoSFString_getClassTypeId()
def SoSFString_initClass():
"""SoSFString_initClass()"""
return _coin.SoSFString_initClass()
class SoSFColor(SoSField):
"""Proxy of C++ SoSFColor class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFColor self) -> SoSFColor"""
this = _coin.new_SoSFColor()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFColor
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFColor_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFColor_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFColor self) -> SoType"""
return _coin.SoSFColor_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFColor self, SoField field)"""
return _coin.SoSFColor_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFColor self, SoField field) -> SbBool"""
return _coin.SoSFColor_isSame(self, field)
def getValue(self):
"""getValue(SoSFColor self) -> SbColor"""
return _coin.SoSFColor_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFColor self, SoSFColor field) -> int"""
return _coin.SoSFColor___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFColor self, SoSFColor field) -> int"""
return _coin.SoSFColor___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFColor_initClass()
initClass = staticmethod(initClass)
def setHSVValue(self, *args):
"""
setHSVValue(SoSFColor self, float h, float s, float v)
setHSVValue(SoSFColor self, float const [3] hsv)
"""
return _coin.SoSFColor_setHSVValue(self, *args)
def setValue(self, *args):
"""
setValue(SoSFColor self, SbColor newvalue)
setValue(SoSFColor self, SbVec3f vec)
setValue(SoSFColor self, float red, float green, float blue)
setValue(SoSFColor self, float const [3] rgb)
setValue(SoSFColor self, SoSFColor other)
"""
return _coin.SoSFColor_setValue(self, *args)
SoSFColor_swigregister = _coin.SoSFColor_swigregister
SoSFColor_swigregister(SoSFColor)
def SoSFColor_createInstance():
"""SoSFColor_createInstance() -> void *"""
return _coin.SoSFColor_createInstance()
def SoSFColor_getClassTypeId():
"""SoSFColor_getClassTypeId() -> SoType"""
return _coin.SoSFColor_getClassTypeId()
def SoSFColor_initClass():
"""SoSFColor_initClass()"""
return _coin.SoSFColor_initClass()
class SoReplacedElement(SoElement):
"""Proxy of C++ SoReplacedElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoReplacedElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoReplacedElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def initClass():
"""initClass()"""
return _coin.SoReplacedElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoReplacedElement self, SoState state)"""
return _coin.SoReplacedElement_init(self, state)
def matches(self, element):
"""matches(SoReplacedElement self, SoElement element) -> SbBool"""
return _coin.SoReplacedElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoReplacedElement self) -> SoElement"""
return _coin.SoReplacedElement_copyMatchInfo(self)
def getNodeId(self):
"""getNodeId(SoReplacedElement self) -> uint32_t"""
return _coin.SoReplacedElement_getNodeId(self)
def output(self, file):
"""output(SoReplacedElement self, FILE * file)"""
return _coin.SoReplacedElement_output(self, file)
SoReplacedElement_swigregister = _coin.SoReplacedElement_swigregister
SoReplacedElement_swigregister(SoReplacedElement)
def SoReplacedElement_getClassTypeId():
"""SoReplacedElement_getClassTypeId() -> SoType"""
return _coin.SoReplacedElement_getClassTypeId()
def SoReplacedElement_getClassStackIndex():
"""SoReplacedElement_getClassStackIndex() -> int"""
return _coin.SoReplacedElement_getClassStackIndex()
def SoReplacedElement_initClass():
"""SoReplacedElement_initClass()"""
return _coin.SoReplacedElement_initClass()
class SbVec3s(object):
"""Proxy of C++ SbVec3s class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbVec3s self) -> SbVec3s
__init__(SbVec3s self, short const [3] v) -> SbVec3s
__init__(SbVec3s self, short x, short y, short z) -> SbVec3s
__init__(SbVec3s self, SbVec3us const & v) -> SbVec3s
__init__(SbVec3s self, SbVec3b v) -> SbVec3s
__init__(SbVec3s self, SbVec3i32 v) -> SbVec3s
__init__(SbVec3s self, SbVec3f v) -> SbVec3s
__init__(SbVec3s self, SbVec3d v) -> SbVec3s
"""
this = _coin.new_SbVec3s(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def setValue(self, *args):
"""
setValue(SbVec3s self, short const [3] v) -> SbVec3s
setValue(SbVec3s self, short x, short y, short z) -> SbVec3s
setValue(SbVec3s self, SbVec3us const & v) -> SbVec3s
setValue(SbVec3s self, SbVec3b v) -> SbVec3s
setValue(SbVec3s self, SbVec3i32 v) -> SbVec3s
setValue(SbVec3s self, SbVec3f v) -> SbVec3s
setValue(SbVec3s self, SbVec3d v) -> SbVec3s
"""
return _coin.SbVec3s_setValue(self, *args)
def getValue(self, *args):
"""
getValue(SbVec3s self) -> short const
getValue(SbVec3s self)
"""
return _coin.SbVec3s_getValue(self, *args)
def dot(self, v):
"""dot(SbVec3s self, SbVec3s v) -> int32_t"""
return _coin.SbVec3s_dot(self, v)
def negate(self):
"""negate(SbVec3s self)"""
return _coin.SbVec3s_negate(self)
def __imul__(self, *args):
"""
__imul__(SbVec3s self, int d) -> SbVec3s
__imul__(SbVec3s self, double d) -> SbVec3s
"""
return _coin.SbVec3s___imul__(self, *args)
def __idiv__(self, *args):
"""
__idiv__(SbVec3s self, int d) -> SbVec3s
__idiv__(SbVec3s self, double d) -> SbVec3s
"""
return _coin.SbVec3s___idiv__(self, *args)
def __iadd__(self, v):
"""__iadd__(SbVec3s self, SbVec3s v) -> SbVec3s"""
return _coin.SbVec3s___iadd__(self, v)
def __isub__(self, v):
"""__isub__(SbVec3s self, SbVec3s v) -> SbVec3s"""
return _coin.SbVec3s___isub__(self, v)
def __neg__(self):
"""__neg__(SbVec3s self) -> SbVec3s"""
return _coin.SbVec3s___neg__(self)
def toString(self):
"""toString(SbVec3s self) -> SbString"""
return _coin.SbVec3s_toString(self)
def fromString(self, str):
"""fromString(SbVec3s self, SbString str) -> SbBool"""
return _coin.SbVec3s_fromString(self, str)
def output(self, fp):
"""output(SbVec3s self, FILE * fp)"""
return _coin.SbVec3s_output(self, fp)
def __add__(self, u):
"""__add__(SbVec3s self, SbVec3s u) -> SbVec3s"""
return _coin.SbVec3s___add__(self, u)
def __sub__(self, u):
"""__sub__(SbVec3s self, SbVec3s u) -> SbVec3s"""
return _coin.SbVec3s___sub__(self, u)
def __mul__(self, d):
"""__mul__(SbVec3s self, double const d) -> SbVec3s"""
return _coin.SbVec3s___mul__(self, d)
def __rmul__(self, d):
"""__rmul__(SbVec3s self, double const d) -> SbVec3s"""
return _coin.SbVec3s___rmul__(self, d)
def __div__(self, d):
"""__div__(SbVec3s self, double const d) -> SbVec3s"""
return _coin.SbVec3s___div__(self, d)
def __truediv__(self, d):
"""__truediv__(SbVec3s self, double const d) -> SbVec3s"""
return _coin.SbVec3s___truediv__(self, d)
def __eq__(self, u):
"""__eq__(SbVec3s self, SbVec3s u) -> int"""
return _coin.SbVec3s___eq__(self, u)
def __nq__(self, u):
"""__nq__(SbVec3s self, SbVec3s u) -> int"""
return _coin.SbVec3s___nq__(self, u)
def __getitem__(self, i):
"""__getitem__(SbVec3s self, int i) -> short"""
return _coin.SbVec3s___getitem__(self, i)
def __setitem__(self, i, value):
"""__setitem__(SbVec3s self, int i, short value)"""
return _coin.SbVec3s___setitem__(self, i, value)
def __iter__(self):
for i in range(3):
yield self[i]
def __len__(self):
return 3
__swig_destroy__ = _coin.delete_SbVec3s
__del__ = lambda self: None
SbVec3s_swigregister = _coin.SbVec3s_swigregister
SbVec3s_swigregister(SbVec3s)
class SoMultiTextureImageElement(SoElement):
"""Proxy of C++ SoMultiTextureImageElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoMultiTextureImageElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoMultiTextureImageElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoMultiTextureImageElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoMultiTextureImageElement_initClass()
initClass = staticmethod(initClass)
BLEND = _coin.SoMultiTextureImageElement_BLEND
MODULATE = _coin.SoMultiTextureImageElement_MODULATE
DECAL = _coin.SoMultiTextureImageElement_DECAL
REPLACE = _coin.SoMultiTextureImageElement_REPLACE
CLAMP = _coin.SoMultiTextureImageElement_CLAMP
REPEAT = _coin.SoMultiTextureImageElement_REPEAT
CLAMP_TO_BORDER = _coin.SoMultiTextureImageElement_CLAMP_TO_BORDER
def init(self, state):
"""init(SoMultiTextureImageElement self, SoState state)"""
return _coin.SoMultiTextureImageElement_init(self, state)
def setDefault(state, node, unit=0):
"""
setDefault(SoState state, SoNode node, int const unit=0)
setDefault(SoState state, SoNode node)
"""
return _coin.SoMultiTextureImageElement_setDefault(state, node, unit)
setDefault = staticmethod(setDefault)
def getBlendColor(state, unit=0):
"""
getBlendColor(SoState state, int const unit=0) -> SbColor
getBlendColor(SoState state) -> SbColor
"""
return _coin.SoMultiTextureImageElement_getBlendColor(state, unit)
getBlendColor = staticmethod(getBlendColor)
def getModel(state, unit=0):
"""
getModel(SoState state, int const unit=0) -> SoMultiTextureImageElement::Model
getModel(SoState state) -> SoMultiTextureImageElement::Model
"""
return _coin.SoMultiTextureImageElement_getModel(state, unit)
getModel = staticmethod(getModel)
def getWrapS(state, unit=0):
"""
getWrapS(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap
getWrapS(SoState state) -> SoMultiTextureImageElement::Wrap
"""
return _coin.SoMultiTextureImageElement_getWrapS(state, unit)
getWrapS = staticmethod(getWrapS)
def getWrapT(state, unit=0):
"""
getWrapT(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap
getWrapT(SoState state) -> SoMultiTextureImageElement::Wrap
"""
return _coin.SoMultiTextureImageElement_getWrapT(state, unit)
getWrapT = staticmethod(getWrapT)
def getWrapR(state, unit=0):
"""
getWrapR(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap
getWrapR(SoState state) -> SoMultiTextureImageElement::Wrap
"""
return _coin.SoMultiTextureImageElement_getWrapR(state, unit)
getWrapR = staticmethod(getWrapR)
def containsTransparency(state):
"""containsTransparency(SoState state) -> SbBool"""
return _coin.SoMultiTextureImageElement_containsTransparency(state)
containsTransparency = staticmethod(containsTransparency)
def getDefault(*args):
"""
getDefault(SbVec2s size, int & numComponents) -> unsigned char const
getDefault(SbVec3s size, int & numComponents) -> unsigned char const *
"""
return _coin.SoMultiTextureImageElement_getDefault(*args)
getDefault = staticmethod(getDefault)
def push(self, state):
"""push(SoMultiTextureImageElement self, SoState state)"""
return _coin.SoMultiTextureImageElement_push(self, state)
def matches(self, elem):
"""matches(SoMultiTextureImageElement self, SoElement elem) -> SbBool"""
return _coin.SoMultiTextureImageElement_matches(self, elem)
def copyMatchInfo(self):
"""copyMatchInfo(SoMultiTextureImageElement self) -> SoElement"""
return _coin.SoMultiTextureImageElement_copyMatchInfo(self)
def setElt(self, *args):
"""
setElt(SoMultiTextureImageElement self, int const unit, uint32_t const nodeid, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)
setElt(SoMultiTextureImageElement self, int const unit, uint32_t const nodeid, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)
"""
return _coin.SoMultiTextureImageElement_setElt(self, *args)
def hasTransparency(self, unit=0):
"""
hasTransparency(SoMultiTextureImageElement self, int const unit=0) -> SbBool
hasTransparency(SoMultiTextureImageElement self) -> SbBool
"""
return _coin.SoMultiTextureImageElement_hasTransparency(self, unit)
def set(*args):
"""
set(SoState state, SoNode node, int const unit, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)
set(SoState state, SoNode node, int const unit, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)
set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const model, SbColor blendColor)
set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)
set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const wrapR, int const model, SbColor blendColor)
set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)
"""
return _coin.SoMultiTextureImageElement_set(*args)
set = staticmethod(set)
def get(*args):
"""
get(SoState state, int const unit, SbVec2s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
get(SoState state, int const unit, SbVec3s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Wrap & wrapR, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
get(SoState state, SbVec2s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
get(SoState state, SbVec3s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Wrap & wrapR, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
get(SoState state, SbVec2s size, int & numComponents, int & wrapS, int & wrapT, int & model, SbColor blendColor) -> unsigned char const
get(SoState state, SbVec3s size, int & numComponents, int & wrapS, int & wrapT, int & wrapR, int & model, SbColor blendColor) -> unsigned char const *
"""
return _coin.SoMultiTextureImageElement_get(*args)
get = staticmethod(get)
def getImage(*args):
"""
getImage(SoState state, int const unit, SbVec2s size, int & numComponents) -> unsigned char const
getImage(SoState state, int const unit, SbVec3s size, int & numComponents) -> unsigned char const
getImage(SoState state, SbVec2s size, int & numComponents) -> unsigned char const
getImage(SoState state, SbVec3s size, int & numComponents) -> unsigned char const *
"""
return _coin.SoMultiTextureImageElement_getImage(*args)
getImage = staticmethod(getImage)
SoMultiTextureImageElement_swigregister = _coin.SoMultiTextureImageElement_swigregister
SoMultiTextureImageElement_swigregister(SoMultiTextureImageElement)
def SoMultiTextureImageElement_getClassTypeId():
"""SoMultiTextureImageElement_getClassTypeId() -> SoType"""
return _coin.SoMultiTextureImageElement_getClassTypeId()
def SoMultiTextureImageElement_getClassStackIndex():
"""SoMultiTextureImageElement_getClassStackIndex() -> int"""
return _coin.SoMultiTextureImageElement_getClassStackIndex()
def SoMultiTextureImageElement_createInstance():
"""SoMultiTextureImageElement_createInstance() -> void *"""
return _coin.SoMultiTextureImageElement_createInstance()
def SoMultiTextureImageElement_initClass():
"""SoMultiTextureImageElement_initClass()"""
return _coin.SoMultiTextureImageElement_initClass()
def SoMultiTextureImageElement_setDefault(state, node, unit=0):
"""
setDefault(SoState state, SoNode node, int const unit=0)
SoMultiTextureImageElement_setDefault(SoState state, SoNode node)
"""
return _coin.SoMultiTextureImageElement_setDefault(state, node, unit)
def SoMultiTextureImageElement_getBlendColor(state, unit=0):
"""
getBlendColor(SoState state, int const unit=0) -> SbColor
SoMultiTextureImageElement_getBlendColor(SoState state) -> SbColor
"""
return _coin.SoMultiTextureImageElement_getBlendColor(state, unit)
def SoMultiTextureImageElement_getModel(state, unit=0):
"""
getModel(SoState state, int const unit=0) -> SoMultiTextureImageElement::Model
SoMultiTextureImageElement_getModel(SoState state) -> SoMultiTextureImageElement::Model
"""
return _coin.SoMultiTextureImageElement_getModel(state, unit)
def SoMultiTextureImageElement_getWrapS(state, unit=0):
"""
getWrapS(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap
SoMultiTextureImageElement_getWrapS(SoState state) -> SoMultiTextureImageElement::Wrap
"""
return _coin.SoMultiTextureImageElement_getWrapS(state, unit)
def SoMultiTextureImageElement_getWrapT(state, unit=0):
"""
getWrapT(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap
SoMultiTextureImageElement_getWrapT(SoState state) -> SoMultiTextureImageElement::Wrap
"""
return _coin.SoMultiTextureImageElement_getWrapT(state, unit)
def SoMultiTextureImageElement_getWrapR(state, unit=0):
"""
getWrapR(SoState state, int const unit=0) -> SoMultiTextureImageElement::Wrap
SoMultiTextureImageElement_getWrapR(SoState state) -> SoMultiTextureImageElement::Wrap
"""
return _coin.SoMultiTextureImageElement_getWrapR(state, unit)
def SoMultiTextureImageElement_containsTransparency(state):
"""SoMultiTextureImageElement_containsTransparency(SoState state) -> SbBool"""
return _coin.SoMultiTextureImageElement_containsTransparency(state)
def SoMultiTextureImageElement_getDefault(*args):
"""
getDefault(SbVec2s size, int & numComponents) -> unsigned char const
SoMultiTextureImageElement_getDefault(SbVec3s size, int & numComponents) -> unsigned char const *
"""
return _coin.SoMultiTextureImageElement_getDefault(*args)
def SoMultiTextureImageElement_set(*args):
"""
set(SoState state, SoNode node, int const unit, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)
set(SoState state, SoNode node, int const unit, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)
set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const model, SbColor blendColor)
set(SoState state, SoNode node, SbVec2s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Model const model, SbColor blendColor)
set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, int const wrapS, int const wrapT, int const wrapR, int const model, SbColor blendColor)
SoMultiTextureImageElement_set(SoState state, SoNode node, SbVec3s size, int const numComponents, unsigned char const * bytes, SoMultiTextureImageElement::Wrap const wrapS, SoMultiTextureImageElement::Wrap const wrapT, SoMultiTextureImageElement::Wrap const wrapR, SoMultiTextureImageElement::Model const model, SbColor blendColor)
"""
return _coin.SoMultiTextureImageElement_set(*args)
def SoMultiTextureImageElement_get(*args):
"""
get(SoState state, int const unit, SbVec2s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
get(SoState state, int const unit, SbVec3s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Wrap & wrapR, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
get(SoState state, SbVec2s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
get(SoState state, SbVec3s size, int & numComponents, SoMultiTextureImageElement::Wrap & wrapS, SoMultiTextureImageElement::Wrap & wrapT, SoMultiTextureImageElement::Wrap & wrapR, SoMultiTextureImageElement::Model & model, SbColor blendColor) -> unsigned char const
get(SoState state, SbVec2s size, int & numComponents, int & wrapS, int & wrapT, int & model, SbColor blendColor) -> unsigned char const
SoMultiTextureImageElement_get(SoState state, SbVec3s size, int & numComponents, int & wrapS, int & wrapT, int & wrapR, int & model, SbColor blendColor) -> unsigned char const *
"""
return _coin.SoMultiTextureImageElement_get(*args)
def SoMultiTextureImageElement_getImage(*args):
"""
getImage(SoState state, int const unit, SbVec2s size, int & numComponents) -> unsigned char const
getImage(SoState state, int const unit, SbVec3s size, int & numComponents) -> unsigned char const
getImage(SoState state, SbVec2s size, int & numComponents) -> unsigned char const
SoMultiTextureImageElement_getImage(SoState state, SbVec3s size, int & numComponents) -> unsigned char const *
"""
return _coin.SoMultiTextureImageElement_getImage(*args)
class SoTexture2(SoTexture):
"""Proxy of C++ SoTexture2 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTexture2_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTexture2 self) -> SoType"""
return _coin.SoTexture2_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoTexture2_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoTexture2 self) -> SoTexture2"""
this = _coin.new_SoTexture2()
try:
self.this.append(this)
except Exception:
self.this = this
MODULATE = _coin.SoTexture2_MODULATE
DECAL = _coin.SoTexture2_DECAL
BLEND = _coin.SoTexture2_BLEND
REPLACE = _coin.SoTexture2_REPLACE
REPEAT = _coin.SoTexture2_REPEAT
CLAMP = _coin.SoTexture2_CLAMP
filename = _swig_property(_coin.SoTexture2_filename_get, _coin.SoTexture2_filename_set)
image = _swig_property(_coin.SoTexture2_image_get, _coin.SoTexture2_image_set)
wrapS = _swig_property(_coin.SoTexture2_wrapS_get, _coin.SoTexture2_wrapS_set)
wrapT = _swig_property(_coin.SoTexture2_wrapT_get, _coin.SoTexture2_wrapT_set)
model = _swig_property(_coin.SoTexture2_model_get, _coin.SoTexture2_model_set)
blendColor = _swig_property(_coin.SoTexture2_blendColor_get, _coin.SoTexture2_blendColor_set)
enableCompressedTexture = _swig_property(_coin.SoTexture2_enableCompressedTexture_get, _coin.SoTexture2_enableCompressedTexture_set)
def doAction(self, action):
"""doAction(SoTexture2 self, SoAction action)"""
return _coin.SoTexture2_doAction(self, action)
def GLRender(self, action):
"""GLRender(SoTexture2 self, SoGLRenderAction action)"""
return _coin.SoTexture2_GLRender(self, action)
def callback(self, action):
"""callback(SoTexture2 self, SoCallbackAction action)"""
return _coin.SoTexture2_callback(self, action)
def rayPick(self, action):
"""rayPick(SoTexture2 self, SoRayPickAction action)"""
return _coin.SoTexture2_rayPick(self, action)
def readImage(fname, w, h, nc, bytes):
"""readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
return _coin.SoTexture2_readImage(fname, w, h, nc, bytes)
readImage = staticmethod(readImage)
SoTexture2_swigregister = _coin.SoTexture2_swigregister
SoTexture2_swigregister(SoTexture2)
def SoTexture2_getClassTypeId():
"""SoTexture2_getClassTypeId() -> SoType"""
return _coin.SoTexture2_getClassTypeId()
def SoTexture2_initClass():
"""SoTexture2_initClass()"""
return _coin.SoTexture2_initClass()
def SoTexture2_readImage(fname, w, h, nc, bytes):
"""SoTexture2_readImage(SbString fname, int & w, int & h, int & nc, unsigned char *& bytes) -> SbBool"""
return _coin.SoTexture2_readImage(fname, w, h, nc, bytes)
class SoTextureCoordinateBindingElement(SoInt32Element):
"""Proxy of C++ SoTextureCoordinateBindingElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTextureCoordinateBindingElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoTextureCoordinateBindingElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoTextureCoordinateBindingElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoTextureCoordinateBindingElement_initClass()
initClass = staticmethod(initClass)
PER_VERTEX = _coin.SoTextureCoordinateBindingElement_PER_VERTEX
PER_VERTEX_INDEXED = _coin.SoTextureCoordinateBindingElement_PER_VERTEX_INDEXED
def init(self, state):
"""init(SoTextureCoordinateBindingElement self, SoState state)"""
return _coin.SoTextureCoordinateBindingElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, SoTextureCoordinateBindingElement::Binding const binding)
set(SoState state, SoTextureCoordinateBindingElement::Binding const binding)
"""
return _coin.SoTextureCoordinateBindingElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SoTextureCoordinateBindingElement::Binding"""
return _coin.SoTextureCoordinateBindingElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SoTextureCoordinateBindingElement::Binding"""
return _coin.SoTextureCoordinateBindingElement_getDefault()
getDefault = staticmethod(getDefault)
SoTextureCoordinateBindingElement_swigregister = _coin.SoTextureCoordinateBindingElement_swigregister
SoTextureCoordinateBindingElement_swigregister(SoTextureCoordinateBindingElement)
def SoTextureCoordinateBindingElement_getClassTypeId():
"""SoTextureCoordinateBindingElement_getClassTypeId() -> SoType"""
return _coin.SoTextureCoordinateBindingElement_getClassTypeId()
def SoTextureCoordinateBindingElement_getClassStackIndex():
"""SoTextureCoordinateBindingElement_getClassStackIndex() -> int"""
return _coin.SoTextureCoordinateBindingElement_getClassStackIndex()
def SoTextureCoordinateBindingElement_createInstance():
"""SoTextureCoordinateBindingElement_createInstance() -> void *"""
return _coin.SoTextureCoordinateBindingElement_createInstance()
def SoTextureCoordinateBindingElement_initClass():
"""SoTextureCoordinateBindingElement_initClass()"""
return _coin.SoTextureCoordinateBindingElement_initClass()
def SoTextureCoordinateBindingElement_set(*args):
"""
set(SoState state, SoNode node, SoTextureCoordinateBindingElement::Binding const binding)
SoTextureCoordinateBindingElement_set(SoState state, SoTextureCoordinateBindingElement::Binding const binding)
"""
return _coin.SoTextureCoordinateBindingElement_set(*args)
def SoTextureCoordinateBindingElement_get(state):
"""SoTextureCoordinateBindingElement_get(SoState state) -> SoTextureCoordinateBindingElement::Binding"""
return _coin.SoTextureCoordinateBindingElement_get(state)
def SoTextureCoordinateBindingElement_getDefault():
"""SoTextureCoordinateBindingElement_getDefault() -> SoTextureCoordinateBindingElement::Binding"""
return _coin.SoTextureCoordinateBindingElement_getDefault()
class SoTextureCoordinateBinding(SoNode):
"""Proxy of C++ SoTextureCoordinateBinding class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTextureCoordinateBinding_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTextureCoordinateBinding self) -> SoType"""
return _coin.SoTextureCoordinateBinding_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoTextureCoordinateBinding_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoTextureCoordinateBinding self) -> SoTextureCoordinateBinding"""
this = _coin.new_SoTextureCoordinateBinding()
try:
self.this.append(this)
except Exception:
self.this = this
PER_VERTEX = _coin.SoTextureCoordinateBinding_PER_VERTEX
PER_VERTEX_INDEXED = _coin.SoTextureCoordinateBinding_PER_VERTEX_INDEXED
DEFAULT = _coin.SoTextureCoordinateBinding_DEFAULT
value = _swig_property(_coin.SoTextureCoordinateBinding_value_get, _coin.SoTextureCoordinateBinding_value_set)
def doAction(self, action):
"""doAction(SoTextureCoordinateBinding self, SoAction action)"""
return _coin.SoTextureCoordinateBinding_doAction(self, action)
def callback(self, action):
"""callback(SoTextureCoordinateBinding self, SoCallbackAction action)"""
return _coin.SoTextureCoordinateBinding_callback(self, action)
def GLRender(self, action):
"""GLRender(SoTextureCoordinateBinding self, SoGLRenderAction action)"""
return _coin.SoTextureCoordinateBinding_GLRender(self, action)
def pick(self, action):
"""pick(SoTextureCoordinateBinding self, SoPickAction action)"""
return _coin.SoTextureCoordinateBinding_pick(self, action)
SoTextureCoordinateBinding_swigregister = _coin.SoTextureCoordinateBinding_swigregister
SoTextureCoordinateBinding_swigregister(SoTextureCoordinateBinding)
def SoTextureCoordinateBinding_getClassTypeId():
"""SoTextureCoordinateBinding_getClassTypeId() -> SoType"""
return _coin.SoTextureCoordinateBinding_getClassTypeId()
def SoTextureCoordinateBinding_initClass():
"""SoTextureCoordinateBinding_initClass()"""
return _coin.SoTextureCoordinateBinding_initClass()
class SoTransformation(SoNode):
"""Proxy of C++ SoTransformation class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTransformation_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTransformation self) -> SoType"""
return _coin.SoTransformation_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoTransformation_initClass()
initClass = staticmethod(initClass)
SoTransformation_swigregister = _coin.SoTransformation_swigregister
SoTransformation_swigregister(SoTransformation)
def SoTransformation_getClassTypeId():
"""SoTransformation_getClassTypeId() -> SoType"""
return _coin.SoTransformation_getClassTypeId()
def SoTransformation_initClass():
"""SoTransformation_initClass()"""
return _coin.SoTransformation_initClass()
class SoUnits(SoTransformation):
"""Proxy of C++ SoUnits class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoUnits_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoUnits self) -> SoType"""
return _coin.SoUnits_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoUnits_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoUnits self) -> SoUnits"""
this = _coin.new_SoUnits()
try:
self.this.append(this)
except Exception:
self.this = this
METERS = _coin.SoUnits_METERS
CENTIMETERS = _coin.SoUnits_CENTIMETERS
MILLIMETERS = _coin.SoUnits_MILLIMETERS
MICROMETERS = _coin.SoUnits_MICROMETERS
MICRONS = _coin.SoUnits_MICRONS
NANOMETERS = _coin.SoUnits_NANOMETERS
ANGSTROMS = _coin.SoUnits_ANGSTROMS
KILOMETERS = _coin.SoUnits_KILOMETERS
FEET = _coin.SoUnits_FEET
INCHES = _coin.SoUnits_INCHES
POINTS = _coin.SoUnits_POINTS
YARDS = _coin.SoUnits_YARDS
MILES = _coin.SoUnits_MILES
NAUTICAL_MILES = _coin.SoUnits_NAUTICAL_MILES
units = _swig_property(_coin.SoUnits_units_get, _coin.SoUnits_units_set)
def doAction(self, action):
"""doAction(SoUnits self, SoAction action)"""
return _coin.SoUnits_doAction(self, action)
def callback(self, action):
"""callback(SoUnits self, SoCallbackAction action)"""
return _coin.SoUnits_callback(self, action)
def getBoundingBox(self, action):
"""getBoundingBox(SoUnits self, SoGetBoundingBoxAction action)"""
return _coin.SoUnits_getBoundingBox(self, action)
def getMatrix(self, action):
"""getMatrix(SoUnits self, SoGetMatrixAction action)"""
return _coin.SoUnits_getMatrix(self, action)
def GLRender(self, action):
"""GLRender(SoUnits self, SoGLRenderAction action)"""
return _coin.SoUnits_GLRender(self, action)
def pick(self, action):
"""pick(SoUnits self, SoPickAction action)"""
return _coin.SoUnits_pick(self, action)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoUnits self, SoGetPrimitiveCountAction action)"""
return _coin.SoUnits_getPrimitiveCount(self, action)
SoUnits_swigregister = _coin.SoUnits_swigregister
SoUnits_swigregister(SoUnits)
def SoUnits_getClassTypeId():
"""SoUnits_getClassTypeId() -> SoType"""
return _coin.SoUnits_getClassTypeId()
def SoUnits_initClass():
"""SoUnits_initClass()"""
return _coin.SoUnits_initClass()
class SoCallbackAction(SoAction):
"""Proxy of C++ SoCallbackAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoCallbackAction self) -> SoType"""
return _coin.SoCallbackAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoCallbackAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoCallbackAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoCallbackAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoCallbackAction_initClass()
initClass = staticmethod(initClass)
def __init__(self, *args):
"""
__init__(SoCallbackAction self) -> SoCallbackAction
__init__(SoCallbackAction self, SbViewportRegion vp) -> SoCallbackAction
"""
this = _coin.new_SoCallbackAction(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoCallbackAction
__del__ = lambda self: None
def setViewportRegion(self, vp):
"""setViewportRegion(SoCallbackAction self, SbViewportRegion vp)"""
return _coin.SoCallbackAction_setViewportRegion(self, vp)
CONTINUE = _coin.SoCallbackAction_CONTINUE
ABORT = _coin.SoCallbackAction_ABORT
PRUNE = _coin.SoCallbackAction_PRUNE
def getDecimationType(self):
"""getDecimationType(SoCallbackAction self) -> SoDecimationTypeElement::Type"""
return _coin.SoCallbackAction_getDecimationType(self)
def getDecimationPercentage(self):
"""getDecimationPercentage(SoCallbackAction self) -> float"""
return _coin.SoCallbackAction_getDecimationPercentage(self)
def getComplexity(self):
"""getComplexity(SoCallbackAction self) -> float"""
return _coin.SoCallbackAction_getComplexity(self)
def getComplexityType(self):
"""getComplexityType(SoCallbackAction self) -> SoComplexity::Type"""
return _coin.SoCallbackAction_getComplexityType(self)
def getNumCoordinates(self):
"""getNumCoordinates(SoCallbackAction self) -> int32_t"""
return _coin.SoCallbackAction_getNumCoordinates(self)
def getCoordinate3(self, index):
"""getCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
return _coin.SoCallbackAction_getCoordinate3(self, index)
def getCoordinate4(self, index):
"""getCoordinate4(SoCallbackAction self, int const index) -> SbVec4f"""
return _coin.SoCallbackAction_getCoordinate4(self, index)
def getDrawStyle(self):
"""getDrawStyle(SoCallbackAction self) -> SoDrawStyle::Style"""
return _coin.SoCallbackAction_getDrawStyle(self)
def getLinePattern(self):
"""getLinePattern(SoCallbackAction self) -> unsigned short"""
return _coin.SoCallbackAction_getLinePattern(self)
def getLineWidth(self):
"""getLineWidth(SoCallbackAction self) -> float"""
return _coin.SoCallbackAction_getLineWidth(self)
def getPointSize(self):
"""getPointSize(SoCallbackAction self) -> float"""
return _coin.SoCallbackAction_getPointSize(self)
def getFontName(self):
"""getFontName(SoCallbackAction self) -> SbName"""
return _coin.SoCallbackAction_getFontName(self)
def getFontSize(self):
"""getFontSize(SoCallbackAction self) -> float"""
return _coin.SoCallbackAction_getFontSize(self)
def getLightModel(self):
"""getLightModel(SoCallbackAction self) -> SoLightModel::Model"""
return _coin.SoCallbackAction_getLightModel(self)
def getLightAttenuation(self):
"""getLightAttenuation(SoCallbackAction self) -> SbVec3f"""
return _coin.SoCallbackAction_getLightAttenuation(self)
def getMaterialBinding(self):
"""getMaterialBinding(SoCallbackAction self) -> SoMaterialBinding::Binding"""
return _coin.SoCallbackAction_getMaterialBinding(self)
def getNumNormals(self):
"""getNumNormals(SoCallbackAction self) -> uint32_t"""
return _coin.SoCallbackAction_getNumNormals(self)
def getNormal(self, index):
"""getNormal(SoCallbackAction self, int const index) -> SbVec3f"""
return _coin.SoCallbackAction_getNormal(self, index)
def getNormalBinding(self):
"""getNormalBinding(SoCallbackAction self) -> SoNormalBinding::Binding"""
return _coin.SoCallbackAction_getNormalBinding(self)
def getNumProfileCoordinates(self):
"""getNumProfileCoordinates(SoCallbackAction self) -> int32_t"""
return _coin.SoCallbackAction_getNumProfileCoordinates(self)
def getProfileCoordinate2(self, index):
"""getProfileCoordinate2(SoCallbackAction self, int const index) -> SbVec2f"""
return _coin.SoCallbackAction_getProfileCoordinate2(self, index)
def getProfileCoordinate3(self, index):
"""getProfileCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
return _coin.SoCallbackAction_getProfileCoordinate3(self, index)
def getProfile(self):
"""getProfile(SoCallbackAction self) -> SoNodeList"""
return _coin.SoCallbackAction_getProfile(self)
def getVertexOrdering(self):
"""getVertexOrdering(SoCallbackAction self) -> SoShapeHints::VertexOrdering"""
return _coin.SoCallbackAction_getVertexOrdering(self)
def getShapeType(self):
"""getShapeType(SoCallbackAction self) -> SoShapeHints::ShapeType"""
return _coin.SoCallbackAction_getShapeType(self)
def getFaceType(self):
"""getFaceType(SoCallbackAction self) -> SoShapeHints::FaceType"""
return _coin.SoCallbackAction_getFaceType(self)
def getCreaseAngle(self):
"""getCreaseAngle(SoCallbackAction self) -> float"""
return _coin.SoCallbackAction_getCreaseAngle(self)
def getNumTextureCoordinates(self):
"""getNumTextureCoordinates(SoCallbackAction self) -> int32_t"""
return _coin.SoCallbackAction_getNumTextureCoordinates(self)
def getTextureCoordinate2(self, index):
"""getTextureCoordinate2(SoCallbackAction self, int const index) -> SbVec2f"""
return _coin.SoCallbackAction_getTextureCoordinate2(self, index)
def getTextureCoordinate3(self, index):
"""getTextureCoordinate3(SoCallbackAction self, int const index) -> SbVec3f"""
return _coin.SoCallbackAction_getTextureCoordinate3(self, index)
def getTextureCoordinate4(self, index):
"""getTextureCoordinate4(SoCallbackAction self, int const index) -> SbVec4f"""
return _coin.SoCallbackAction_getTextureCoordinate4(self, index)
def getTextureCoordinateBinding(self):
"""getTextureCoordinateBinding(SoCallbackAction self) -> SoTextureCoordinateBinding::Binding"""
return _coin.SoCallbackAction_getTextureCoordinateBinding(self)
def getTextureBlendColor(self):
"""getTextureBlendColor(SoCallbackAction self) -> SbColor"""
return _coin.SoCallbackAction_getTextureBlendColor(self)
def getTextureImage(self, *args):
"""
getTextureImage(SoCallbackAction self, SbVec2s size, int & numcomps) -> unsigned char const
getTextureImage(SoCallbackAction self, SbVec3s size, int & numcomps) -> unsigned char const *
"""
return _coin.SoCallbackAction_getTextureImage(self, *args)
def getTextureMatrix(self):
"""getTextureMatrix(SoCallbackAction self) -> SbMatrix"""
return _coin.SoCallbackAction_getTextureMatrix(self)
def getTextureModel(self):
"""getTextureModel(SoCallbackAction self) -> SoTexture2::Model"""
return _coin.SoCallbackAction_getTextureModel(self)
def getTextureWrapS(self):
"""getTextureWrapS(SoCallbackAction self) -> SoTexture2::Wrap"""
return _coin.SoCallbackAction_getTextureWrapS(self)
def getTextureWrapT(self):
"""getTextureWrapT(SoCallbackAction self) -> SoTexture2::Wrap"""
return _coin.SoCallbackAction_getTextureWrapT(self)
def getTextureWrapR(self):
"""getTextureWrapR(SoCallbackAction self) -> SoTexture2::Wrap"""
return _coin.SoCallbackAction_getTextureWrapR(self)
def getModelMatrix(self):
"""getModelMatrix(SoCallbackAction self) -> SbMatrix"""
return _coin.SoCallbackAction_getModelMatrix(self)
def getUnits(self):
"""getUnits(SoCallbackAction self) -> SoUnits::Units"""
return _coin.SoCallbackAction_getUnits(self)
def getFocalDistance(self):
"""getFocalDistance(SoCallbackAction self) -> float"""
return _coin.SoCallbackAction_getFocalDistance(self)
def getProjectionMatrix(self):
"""getProjectionMatrix(SoCallbackAction self) -> SbMatrix"""
return _coin.SoCallbackAction_getProjectionMatrix(self)
def getViewingMatrix(self):
"""getViewingMatrix(SoCallbackAction self) -> SbMatrix"""
return _coin.SoCallbackAction_getViewingMatrix(self)
def getViewVolume(self):
"""getViewVolume(SoCallbackAction self) -> SbViewVolume"""
return _coin.SoCallbackAction_getViewVolume(self)
def getViewportRegion(self):
"""getViewportRegion(SoCallbackAction self) -> SbViewportRegion"""
return _coin.SoCallbackAction_getViewportRegion(self)
def getPickStyle(self):
"""getPickStyle(SoCallbackAction self) -> SoPickStyle::Style"""
return _coin.SoCallbackAction_getPickStyle(self)
def getSwitch(self):
"""getSwitch(SoCallbackAction self) -> int32_t"""
return _coin.SoCallbackAction_getSwitch(self)
def getCurrentResponse(self):
"""getCurrentResponse(SoCallbackAction self) -> SoCallbackAction::Response"""
return _coin.SoCallbackAction_getCurrentResponse(self)
def invokePreCallbacks(self, node):
"""invokePreCallbacks(SoCallbackAction self, SoNode node)"""
return _coin.SoCallbackAction_invokePreCallbacks(self, node)
def invokePostCallbacks(self, node):
"""invokePostCallbacks(SoCallbackAction self, SoNode node)"""
return _coin.SoCallbackAction_invokePostCallbacks(self, node)
def invokeTriangleCallbacks(self, shape, v1, v2, v3):
"""invokeTriangleCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2, SoPrimitiveVertex v3)"""
return _coin.SoCallbackAction_invokeTriangleCallbacks(self, shape, v1, v2, v3)
def invokeLineSegmentCallbacks(self, shape, v1, v2):
"""invokeLineSegmentCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v1, SoPrimitiveVertex v2)"""
return _coin.SoCallbackAction_invokeLineSegmentCallbacks(self, shape, v1, v2)
def invokePointCallbacks(self, shape, v):
"""invokePointCallbacks(SoCallbackAction self, SoShape shape, SoPrimitiveVertex v)"""
return _coin.SoCallbackAction_invokePointCallbacks(self, shape, v)
def shouldGeneratePrimitives(self, shape):
"""shouldGeneratePrimitives(SoCallbackAction self, SoShape shape) -> SbBool"""
return _coin.SoCallbackAction_shouldGeneratePrimitives(self, shape)
def getCurPathTail(self):
"""getCurPathTail(SoCallbackAction self) -> SoNode"""
return _coin.SoCallbackAction_getCurPathTail(self)
def setCurrentNode(self, node):
"""setCurrentNode(SoCallbackAction self, SoNode node)"""
return _coin.SoCallbackAction_setCurrentNode(self, node)
def setCallbackAll(self, callbackall):
"""setCallbackAll(SoCallbackAction self, SbBool callbackall)"""
return _coin.SoCallbackAction_setCallbackAll(self, callbackall)
def isCallbackAll(self):
"""isCallbackAll(SoCallbackAction self) -> SbBool"""
return _coin.SoCallbackAction_isCallbackAll(self)
def getMaterial(self, index=0):
"""
getMaterial(SoCallbackAction self, int const index=0) -> PyObject
getMaterial(SoCallbackAction self) -> PyObject *
"""
return _coin.SoCallbackAction_getMaterial(self, index)
def addPreCallback(self, *args):
"""
addPreCallback(SoCallbackAction self, SoType type, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
addPreCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoCallbackAction_addPreCallback(self, *args)
def addPostCallback(self, *args):
"""
addPostCallback(SoCallbackAction self, SoType type, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
addPostCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoCallbackAction_addPostCallback(self, *args)
def addPreTailCallback(self, *args):
"""
addPreTailCallback(SoCallbackAction self, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
addPreTailCallback(SoCallbackAction self, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoCallbackAction_addPreTailCallback(self, *args)
def addPostTailCallback(self, *args):
"""
addPostTailCallback(SoCallbackAction self, SoCallbackAction::SoCallbackActionCB * cb, void * userdata)
addPostTailCallback(SoCallbackAction self, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoCallbackAction_addPostTailCallback(self, *args)
def addTriangleCallback(self, *args):
"""
addTriangleCallback(SoCallbackAction self, SoType type, SoTriangleCB * cb, void * userdata)
addTriangleCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoCallbackAction_addTriangleCallback(self, *args)
def addLineSegmentCallback(self, *args):
"""
addLineSegmentCallback(SoCallbackAction self, SoType type, SoLineSegmentCB * cb, void * userdata)
addLineSegmentCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoCallbackAction_addLineSegmentCallback(self, *args)
def addPointCallback(self, *args):
"""
addPointCallback(SoCallbackAction self, SoType type, SoPointCB * cb, void * userdata)
addPointCallback(SoCallbackAction self, SoType type, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoCallbackAction_addPointCallback(self, *args)
SoCallbackAction_swigregister = _coin.SoCallbackAction_swigregister
SoCallbackAction_swigregister(SoCallbackAction)
def SoCallbackAction_getClassTypeId():
"""SoCallbackAction_getClassTypeId() -> SoType"""
return _coin.SoCallbackAction_getClassTypeId()
def SoCallbackAction_addMethod(type, method):
"""SoCallbackAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoCallbackAction_addMethod(type, method)
def SoCallbackAction_enableElement(type, stackindex):
"""SoCallbackAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoCallbackAction_enableElement(type, stackindex)
def SoCallbackAction_initClass():
"""SoCallbackAction_initClass()"""
return _coin.SoCallbackAction_initClass()
class SbVec2f(object):
"""Proxy of C++ SbVec2f class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbVec2f self) -> SbVec2f
__init__(SbVec2f self, float const [2] v) -> SbVec2f
__init__(SbVec2f self, float x, float y) -> SbVec2f
__init__(SbVec2f self, SbVec2d v) -> SbVec2f
__init__(SbVec2f self, SbVec2b v) -> SbVec2f
__init__(SbVec2f self, SbVec2s v) -> SbVec2f
__init__(SbVec2f self, SbVec2i32 v) -> SbVec2f
"""
this = _coin.new_SbVec2f(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def setValue(self, *args):
"""
setValue(SbVec2f self, float const [2] v) -> SbVec2f
setValue(SbVec2f self, float x, float y) -> SbVec2f
setValue(SbVec2f self, SbVec2d v) -> SbVec2f
setValue(SbVec2f self, SbVec2b v) -> SbVec2f
setValue(SbVec2f self, SbVec2s v) -> SbVec2f
setValue(SbVec2f self, SbVec2i32 v) -> SbVec2f
"""
return _coin.SbVec2f_setValue(self, *args)
def getValue(self):
"""getValue(SbVec2f self)"""
return _coin.SbVec2f_getValue(self)
def dot(self, v):
"""dot(SbVec2f self, SbVec2f v) -> float"""
return _coin.SbVec2f_dot(self, v)
def equals(self, v, tolerance):
"""equals(SbVec2f self, SbVec2f v, float tolerance) -> SbBool"""
return _coin.SbVec2f_equals(self, v, tolerance)
def length(self):
"""length(SbVec2f self) -> float"""
return _coin.SbVec2f_length(self)
def sqrLength(self):
"""sqrLength(SbVec2f self) -> float"""
return _coin.SbVec2f_sqrLength(self)
def negate(self):
"""negate(SbVec2f self)"""
return _coin.SbVec2f_negate(self)
def normalize(self):
"""normalize(SbVec2f self) -> float"""
return _coin.SbVec2f_normalize(self)
def __imul__(self, d):
"""__imul__(SbVec2f self, float d) -> SbVec2f"""
return _coin.SbVec2f___imul__(self, d)
def __idiv__(self, d):
"""__idiv__(SbVec2f self, float d) -> SbVec2f"""
return _coin.SbVec2f___idiv__(self, d)
def __iadd__(self, v):
"""__iadd__(SbVec2f self, SbVec2f v) -> SbVec2f"""
return _coin.SbVec2f___iadd__(self, v)
def __isub__(self, v):
"""__isub__(SbVec2f self, SbVec2f v) -> SbVec2f"""
return _coin.SbVec2f___isub__(self, v)
def __neg__(self):
"""__neg__(SbVec2f self) -> SbVec2f"""
return _coin.SbVec2f___neg__(self)
def toString(self):
"""toString(SbVec2f self) -> SbString"""
return _coin.SbVec2f_toString(self)
def fromString(self, str):
"""fromString(SbVec2f self, SbString str) -> SbBool"""
return _coin.SbVec2f_fromString(self, str)
def output(self, fp):
"""output(SbVec2f self, FILE * fp)"""
return _coin.SbVec2f_output(self, fp)
def __add__(self, u):
"""__add__(SbVec2f self, SbVec2f u) -> SbVec2f"""
return _coin.SbVec2f___add__(self, u)
def __sub__(self, u):
"""__sub__(SbVec2f self, SbVec2f u) -> SbVec2f"""
return _coin.SbVec2f___sub__(self, u)
def __mul__(self, d):
"""__mul__(SbVec2f self, float const d) -> SbVec2f"""
return _coin.SbVec2f___mul__(self, d)
def __rmul__(self, d):
"""__rmul__(SbVec2f self, float const d) -> SbVec2f"""
return _coin.SbVec2f___rmul__(self, d)
def __div__(self, d):
"""__div__(SbVec2f self, float const d) -> SbVec2f"""
return _coin.SbVec2f___div__(self, d)
def __truediv__(self, d):
"""__truediv__(SbVec2f self, float const d) -> SbVec2f"""
return _coin.SbVec2f___truediv__(self, d)
def __eq__(self, u):
"""__eq__(SbVec2f self, SbVec2f u) -> int"""
return _coin.SbVec2f___eq__(self, u)
def __nq__(self, u):
"""__nq__(SbVec2f self, SbVec2f u) -> int"""
return _coin.SbVec2f___nq__(self, u)
def __getitem__(self, i):
"""__getitem__(SbVec2f self, int i) -> float"""
return _coin.SbVec2f___getitem__(self, i)
def __setitem__(self, i, value):
"""__setitem__(SbVec2f self, int i, float value)"""
return _coin.SbVec2f___setitem__(self, i, value)
def __iter__(self):
for i in range(2):
yield self[i]
def __len__(self):
return 2
__swig_destroy__ = _coin.delete_SbVec2f
__del__ = lambda self: None
SbVec2f_swigregister = _coin.SbVec2f_swigregister
SbVec2f_swigregister(SbVec2f)
class SbViewportRegion(object):
"""Proxy of C++ SbViewportRegion class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbViewportRegion self) -> SbViewportRegion
__init__(SbViewportRegion self, short width, short height) -> SbViewportRegion
__init__(SbViewportRegion self, SbVec2s winSize) -> SbViewportRegion
__init__(SbViewportRegion self, SbViewportRegion vpReg) -> SbViewportRegion
"""
this = _coin.new_SbViewportRegion(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def setWindowSize(self, *args):
"""
setWindowSize(SbViewportRegion self, short width, short height)
setWindowSize(SbViewportRegion self, SbVec2s winSize)
"""
return _coin.SbViewportRegion_setWindowSize(self, *args)
def setViewport(self, *args):
"""
setViewport(SbViewportRegion self, float left, float bottom, float width, float height)
setViewport(SbViewportRegion self, SbVec2f origin, SbVec2f size)
"""
return _coin.SbViewportRegion_setViewport(self, *args)
def setViewportPixels(self, *args):
"""
setViewportPixels(SbViewportRegion self, short left, short bottom, short width, short height)
setViewportPixels(SbViewportRegion self, SbVec2s origin, SbVec2s size)
"""
return _coin.SbViewportRegion_setViewportPixels(self, *args)
def getWindowSize(self):
"""getWindowSize(SbViewportRegion self) -> SbVec2s"""
return _coin.SbViewportRegion_getWindowSize(self)
def getViewportOrigin(self):
"""getViewportOrigin(SbViewportRegion self) -> SbVec2f"""
return _coin.SbViewportRegion_getViewportOrigin(self)
def getViewportOriginPixels(self):
"""getViewportOriginPixels(SbViewportRegion self) -> SbVec2s"""
return _coin.SbViewportRegion_getViewportOriginPixels(self)
def getViewportSize(self):
"""getViewportSize(SbViewportRegion self) -> SbVec2f"""
return _coin.SbViewportRegion_getViewportSize(self)
def getViewportSizePixels(self):
"""getViewportSizePixels(SbViewportRegion self) -> SbVec2s"""
return _coin.SbViewportRegion_getViewportSizePixels(self)
def getViewportAspectRatio(self):
"""getViewportAspectRatio(SbViewportRegion self) -> float"""
return _coin.SbViewportRegion_getViewportAspectRatio(self)
def scaleWidth(self, ratio):
"""scaleWidth(SbViewportRegion self, float ratio)"""
return _coin.SbViewportRegion_scaleWidth(self, ratio)
def scaleHeight(self, ratio):
"""scaleHeight(SbViewportRegion self, float ratio)"""
return _coin.SbViewportRegion_scaleHeight(self, ratio)
def setPixelsPerInch(self, ppi):
"""setPixelsPerInch(SbViewportRegion self, float ppi)"""
return _coin.SbViewportRegion_setPixelsPerInch(self, ppi)
def getPixelsPerInch(self):
"""getPixelsPerInch(SbViewportRegion self) -> float"""
return _coin.SbViewportRegion_getPixelsPerInch(self)
def getPixelsPerPoint(self):
"""getPixelsPerPoint(SbViewportRegion self) -> float"""
return _coin.SbViewportRegion_getPixelsPerPoint(self)
def output(self, file):
"""output(SbViewportRegion self, FILE * file)"""
return _coin.SbViewportRegion_output(self, file)
def __eq__(self, u):
"""__eq__(SbViewportRegion self, SbViewportRegion u) -> int"""
return _coin.SbViewportRegion___eq__(self, u)
def __ne__(self, u):
"""__ne__(SbViewportRegion self, SbViewportRegion u) -> int"""
return _coin.SbViewportRegion___ne__(self, u)
__swig_destroy__ = _coin.delete_SbViewportRegion
__del__ = lambda self: None
SbViewportRegion_swigregister = _coin.SbViewportRegion_swigregister
SbViewportRegion_swigregister(SbViewportRegion)
class SoGLRenderAction(SoAction):
"""Proxy of C++ SoGLRenderAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoGLRenderAction self) -> SoType"""
return _coin.SoGLRenderAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLRenderAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoGLRenderAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoGLRenderAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoGLRenderAction_initClass()
initClass = staticmethod(initClass)
def __init__(self, viewportregion):
"""__init__(SoGLRenderAction self, SbViewportRegion viewportregion) -> SoGLRenderAction"""
this = _coin.new_SoGLRenderAction(viewportregion)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoGLRenderAction
__del__ = lambda self: None
SCREEN_DOOR = _coin.SoGLRenderAction_SCREEN_DOOR
ADD = _coin.SoGLRenderAction_ADD
DELAYED_ADD = _coin.SoGLRenderAction_DELAYED_ADD
SORTED_OBJECT_ADD = _coin.SoGLRenderAction_SORTED_OBJECT_ADD
BLEND = _coin.SoGLRenderAction_BLEND
DELAYED_BLEND = _coin.SoGLRenderAction_DELAYED_BLEND
SORTED_OBJECT_BLEND = _coin.SoGLRenderAction_SORTED_OBJECT_BLEND
SORTED_OBJECT_SORTED_TRIANGLE_ADD = _coin.SoGLRenderAction_SORTED_OBJECT_SORTED_TRIANGLE_ADD
SORTED_OBJECT_SORTED_TRIANGLE_BLEND = _coin.SoGLRenderAction_SORTED_OBJECT_SORTED_TRIANGLE_BLEND
NONE = _coin.SoGLRenderAction_NONE
SORTED_LAYERS_BLEND = _coin.SoGLRenderAction_SORTED_LAYERS_BLEND
ONE_PASS = _coin.SoGLRenderAction_ONE_PASS
NONSOLID_SEPARATE_BACKFACE_PASS = _coin.SoGLRenderAction_NONSOLID_SEPARATE_BACKFACE_PASS
CONTINUE = _coin.SoGLRenderAction_CONTINUE
ABORT = _coin.SoGLRenderAction_ABORT
PRUNE = _coin.SoGLRenderAction_PRUNE
DELAY = _coin.SoGLRenderAction_DELAY
BBOX_CENTER = _coin.SoGLRenderAction_BBOX_CENTER
BBOX_CLOSEST_CORNER = _coin.SoGLRenderAction_BBOX_CLOSEST_CORNER
BBOX_FARTHEST_CORNER = _coin.SoGLRenderAction_BBOX_FARTHEST_CORNER
CUSTOM_CALLBACK = _coin.SoGLRenderAction_CUSTOM_CALLBACK
def setViewportRegion(self, newregion):
"""setViewportRegion(SoGLRenderAction self, SbViewportRegion newregion)"""
return _coin.SoGLRenderAction_setViewportRegion(self, newregion)
def getViewportRegion(self):
"""getViewportRegion(SoGLRenderAction self) -> SbViewportRegion"""
return _coin.SoGLRenderAction_getViewportRegion(self)
def setUpdateArea(self, origin, size):
"""setUpdateArea(SoGLRenderAction self, SbVec2f origin, SbVec2f size)"""
return _coin.SoGLRenderAction_setUpdateArea(self, origin, size)
def getUpdateArea(self, origin, size):
"""getUpdateArea(SoGLRenderAction self, SbVec2f origin, SbVec2f size)"""
return _coin.SoGLRenderAction_getUpdateArea(self, origin, size)
def getAbortCallback(self, func_out, userdata_out):
"""getAbortCallback(SoGLRenderAction self, SoGLRenderAction::SoGLRenderAbortCB *& func_out, void *& userdata_out)"""
return _coin.SoGLRenderAction_getAbortCallback(self, func_out, userdata_out)
def setTransparencyType(self, type):
"""setTransparencyType(SoGLRenderAction self, SoGLRenderAction::TransparencyType const type)"""
return _coin.SoGLRenderAction_setTransparencyType(self, type)
def getTransparencyType(self):
"""getTransparencyType(SoGLRenderAction self) -> SoGLRenderAction::TransparencyType"""
return _coin.SoGLRenderAction_getTransparencyType(self)
def setTransparentDelayedObjectRenderType(self, type):
"""setTransparentDelayedObjectRenderType(SoGLRenderAction self, SoGLRenderAction::TransparentDelayedObjectRenderType type)"""
return _coin.SoGLRenderAction_setTransparentDelayedObjectRenderType(self, type)
def getTransparentDelayedObjectRenderType(self):
"""getTransparentDelayedObjectRenderType(SoGLRenderAction self) -> SoGLRenderAction::TransparentDelayedObjectRenderType"""
return _coin.SoGLRenderAction_getTransparentDelayedObjectRenderType(self)
def setSmoothing(self, smooth):
"""setSmoothing(SoGLRenderAction self, SbBool const smooth)"""
return _coin.SoGLRenderAction_setSmoothing(self, smooth)
def isSmoothing(self):
"""isSmoothing(SoGLRenderAction self) -> SbBool"""
return _coin.SoGLRenderAction_isSmoothing(self)
def setNumPasses(self, num):
"""setNumPasses(SoGLRenderAction self, int const num)"""
return _coin.SoGLRenderAction_setNumPasses(self, num)
def getNumPasses(self):
"""getNumPasses(SoGLRenderAction self) -> int"""
return _coin.SoGLRenderAction_getNumPasses(self)
def setPassUpdate(self, flag):
"""setPassUpdate(SoGLRenderAction self, SbBool const flag)"""
return _coin.SoGLRenderAction_setPassUpdate(self, flag)
def isPassUpdate(self):
"""isPassUpdate(SoGLRenderAction self) -> SbBool"""
return _coin.SoGLRenderAction_isPassUpdate(self)
def setCacheContext(self, context):
"""setCacheContext(SoGLRenderAction self, uint32_t const context)"""
return _coin.SoGLRenderAction_setCacheContext(self, context)
def getCacheContext(self):
"""getCacheContext(SoGLRenderAction self) -> uint32_t"""
return _coin.SoGLRenderAction_getCacheContext(self)
def addDelayedPath(self, path):
"""addDelayedPath(SoGLRenderAction self, SoPath path)"""
return _coin.SoGLRenderAction_addDelayedPath(self, path)
def isRenderingDelayedPaths(self):
"""isRenderingDelayedPaths(SoGLRenderAction self) -> SbBool"""
return _coin.SoGLRenderAction_isRenderingDelayedPaths(self)
def handleTransparency(self, istransparent=0):
"""
handleTransparency(SoGLRenderAction self, SbBool istransparent=0) -> SbBool
handleTransparency(SoGLRenderAction self) -> SbBool
"""
return _coin.SoGLRenderAction_handleTransparency(self, istransparent)
def setCurPass(self, passnum, numpasses):
"""setCurPass(SoGLRenderAction self, int const passnum, int const numpasses)"""
return _coin.SoGLRenderAction_setCurPass(self, passnum, numpasses)
def getCurPass(self):
"""getCurPass(SoGLRenderAction self) -> int"""
return _coin.SoGLRenderAction_getCurPass(self)
def abortNow(self):
"""abortNow(SoGLRenderAction self) -> SbBool"""
return _coin.SoGLRenderAction_abortNow(self)
def setRenderingIsRemote(self, isremote):
"""setRenderingIsRemote(SoGLRenderAction self, SbBool isremote)"""
return _coin.SoGLRenderAction_setRenderingIsRemote(self, isremote)
def getRenderingIsRemote(self):
"""getRenderingIsRemote(SoGLRenderAction self) -> SbBool"""
return _coin.SoGLRenderAction_getRenderingIsRemote(self)
def invalidateState(self):
"""invalidateState(SoGLRenderAction self)"""
return _coin.SoGLRenderAction_invalidateState(self)
def setSortedLayersNumPasses(self, num):
"""setSortedLayersNumPasses(SoGLRenderAction self, int num)"""
return _coin.SoGLRenderAction_setSortedLayersNumPasses(self, num)
def getSortedLayersNumPasses(self):
"""getSortedLayersNumPasses(SoGLRenderAction self) -> int"""
return _coin.SoGLRenderAction_getSortedLayersNumPasses(self)
def setSortedObjectOrderStrategy(self, strategy, cb=None, closure=None):
"""
setSortedObjectOrderStrategy(SoGLRenderAction self, SoGLRenderAction::SortedObjectOrderStrategy const strategy, SoGLSortedObjectOrderCB * cb=None, void * closure=None)
setSortedObjectOrderStrategy(SoGLRenderAction self, SoGLRenderAction::SortedObjectOrderStrategy const strategy, SoGLSortedObjectOrderCB * cb=None)
setSortedObjectOrderStrategy(SoGLRenderAction self, SoGLRenderAction::SortedObjectOrderStrategy const strategy)
"""
return _coin.SoGLRenderAction_setSortedObjectOrderStrategy(self, strategy, cb, closure)
def setDelayedObjDepthWrite(self, write):
"""setDelayedObjDepthWrite(SoGLRenderAction self, SbBool write)"""
return _coin.SoGLRenderAction_setDelayedObjDepthWrite(self, write)
def getDelayedObjDepthWrite(self):
"""getDelayedObjDepthWrite(SoGLRenderAction self) -> SbBool"""
return _coin.SoGLRenderAction_getDelayedObjDepthWrite(self)
def isRenderingTranspPaths(self):
"""isRenderingTranspPaths(SoGLRenderAction self) -> SbBool"""
return _coin.SoGLRenderAction_isRenderingTranspPaths(self)
def isRenderingTranspBackfaces(self):
"""isRenderingTranspBackfaces(SoGLRenderAction self) -> SbBool"""
return _coin.SoGLRenderAction_isRenderingTranspBackfaces(self)
def setPassCallback(self, *args):
"""
setPassCallback(SoGLRenderAction self, SoGLRenderPassCB *const func, void *const userdata)
setPassCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoGLRenderAction_setPassCallback(self, *args)
def setAbortCallback(self, *args):
"""
setAbortCallback(SoGLRenderAction self, SoGLRenderAction::SoGLRenderAbortCB *const func, void *const userdata)
setAbortCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoGLRenderAction_setAbortCallback(self, *args)
def addPreRenderCallback(self, *args):
"""
addPreRenderCallback(SoGLRenderAction self, SoGLPreRenderCB * func, void * userdata)
addPreRenderCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoGLRenderAction_addPreRenderCallback(self, *args)
def removePreRenderCallback(self, *args):
"""
removePreRenderCallback(SoGLRenderAction self, SoGLPreRenderCB * func, void * userdata)
removePreRenderCallback(SoGLRenderAction self, PyObject * pyfunc, PyObject * userdata)
"""
return _coin.SoGLRenderAction_removePreRenderCallback(self, *args)
def constructFromAction(action):
"""constructFromAction(SoAction action) -> SoGLRenderAction"""
return _coin.SoGLRenderAction_constructFromAction(action)
constructFromAction = staticmethod(constructFromAction)
SoGLRenderAction_swigregister = _coin.SoGLRenderAction_swigregister
SoGLRenderAction_swigregister(SoGLRenderAction)
def SoGLRenderAction_getClassTypeId():
"""SoGLRenderAction_getClassTypeId() -> SoType"""
return _coin.SoGLRenderAction_getClassTypeId()
def SoGLRenderAction_addMethod(type, method):
"""SoGLRenderAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoGLRenderAction_addMethod(type, method)
def SoGLRenderAction_enableElement(type, stackindex):
"""SoGLRenderAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoGLRenderAction_enableElement(type, stackindex)
def SoGLRenderAction_initClass():
"""SoGLRenderAction_initClass()"""
return _coin.SoGLRenderAction_initClass()
def SoGLRenderAction_constructFromAction(action):
"""SoGLRenderAction_constructFromAction(SoAction action) -> SoGLRenderAction"""
return _coin.SoGLRenderAction_constructFromAction(action)
class SoBoxHighlightRenderAction(SoGLRenderAction):
"""Proxy of C++ SoBoxHighlightRenderAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoBoxHighlightRenderAction self) -> SoType"""
return _coin.SoBoxHighlightRenderAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoBoxHighlightRenderAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoBoxHighlightRenderAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoBoxHighlightRenderAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoBoxHighlightRenderAction_initClass()
initClass = staticmethod(initClass)
def __init__(self, *args):
"""
__init__(SoBoxHighlightRenderAction self) -> SoBoxHighlightRenderAction
__init__(SoBoxHighlightRenderAction self, SbViewportRegion viewportregion) -> SoBoxHighlightRenderAction
"""
this = _coin.new_SoBoxHighlightRenderAction(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoBoxHighlightRenderAction
__del__ = lambda self: None
def apply(self, *args):
"""
apply(SoBoxHighlightRenderAction self, SoNode node)
apply(SoBoxHighlightRenderAction self, SoPath path)
apply(SoBoxHighlightRenderAction self, SoPathList pathlist, SbBool obeysrules=0)
apply(SoBoxHighlightRenderAction self, SoPathList pathlist)
"""
return _coin.SoBoxHighlightRenderAction_apply(self, *args)
def setVisible(self, visible):
"""setVisible(SoBoxHighlightRenderAction self, SbBool const visible)"""
return _coin.SoBoxHighlightRenderAction_setVisible(self, visible)
def isVisible(self):
"""isVisible(SoBoxHighlightRenderAction self) -> SbBool"""
return _coin.SoBoxHighlightRenderAction_isVisible(self)
def setColor(self, color):
"""setColor(SoBoxHighlightRenderAction self, SbColor color)"""
return _coin.SoBoxHighlightRenderAction_setColor(self, color)
def getColor(self):
"""getColor(SoBoxHighlightRenderAction self) -> SbColor"""
return _coin.SoBoxHighlightRenderAction_getColor(self)
def setLinePattern(self, pattern):
"""setLinePattern(SoBoxHighlightRenderAction self, unsigned short pattern)"""
return _coin.SoBoxHighlightRenderAction_setLinePattern(self, pattern)
def getLinePattern(self):
"""getLinePattern(SoBoxHighlightRenderAction self) -> unsigned short"""
return _coin.SoBoxHighlightRenderAction_getLinePattern(self)
def setLineWidth(self, width):
"""setLineWidth(SoBoxHighlightRenderAction self, float const width)"""
return _coin.SoBoxHighlightRenderAction_setLineWidth(self, width)
def getLineWidth(self):
"""getLineWidth(SoBoxHighlightRenderAction self) -> float"""
return _coin.SoBoxHighlightRenderAction_getLineWidth(self)
SoBoxHighlightRenderAction_swigregister = _coin.SoBoxHighlightRenderAction_swigregister
SoBoxHighlightRenderAction_swigregister(SoBoxHighlightRenderAction)
def SoBoxHighlightRenderAction_getClassTypeId():
"""SoBoxHighlightRenderAction_getClassTypeId() -> SoType"""
return _coin.SoBoxHighlightRenderAction_getClassTypeId()
def SoBoxHighlightRenderAction_addMethod(type, method):
"""SoBoxHighlightRenderAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoBoxHighlightRenderAction_addMethod(type, method)
def SoBoxHighlightRenderAction_enableElement(type, stackindex):
"""SoBoxHighlightRenderAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoBoxHighlightRenderAction_enableElement(type, stackindex)
def SoBoxHighlightRenderAction_initClass():
"""SoBoxHighlightRenderAction_initClass()"""
return _coin.SoBoxHighlightRenderAction_initClass()
class SoLineHighlightRenderAction(SoGLRenderAction):
"""Proxy of C++ SoLineHighlightRenderAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoLineHighlightRenderAction self) -> SoType"""
return _coin.SoLineHighlightRenderAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoLineHighlightRenderAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoLineHighlightRenderAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoLineHighlightRenderAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoLineHighlightRenderAction_initClass()
initClass = staticmethod(initClass)
def __init__(self, *args):
"""
__init__(SoLineHighlightRenderAction self) -> SoLineHighlightRenderAction
__init__(SoLineHighlightRenderAction self, SbViewportRegion viewportregion) -> SoLineHighlightRenderAction
"""
this = _coin.new_SoLineHighlightRenderAction(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoLineHighlightRenderAction
__del__ = lambda self: None
def apply(self, *args):
"""
apply(SoLineHighlightRenderAction self, SoNode node)
apply(SoLineHighlightRenderAction self, SoPath path)
apply(SoLineHighlightRenderAction self, SoPathList pathlist, SbBool obeysrules=0)
apply(SoLineHighlightRenderAction self, SoPathList pathlist)
"""
return _coin.SoLineHighlightRenderAction_apply(self, *args)
def setVisible(self, visible):
"""setVisible(SoLineHighlightRenderAction self, SbBool const visible)"""
return _coin.SoLineHighlightRenderAction_setVisible(self, visible)
def isVisible(self):
"""isVisible(SoLineHighlightRenderAction self) -> SbBool"""
return _coin.SoLineHighlightRenderAction_isVisible(self)
def setColor(self, color):
"""setColor(SoLineHighlightRenderAction self, SbColor color)"""
return _coin.SoLineHighlightRenderAction_setColor(self, color)
def getColor(self):
"""getColor(SoLineHighlightRenderAction self) -> SbColor"""
return _coin.SoLineHighlightRenderAction_getColor(self)
def setLinePattern(self, pattern):
"""setLinePattern(SoLineHighlightRenderAction self, uint16_t pattern)"""
return _coin.SoLineHighlightRenderAction_setLinePattern(self, pattern)
def getLinePattern(self):
"""getLinePattern(SoLineHighlightRenderAction self) -> uint16_t"""
return _coin.SoLineHighlightRenderAction_getLinePattern(self)
def setLineWidth(self, width):
"""setLineWidth(SoLineHighlightRenderAction self, float const width)"""
return _coin.SoLineHighlightRenderAction_setLineWidth(self, width)
def getLineWidth(self):
"""getLineWidth(SoLineHighlightRenderAction self) -> float"""
return _coin.SoLineHighlightRenderAction_getLineWidth(self)
SoLineHighlightRenderAction_swigregister = _coin.SoLineHighlightRenderAction_swigregister
SoLineHighlightRenderAction_swigregister(SoLineHighlightRenderAction)
def SoLineHighlightRenderAction_getClassTypeId():
"""SoLineHighlightRenderAction_getClassTypeId() -> SoType"""
return _coin.SoLineHighlightRenderAction_getClassTypeId()
def SoLineHighlightRenderAction_addMethod(type, method):
"""SoLineHighlightRenderAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoLineHighlightRenderAction_addMethod(type, method)
def SoLineHighlightRenderAction_enableElement(type, stackindex):
"""SoLineHighlightRenderAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoLineHighlightRenderAction_enableElement(type, stackindex)
def SoLineHighlightRenderAction_initClass():
"""SoLineHighlightRenderAction_initClass()"""
return _coin.SoLineHighlightRenderAction_initClass()
class SbBox3f(object):
"""Proxy of C++ SbBox3f class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbBox3f self) -> SbBox3f
__init__(SbBox3f self, float xmin, float ymin, float zmin, float xmax, float ymax, float zmax) -> SbBox3f
__init__(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint) -> SbBox3f
__init__(SbBox3f self, SbBox3d box) -> SbBox3f
__init__(SbBox3f self, SbBox3s box) -> SbBox3f
__init__(SbBox3f self, SbBox3i32 box) -> SbBox3f
"""
this = _coin.new_SbBox3f(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def setBounds(self, *args):
"""
setBounds(SbBox3f self, float xmin, float ymin, float zmin, float xmax, float ymax, float zmax) -> SbBox3f
setBounds(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint) -> SbBox3f
setBounds(SbBox3f self, SbBox3d box) -> SbBox3f
setBounds(SbBox3f self, SbBox3s box) -> SbBox3f
setBounds(SbBox3f self, SbBox3i32 box) -> SbBox3f
"""
return _coin.SbBox3f_setBounds(self, *args)
def getBounds(self, *args):
"""
getBounds(SbBox3f self, float & xmin, float & ymin, float & zmin, float & xmax, float & ymax, float & zmax)
getBounds(SbBox3f self, SbVec3f minpoint, SbVec3f maxpoint)
"""
return _coin.SbBox3f_getBounds(self, *args)
def getMin(self, *args):
"""
getMin(SbBox3f self) -> SbVec3f
getMin(SbBox3f self) -> SbVec3f
"""
return _coin.SbBox3f_getMin(self, *args)
def getMax(self, *args):
"""
getMax(SbBox3f self) -> SbVec3f
getMax(SbBox3f self) -> SbVec3f
"""
return _coin.SbBox3f_getMax(self, *args)
def extendBy(self, *args):
"""
extendBy(SbBox3f self, SbVec3f pt)
extendBy(SbBox3f self, SbBox3f box)
"""
return _coin.SbBox3f_extendBy(self, *args)
def transform(self, matrix):
"""transform(SbBox3f self, SbMatrix matrix)"""
return _coin.SbBox3f_transform(self, matrix)
def makeEmpty(self):
"""makeEmpty(SbBox3f self)"""
return _coin.SbBox3f_makeEmpty(self)
def isEmpty(self):
"""isEmpty(SbBox3f self) -> SbBool"""
return _coin.SbBox3f_isEmpty(self)
def hasVolume(self):
"""hasVolume(SbBox3f self) -> SbBool"""
return _coin.SbBox3f_hasVolume(self)
def getVolume(self):
"""getVolume(SbBox3f self) -> float"""
return _coin.SbBox3f_getVolume(self)
def intersect(self, *args):
"""
intersect(SbBox3f self, SbVec3f pt) -> SbBool
intersect(SbBox3f self, SbBox3f box) -> SbBool
"""
return _coin.SbBox3f_intersect(self, *args)
def getClosestPoint(self, point):
"""getClosestPoint(SbBox3f self, SbVec3f point) -> SbVec3f"""
return _coin.SbBox3f_getClosestPoint(self, point)
def outside(self, mvp, cullbits):
"""outside(SbBox3f self, SbMatrix mvp, int & cullbits) -> SbBool"""
return _coin.SbBox3f_outside(self, mvp, cullbits)
def getCenter(self):
"""getCenter(SbBox3f self) -> SbVec3f"""
return _coin.SbBox3f_getCenter(self)
def getOrigin(self, originX, originY, originZ):
"""getOrigin(SbBox3f self, float & originX, float & originY, float & originZ)"""
return _coin.SbBox3f_getOrigin(self, originX, originY, originZ)
def getSize(self, *args):
"""
getSize(SbBox3f self, float & sizeX, float & sizeY, float & sizeZ)
getSize(SbBox3f self) -> SbVec3f
"""
return _coin.SbBox3f_getSize(self, *args)
def getSpan(self, dir, dmin, dmax):
"""getSpan(SbBox3f self, SbVec3f dir, float & dmin, float & dmax)"""
return _coin.SbBox3f_getSpan(self, dir, dmin, dmax)
def output(self, file):
"""output(SbBox3f self, FILE * file)"""
return _coin.SbBox3f_output(self, file)
def __eq__(self, u):
"""__eq__(SbBox3f self, SbBox3f u) -> int"""
return _coin.SbBox3f___eq__(self, u)
def __ne__(self, u):
"""__ne__(SbBox3f self, SbBox3f u) -> int"""
return _coin.SbBox3f___ne__(self, u)
__swig_destroy__ = _coin.delete_SbBox3f
__del__ = lambda self: None
SbBox3f_swigregister = _coin.SbBox3f_swigregister
SbBox3f_swigregister(SbBox3f)
class SbMatrix(object):
"""Proxy of C++ SbMatrix class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbMatrix self) -> SbMatrix
__init__(SbMatrix self, float const a11, float const a12, float const a13, float const a14, float const a21, float const a22, float const a23, float const a24, float const a31, float const a32, float const a33, float const a34, float const a41, float const a42, float const a43, float const a44) -> SbMatrix
__init__(SbMatrix self, SbMat const & matrix) -> SbMatrix
__init__(SbMatrix self, SbMat const * matrix) -> SbMatrix
__init__(SbMatrix self, SbDPMatrix matrix) -> SbMatrix
"""
this = _coin.new_SbMatrix(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SbMatrix
__del__ = lambda self: None
def setValue(self, *args):
"""
setValue(SbMatrix self, SbMat const & m)
setValue(SbMatrix self, SbDPMatrix m)
setValue(SbMatrix self, float const * pMat)
"""
return _coin.SbMatrix_setValue(self, *args)
def makeIdentity(self):
"""makeIdentity(SbMatrix self)"""
return _coin.SbMatrix_makeIdentity(self)
def setRotate(self, q):
"""setRotate(SbMatrix self, SbRotation q)"""
return _coin.SbMatrix_setRotate(self, q)
def inverse(self):
"""inverse(SbMatrix self) -> SbMatrix"""
return _coin.SbMatrix_inverse(self)
def det3(self, *args):
"""
det3(SbMatrix self, int r1, int r2, int r3, int c1, int c2, int c3) -> float
det3(SbMatrix self) -> float
"""
return _coin.SbMatrix_det3(self, *args)
def det4(self):
"""det4(SbMatrix self) -> float"""
return _coin.SbMatrix_det4(self)
def equals(self, m, tolerance):
"""equals(SbMatrix self, SbMatrix m, float tolerance) -> SbBool"""
return _coin.SbMatrix_equals(self, m, tolerance)
def getValue(self, *args):
"""
getValue(SbMatrix self) -> SbMat const
getValue(SbMatrix self, SbMat & m)
"""
return _coin.SbMatrix_getValue(self, *args)
def identity():
"""identity() -> SbMatrix"""
return _coin.SbMatrix_identity()
identity = staticmethod(identity)
def setScale(self, *args):
"""
setScale(SbMatrix self, float const s)
setScale(SbMatrix self, SbVec3f s)
"""
return _coin.SbMatrix_setScale(self, *args)
def setTranslate(self, t):
"""setTranslate(SbMatrix self, SbVec3f t)"""
return _coin.SbMatrix_setTranslate(self, t)
def setTransform(self, *args):
"""
setTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s)
setTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s, SbRotation so)
setTransform(SbMatrix self, SbVec3f translation, SbRotation rotation, SbVec3f scaleFactor, SbRotation scaleOrientation, SbVec3f center)
"""
return _coin.SbMatrix_setTransform(self, *args)
def factor(self, r, s, u, t, proj):
"""factor(SbMatrix self, SbMatrix r, SbVec3f s, SbMatrix u, SbVec3f t, SbMatrix proj) -> SbBool"""
return _coin.SbMatrix_factor(self, r, s, u, t, proj)
def LUDecomposition(self, index, d):
"""LUDecomposition(SbMatrix self, int [4] index, float & d) -> SbBool"""
return _coin.SbMatrix_LUDecomposition(self, index, d)
def LUBackSubstitution(self, index, b):
"""LUBackSubstitution(SbMatrix self, int [4] index, float [4] b)"""
return _coin.SbMatrix_LUBackSubstitution(self, index, b)
def transpose(self):
"""transpose(SbMatrix self) -> SbMatrix"""
return _coin.SbMatrix_transpose(self)
def multRight(self, m):
"""multRight(SbMatrix self, SbMatrix m) -> SbMatrix"""
return _coin.SbMatrix_multRight(self, m)
def multLeft(self, m):
"""multLeft(SbMatrix self, SbMatrix m) -> SbMatrix"""
return _coin.SbMatrix_multLeft(self, m)
def multMatrixVec(self, src):
"""multMatrixVec(SbMatrix self, SbVec3f src)"""
return _coin.SbMatrix_multMatrixVec(self, src)
def multDirMatrix(self, src):
"""multDirMatrix(SbMatrix self, SbVec3f src)"""
return _coin.SbMatrix_multDirMatrix(self, src)
def multLineMatrix(self, src, dst):
"""multLineMatrix(SbMatrix self, SbLine src, SbLine dst)"""
return _coin.SbMatrix_multLineMatrix(self, src, dst)
def multVecMatrix(self, *args):
"""
multVecMatrix(SbMatrix self, SbVec3f src)
multVecMatrix(SbMatrix self, SbVec4f src)
"""
return _coin.SbMatrix_multVecMatrix(self, *args)
def output(self, fp):
"""output(SbMatrix self, FILE * fp)"""
return _coin.SbMatrix_output(self, fp)
def __imul__(self, m):
"""__imul__(SbMatrix self, SbMatrix m) -> SbMatrix"""
return _coin.SbMatrix___imul__(self, m)
def getTransform(self, *args):
"""
getTransform(SbMatrix self, SbVec3f t, SbRotation r, SbVec3f s, SbRotation so)
getTransform(SbMatrix self) -> PyObject
getTransform(SbMatrix self, SbVec3f center) -> PyObject *
"""
return _coin.SbMatrix_getTransform(self, *args)
def __mul__(self, *args):
"""
__mul__(SbMatrix self, SbMatrix u) -> SbMatrix
__mul__(SbMatrix self, SbVec3f u) -> SbVec3f
"""
return _coin.SbMatrix___mul__(self, *args)
def __rmul__(self, u):
"""__rmul__(SbMatrix self, SbVec3f u) -> SbVec3f"""
return _coin.SbMatrix___rmul__(self, u)
def __eq__(self, u):
"""__eq__(SbMatrix self, SbMatrix u) -> int"""
return _coin.SbMatrix___eq__(self, u)
def __ne__(self, u):
"""__ne__(SbMatrix self, SbMatrix u) -> int"""
return _coin.SbMatrix___ne__(self, u)
def __getitem__(self, i):
"""__getitem__(SbMatrix self, int i) -> float const *"""
return _coin.SbMatrix___getitem__(self, i)
SbMatrix_swigregister = _coin.SbMatrix_swigregister
SbMatrix_swigregister(SbMatrix)
def SbMatrix_identity():
"""SbMatrix_identity() -> SbMatrix"""
return _coin.SbMatrix_identity()
class SbXfBox3f(SbBox3f):
"""Proxy of C++ SbXfBox3f class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbXfBox3f self) -> SbXfBox3f
__init__(SbXfBox3f self, SbVec3f boxmin, SbVec3f boxmax) -> SbXfBox3f
__init__(SbXfBox3f self, SbBox3f box) -> SbXfBox3f
"""
this = _coin.new_SbXfBox3f(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SbXfBox3f
__del__ = lambda self: None
def setTransform(self, m):
"""setTransform(SbXfBox3f self, SbMatrix m)"""
return _coin.SbXfBox3f_setTransform(self, m)
def getTransform(self):
"""getTransform(SbXfBox3f self) -> SbMatrix"""
return _coin.SbXfBox3f_getTransform(self)
def getInverse(self):
"""getInverse(SbXfBox3f self) -> SbMatrix"""
return _coin.SbXfBox3f_getInverse(self)
def getCenter(self):
"""getCenter(SbXfBox3f self) -> SbVec3f"""
return _coin.SbXfBox3f_getCenter(self)
def extendBy(self, *args):
"""
extendBy(SbXfBox3f self, SbVec3f pt)
extendBy(SbXfBox3f self, SbBox3f bb)
extendBy(SbXfBox3f self, SbXfBox3f bb)
"""
return _coin.SbXfBox3f_extendBy(self, *args)
def intersect(self, *args):
"""
intersect(SbXfBox3f self, SbVec3f pt) -> SbBool
intersect(SbXfBox3f self, SbBox3f bb) -> SbBool
intersect(SbXfBox3f self, SbXfBox3f bb) -> SbBool
"""
return _coin.SbXfBox3f_intersect(self, *args)
def getSpan(self, direction, dMin, dMax):
"""getSpan(SbXfBox3f self, SbVec3f direction, float & dMin, float & dMax)"""
return _coin.SbXfBox3f_getSpan(self, direction, dMin, dMax)
def project(self):
"""project(SbXfBox3f self) -> SbBox3f"""
return _coin.SbXfBox3f_project(self)
def transform(self, m):
"""transform(SbXfBox3f self, SbMatrix m)"""
return _coin.SbXfBox3f_transform(self, m)
def getVolume(self):
"""getVolume(SbXfBox3f self) -> float"""
return _coin.SbXfBox3f_getVolume(self)
def output(self, file):
"""output(SbXfBox3f self, FILE * file)"""
return _coin.SbXfBox3f_output(self, file)
def __eq__(self, u):
"""__eq__(SbXfBox3f self, SbXfBox3f u) -> int"""
return _coin.SbXfBox3f___eq__(self, u)
def __ne__(self, u):
"""__ne__(SbXfBox3f self, SbXfBox3f u) -> int"""
return _coin.SbXfBox3f___ne__(self, u)
SbXfBox3f_swigregister = _coin.SbXfBox3f_swigregister
SbXfBox3f_swigregister(SbXfBox3f)
class SoGetBoundingBoxAction(SoAction):
"""Proxy of C++ SoGetBoundingBoxAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoGetBoundingBoxAction self) -> SoType"""
return _coin.SoGetBoundingBoxAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGetBoundingBoxAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoGetBoundingBoxAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoGetBoundingBoxAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoGetBoundingBoxAction_initClass()
initClass = staticmethod(initClass)
def __init__(self, vp):
"""__init__(SoGetBoundingBoxAction self, SbViewportRegion vp) -> SoGetBoundingBoxAction"""
this = _coin.new_SoGetBoundingBoxAction(vp)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoGetBoundingBoxAction
__del__ = lambda self: None
TRANSFORM = _coin.SoGetBoundingBoxAction_TRANSFORM
BBOX = _coin.SoGetBoundingBoxAction_BBOX
ALL = _coin.SoGetBoundingBoxAction_ALL
def setViewportRegion(self, newregion):
"""setViewportRegion(SoGetBoundingBoxAction self, SbViewportRegion newregion)"""
return _coin.SoGetBoundingBoxAction_setViewportRegion(self, newregion)
def getViewportRegion(self):
"""getViewportRegion(SoGetBoundingBoxAction self) -> SbViewportRegion"""
return _coin.SoGetBoundingBoxAction_getViewportRegion(self)
def getBoundingBox(self):
"""getBoundingBox(SoGetBoundingBoxAction self) -> SbBox3f"""
return _coin.SoGetBoundingBoxAction_getBoundingBox(self)
def getXfBoundingBox(self):
"""getXfBoundingBox(SoGetBoundingBoxAction self) -> SbXfBox3f"""
return _coin.SoGetBoundingBoxAction_getXfBoundingBox(self)
def getCenter(self):
"""getCenter(SoGetBoundingBoxAction self) -> SbVec3f"""
return _coin.SoGetBoundingBoxAction_getCenter(self)
def setInCameraSpace(self, flag):
"""setInCameraSpace(SoGetBoundingBoxAction self, SbBool const flag)"""
return _coin.SoGetBoundingBoxAction_setInCameraSpace(self, flag)
def isInCameraSpace(self):
"""isInCameraSpace(SoGetBoundingBoxAction self) -> SbBool"""
return _coin.SoGetBoundingBoxAction_isInCameraSpace(self)
def setResetPath(self, *args):
"""
setResetPath(SoGetBoundingBoxAction self, SoPath path, SbBool const resetbefore=1, SoGetBoundingBoxAction::ResetType const what)
setResetPath(SoGetBoundingBoxAction self, SoPath path, SbBool const resetbefore=1)
setResetPath(SoGetBoundingBoxAction self, SoPath path)
"""
return _coin.SoGetBoundingBoxAction_setResetPath(self, *args)
def getResetPath(self):
"""getResetPath(SoGetBoundingBoxAction self) -> SoPath"""
return _coin.SoGetBoundingBoxAction_getResetPath(self)
def isResetPath(self):
"""isResetPath(SoGetBoundingBoxAction self) -> SbBool"""
return _coin.SoGetBoundingBoxAction_isResetPath(self)
def isResetBefore(self):
"""isResetBefore(SoGetBoundingBoxAction self) -> SbBool"""
return _coin.SoGetBoundingBoxAction_isResetBefore(self)
def getWhatReset(self):
"""getWhatReset(SoGetBoundingBoxAction self) -> SoGetBoundingBoxAction::ResetType"""
return _coin.SoGetBoundingBoxAction_getWhatReset(self)
def checkResetBefore(self):
"""checkResetBefore(SoGetBoundingBoxAction self)"""
return _coin.SoGetBoundingBoxAction_checkResetBefore(self)
def checkResetAfter(self):
"""checkResetAfter(SoGetBoundingBoxAction self)"""
return _coin.SoGetBoundingBoxAction_checkResetAfter(self)
def extendBy(self, *args):
"""
extendBy(SoGetBoundingBoxAction self, SbBox3f box)
extendBy(SoGetBoundingBoxAction self, SbXfBox3f box)
"""
return _coin.SoGetBoundingBoxAction_extendBy(self, *args)
def setCenter(self, center, transformcenter):
"""setCenter(SoGetBoundingBoxAction self, SbVec3f center, SbBool const transformcenter)"""
return _coin.SoGetBoundingBoxAction_setCenter(self, center, transformcenter)
def isCenterSet(self):
"""isCenterSet(SoGetBoundingBoxAction self) -> SbBool"""
return _coin.SoGetBoundingBoxAction_isCenterSet(self)
def resetCenter(self):
"""resetCenter(SoGetBoundingBoxAction self)"""
return _coin.SoGetBoundingBoxAction_resetCenter(self)
SoGetBoundingBoxAction_swigregister = _coin.SoGetBoundingBoxAction_swigregister
SoGetBoundingBoxAction_swigregister(SoGetBoundingBoxAction)
def SoGetBoundingBoxAction_getClassTypeId():
"""SoGetBoundingBoxAction_getClassTypeId() -> SoType"""
return _coin.SoGetBoundingBoxAction_getClassTypeId()
def SoGetBoundingBoxAction_addMethod(type, method):
"""SoGetBoundingBoxAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoGetBoundingBoxAction_addMethod(type, method)
def SoGetBoundingBoxAction_enableElement(type, stackindex):
"""SoGetBoundingBoxAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoGetBoundingBoxAction_enableElement(type, stackindex)
def SoGetBoundingBoxAction_initClass():
"""SoGetBoundingBoxAction_initClass()"""
return _coin.SoGetBoundingBoxAction_initClass()
class SbVec4f(object):
"""Proxy of C++ SbVec4f class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbVec4f self) -> SbVec4f
__init__(SbVec4f self, float const [4] v) -> SbVec4f
__init__(SbVec4f self, float x, float y, float z, float w) -> SbVec4f
__init__(SbVec4f self, SbVec4d v) -> SbVec4f
__init__(SbVec4f self, SbVec4b v) -> SbVec4f
__init__(SbVec4f self, SbVec4s v) -> SbVec4f
__init__(SbVec4f self, SbVec4i32 v) -> SbVec4f
"""
this = _coin.new_SbVec4f(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def setValue(self, *args):
"""
setValue(SbVec4f self, float const [4] v) -> SbVec4f
setValue(SbVec4f self, float x, float y, float z, float w) -> SbVec4f
setValue(SbVec4f self, SbVec4d v) -> SbVec4f
setValue(SbVec4f self, SbVec4b v) -> SbVec4f
setValue(SbVec4f self, SbVec4s v) -> SbVec4f
setValue(SbVec4f self, SbVec4i32 v) -> SbVec4f
"""
return _coin.SbVec4f_setValue(self, *args)
def getValue(self):
"""getValue(SbVec4f self) -> float const *"""
return _coin.SbVec4f_getValue(self)
def equals(self, v, tolerance):
"""equals(SbVec4f self, SbVec4f v, float tolerance) -> SbBool"""
return _coin.SbVec4f_equals(self, v, tolerance)
def dot(self, v):
"""dot(SbVec4f self, SbVec4f v) -> float"""
return _coin.SbVec4f_dot(self, v)
def getReal(self, v):
"""getReal(SbVec4f self, SbVec3f v)"""
return _coin.SbVec4f_getReal(self, v)
def length(self):
"""length(SbVec4f self) -> float"""
return _coin.SbVec4f_length(self)
def sqrLength(self):
"""sqrLength(SbVec4f self) -> float"""
return _coin.SbVec4f_sqrLength(self)
def negate(self):
"""negate(SbVec4f self)"""
return _coin.SbVec4f_negate(self)
def normalize(self):
"""normalize(SbVec4f self) -> float"""
return _coin.SbVec4f_normalize(self)
def __imul__(self, d):
"""__imul__(SbVec4f self, float d) -> SbVec4f"""
return _coin.SbVec4f___imul__(self, d)
def __idiv__(self, d):
"""__idiv__(SbVec4f self, float d) -> SbVec4f"""
return _coin.SbVec4f___idiv__(self, d)
def __iadd__(self, v):
"""__iadd__(SbVec4f self, SbVec4f v) -> SbVec4f"""
return _coin.SbVec4f___iadd__(self, v)
def __isub__(self, v):
"""__isub__(SbVec4f self, SbVec4f v) -> SbVec4f"""
return _coin.SbVec4f___isub__(self, v)
def __neg__(self):
"""__neg__(SbVec4f self) -> SbVec4f"""
return _coin.SbVec4f___neg__(self)
def output(self, fp):
"""output(SbVec4f self, FILE * fp)"""
return _coin.SbVec4f_output(self, fp)
def __add__(self, u):
"""__add__(SbVec4f self, SbVec4f u) -> SbVec4f"""
return _coin.SbVec4f___add__(self, u)
def __sub__(self, u):
"""__sub__(SbVec4f self, SbVec4f u) -> SbVec4f"""
return _coin.SbVec4f___sub__(self, u)
def __mul__(self, *args):
"""
__mul__(SbVec4f self, float const d) -> SbVec4f
__mul__(SbVec4f self, SbMatrix m) -> SbVec4f
"""
return _coin.SbVec4f___mul__(self, *args)
def __rmul__(self, d):
"""__rmul__(SbVec4f self, float const d) -> SbVec4f"""
return _coin.SbVec4f___rmul__(self, d)
def __div__(self, d):
"""__div__(SbVec4f self, float const d) -> SbVec4f"""
return _coin.SbVec4f___div__(self, d)
def __truediv__(self, d):
"""__truediv__(SbVec4f self, float const d) -> SbVec4f"""
return _coin.SbVec4f___truediv__(self, d)
def __eq__(self, u):
"""__eq__(SbVec4f self, SbVec4f u) -> int"""
return _coin.SbVec4f___eq__(self, u)
def __nq__(self, u):
"""__nq__(SbVec4f self, SbVec4f u) -> int"""
return _coin.SbVec4f___nq__(self, u)
def __getitem__(self, i):
"""__getitem__(SbVec4f self, int i) -> float"""
return _coin.SbVec4f___getitem__(self, i)
def __setitem__(self, i, value):
"""__setitem__(SbVec4f self, int i, float value)"""
return _coin.SbVec4f___setitem__(self, i, value)
def __iter__(self):
for i in range(4):
yield self[i]
def __len__(self):
return 4
__swig_destroy__ = _coin.delete_SbVec4f
__del__ = lambda self: None
SbVec4f_swigregister = _coin.SbVec4f_swigregister
SbVec4f_swigregister(SbVec4f)
class SbRotation(object):
"""Proxy of C++ SbRotation class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbRotation self) -> SbRotation
__init__(SbRotation self, SbVec3f axis, float const radians) -> SbRotation
__init__(SbRotation self, float const [4] q) -> SbRotation
__init__(SbRotation self, float const q0, float const q1, float const q2, float const q3) -> SbRotation
__init__(SbRotation self, SbMatrix m) -> SbRotation
__init__(SbRotation self, SbVec3f rotateFrom, SbVec3f rotateTo) -> SbRotation
"""
this = _coin.new_SbRotation(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def getValue(self):
"""getValue(SbRotation self) -> float const *"""
return _coin.SbRotation_getValue(self)
def getAxisAngle(self):
"""getAxisAngle(SbRotation self)"""
return _coin.SbRotation_getAxisAngle(self)
def getMatrix(self):
"""getMatrix(SbRotation self)"""
return _coin.SbRotation_getMatrix(self)
def invert(self):
"""invert(SbRotation self) -> SbRotation"""
return _coin.SbRotation_invert(self)
def inverse(self):
"""inverse(SbRotation self) -> SbRotation"""
return _coin.SbRotation_inverse(self)
def setValue(self, *args):
"""
setValue(SbRotation self, float const q0, float const q1, float const q2, float const q3) -> SbRotation
setValue(SbRotation self, float const [4] q) -> SbRotation
setValue(SbRotation self, SbMatrix m) -> SbRotation
setValue(SbRotation self, SbVec3f axis, float const radians) -> SbRotation
setValue(SbRotation self, SbVec3f rotateFrom, SbVec3f rotateTo) -> SbRotation
"""
return _coin.SbRotation_setValue(self, *args)
def __imul__(self, *args):
"""
__imul__(SbRotation self, SbRotation q) -> SbRotation
__imul__(SbRotation self, float const s) -> SbRotation
"""
return _coin.SbRotation___imul__(self, *args)
def equals(self, r, tolerance):
"""equals(SbRotation self, SbRotation r, float tolerance) -> SbBool"""
return _coin.SbRotation_equals(self, r, tolerance)
def multVec(self, src):
"""multVec(SbRotation self, SbVec3f src)"""
return _coin.SbRotation_multVec(self, src)
def scaleAngle(self, scaleFactor):
"""scaleAngle(SbRotation self, float const scaleFactor)"""
return _coin.SbRotation_scaleAngle(self, scaleFactor)
def slerp(rot0, rot1, t):
"""slerp(SbRotation rot0, SbRotation rot1, float t) -> SbRotation"""
return _coin.SbRotation_slerp(rot0, rot1, t)
slerp = staticmethod(slerp)
def identity():
"""identity() -> SbRotation"""
return _coin.SbRotation_identity()
identity = staticmethod(identity)
def toString(self):
"""toString(SbRotation self) -> SbString"""
return _coin.SbRotation_toString(self)
def fromString(self, str):
"""fromString(SbRotation self, SbString str) -> SbBool"""
return _coin.SbRotation_fromString(self, str)
def output(self, fp):
"""output(SbRotation self, FILE * fp)"""
return _coin.SbRotation_output(self, fp)
def __mul__(self, *args):
"""
__mul__(SbRotation self, SbRotation u) -> SbRotation
__mul__(SbRotation self, double const d) -> SbRotation
__mul__(SbRotation self, SbVec3f v) -> SbVec3f
"""
return _coin.SbRotation___mul__(self, *args)
def __eq__(self, u):
"""__eq__(SbRotation self, SbRotation u) -> int"""
return _coin.SbRotation___eq__(self, u)
def __nq__(self, u):
"""__nq__(SbRotation self, SbRotation u) -> int"""
return _coin.SbRotation___nq__(self, u)
def __imul__(self, other):
return self * other
__swig_destroy__ = _coin.delete_SbRotation
__del__ = lambda self: None
SbRotation_swigregister = _coin.SbRotation_swigregister
SbRotation_swigregister(SbRotation)
def SbRotation_slerp(rot0, rot1, t):
"""SbRotation_slerp(SbRotation rot0, SbRotation rot1, float t) -> SbRotation"""
return _coin.SbRotation_slerp(rot0, rot1, t)
def SbRotation_identity():
"""SbRotation_identity() -> SbRotation"""
return _coin.SbRotation_identity()
class SoGetMatrixAction(SoAction):
"""Proxy of C++ SoGetMatrixAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoGetMatrixAction self) -> SoType"""
return _coin.SoGetMatrixAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGetMatrixAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoGetMatrixAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoGetMatrixAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoGetMatrixAction_initClass()
initClass = staticmethod(initClass)
def __init__(self, region):
"""__init__(SoGetMatrixAction self, SbViewportRegion region) -> SoGetMatrixAction"""
this = _coin.new_SoGetMatrixAction(region)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoGetMatrixAction
__del__ = lambda self: None
def setViewportRegion(self, region):
"""setViewportRegion(SoGetMatrixAction self, SbViewportRegion region)"""
return _coin.SoGetMatrixAction_setViewportRegion(self, region)
def getViewportRegion(self):
"""getViewportRegion(SoGetMatrixAction self) -> SbViewportRegion"""
return _coin.SoGetMatrixAction_getViewportRegion(self)
def getMatrix(self):
"""getMatrix(SoGetMatrixAction self) -> SbMatrix"""
return _coin.SoGetMatrixAction_getMatrix(self)
def getInverse(self):
"""getInverse(SoGetMatrixAction self) -> SbMatrix"""
return _coin.SoGetMatrixAction_getInverse(self)
def getTextureMatrix(self):
"""getTextureMatrix(SoGetMatrixAction self) -> SbMatrix"""
return _coin.SoGetMatrixAction_getTextureMatrix(self)
def getTextureInverse(self):
"""getTextureInverse(SoGetMatrixAction self) -> SbMatrix"""
return _coin.SoGetMatrixAction_getTextureInverse(self)
SoGetMatrixAction_swigregister = _coin.SoGetMatrixAction_swigregister
SoGetMatrixAction_swigregister(SoGetMatrixAction)
def SoGetMatrixAction_getClassTypeId():
"""SoGetMatrixAction_getClassTypeId() -> SoType"""
return _coin.SoGetMatrixAction_getClassTypeId()
def SoGetMatrixAction_addMethod(type, method):
"""SoGetMatrixAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoGetMatrixAction_addMethod(type, method)
def SoGetMatrixAction_enableElement(type, stackindex):
"""SoGetMatrixAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoGetMatrixAction_enableElement(type, stackindex)
def SoGetMatrixAction_initClass():
"""SoGetMatrixAction_initClass()"""
return _coin.SoGetMatrixAction_initClass()
class SoGetPrimitiveCountAction(SoAction):
"""Proxy of C++ SoGetPrimitiveCountAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoGetPrimitiveCountAction self) -> SoType"""
return _coin.SoGetPrimitiveCountAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGetPrimitiveCountAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoGetPrimitiveCountAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoGetPrimitiveCountAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoGetPrimitiveCountAction_initClass()
initClass = staticmethod(initClass)
def __init__(self, *args):
"""
__init__(SoGetPrimitiveCountAction self) -> SoGetPrimitiveCountAction
__init__(SoGetPrimitiveCountAction self, SbViewportRegion vp) -> SoGetPrimitiveCountAction
"""
this = _coin.new_SoGetPrimitiveCountAction(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoGetPrimitiveCountAction
__del__ = lambda self: None
def getTriangleCount(self):
"""getTriangleCount(SoGetPrimitiveCountAction self) -> int"""
return _coin.SoGetPrimitiveCountAction_getTriangleCount(self)
def getLineCount(self):
"""getLineCount(SoGetPrimitiveCountAction self) -> int"""
return _coin.SoGetPrimitiveCountAction_getLineCount(self)
def getPointCount(self):
"""getPointCount(SoGetPrimitiveCountAction self) -> int"""
return _coin.SoGetPrimitiveCountAction_getPointCount(self)
def getTextCount(self):
"""getTextCount(SoGetPrimitiveCountAction self) -> int"""
return _coin.SoGetPrimitiveCountAction_getTextCount(self)
def getImageCount(self):
"""getImageCount(SoGetPrimitiveCountAction self) -> int"""
return _coin.SoGetPrimitiveCountAction_getImageCount(self)
def containsNoPrimitives(self):
"""containsNoPrimitives(SoGetPrimitiveCountAction self) -> SbBool"""
return _coin.SoGetPrimitiveCountAction_containsNoPrimitives(self)
def containsNonTriangleShapes(self):
"""containsNonTriangleShapes(SoGetPrimitiveCountAction self) -> SbBool"""
return _coin.SoGetPrimitiveCountAction_containsNonTriangleShapes(self)
def is3DTextCountedAsTriangles(self):
"""is3DTextCountedAsTriangles(SoGetPrimitiveCountAction self) -> SbBool"""
return _coin.SoGetPrimitiveCountAction_is3DTextCountedAsTriangles(self)
def setCount3DTextAsTriangles(self, flag):
"""setCount3DTextAsTriangles(SoGetPrimitiveCountAction self, SbBool const flag)"""
return _coin.SoGetPrimitiveCountAction_setCount3DTextAsTriangles(self, flag)
def canApproximateCount(self):
"""canApproximateCount(SoGetPrimitiveCountAction self) -> SbBool"""
return _coin.SoGetPrimitiveCountAction_canApproximateCount(self)
def setCanApproximate(self, flag):
"""setCanApproximate(SoGetPrimitiveCountAction self, SbBool const flag)"""
return _coin.SoGetPrimitiveCountAction_setCanApproximate(self, flag)
def setDecimationValue(self, type, percentage=1.0):
"""
setDecimationValue(SoGetPrimitiveCountAction self, SoDecimationTypeElement::Type type, float percentage=1.0)
setDecimationValue(SoGetPrimitiveCountAction self, SoDecimationTypeElement::Type type)
"""
return _coin.SoGetPrimitiveCountAction_setDecimationValue(self, type, percentage)
def getDecimationType(self):
"""getDecimationType(SoGetPrimitiveCountAction self) -> SoDecimationTypeElement::Type"""
return _coin.SoGetPrimitiveCountAction_getDecimationType(self)
def getDecimationPercentage(self):
"""getDecimationPercentage(SoGetPrimitiveCountAction self) -> float"""
return _coin.SoGetPrimitiveCountAction_getDecimationPercentage(self)
def addNumTriangles(self, num):
"""addNumTriangles(SoGetPrimitiveCountAction self, int const num)"""
return _coin.SoGetPrimitiveCountAction_addNumTriangles(self, num)
def addNumLines(self, num):
"""addNumLines(SoGetPrimitiveCountAction self, int const num)"""
return _coin.SoGetPrimitiveCountAction_addNumLines(self, num)
def addNumPoints(self, num):
"""addNumPoints(SoGetPrimitiveCountAction self, int const num)"""
return _coin.SoGetPrimitiveCountAction_addNumPoints(self, num)
def addNumText(self, num):
"""addNumText(SoGetPrimitiveCountAction self, int const num)"""
return _coin.SoGetPrimitiveCountAction_addNumText(self, num)
def addNumImage(self, num):
"""addNumImage(SoGetPrimitiveCountAction self, int const num)"""
return _coin.SoGetPrimitiveCountAction_addNumImage(self, num)
def incNumTriangles(self):
"""incNumTriangles(SoGetPrimitiveCountAction self)"""
return _coin.SoGetPrimitiveCountAction_incNumTriangles(self)
def incNumLines(self):
"""incNumLines(SoGetPrimitiveCountAction self)"""
return _coin.SoGetPrimitiveCountAction_incNumLines(self)
def incNumPoints(self):
"""incNumPoints(SoGetPrimitiveCountAction self)"""
return _coin.SoGetPrimitiveCountAction_incNumPoints(self)
def incNumText(self):
"""incNumText(SoGetPrimitiveCountAction self)"""
return _coin.SoGetPrimitiveCountAction_incNumText(self)
def incNumImage(self):
"""incNumImage(SoGetPrimitiveCountAction self)"""
return _coin.SoGetPrimitiveCountAction_incNumImage(self)
SoGetPrimitiveCountAction_swigregister = _coin.SoGetPrimitiveCountAction_swigregister
SoGetPrimitiveCountAction_swigregister(SoGetPrimitiveCountAction)
def SoGetPrimitiveCountAction_getClassTypeId():
"""SoGetPrimitiveCountAction_getClassTypeId() -> SoType"""
return _coin.SoGetPrimitiveCountAction_getClassTypeId()
def SoGetPrimitiveCountAction_addMethod(type, method):
"""SoGetPrimitiveCountAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoGetPrimitiveCountAction_addMethod(type, method)
def SoGetPrimitiveCountAction_enableElement(type, stackindex):
"""SoGetPrimitiveCountAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoGetPrimitiveCountAction_enableElement(type, stackindex)
def SoGetPrimitiveCountAction_initClass():
"""SoGetPrimitiveCountAction_initClass()"""
return _coin.SoGetPrimitiveCountAction_initClass()
class SoHandleEventAction(SoAction):
"""Proxy of C++ SoHandleEventAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoHandleEventAction self) -> SoType"""
return _coin.SoHandleEventAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoHandleEventAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoHandleEventAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoHandleEventAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoHandleEventAction_initClass()
initClass = staticmethod(initClass)
def __init__(self, viewportregion):
"""__init__(SoHandleEventAction self, SbViewportRegion viewportregion) -> SoHandleEventAction"""
this = _coin.new_SoHandleEventAction(viewportregion)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoHandleEventAction
__del__ = lambda self: None
def setViewportRegion(self, newregion):
"""setViewportRegion(SoHandleEventAction self, SbViewportRegion newregion)"""
return _coin.SoHandleEventAction_setViewportRegion(self, newregion)
def getViewportRegion(self):
"""getViewportRegion(SoHandleEventAction self) -> SbViewportRegion"""
return _coin.SoHandleEventAction_getViewportRegion(self)
def setEvent(self, ev):
"""setEvent(SoHandleEventAction self, SoEvent ev)"""
return _coin.SoHandleEventAction_setEvent(self, ev)
def getEvent(self):
"""getEvent(SoHandleEventAction self) -> SoEvent"""
return _coin.SoHandleEventAction_getEvent(self)
def setHandled(self):
"""setHandled(SoHandleEventAction self)"""
return _coin.SoHandleEventAction_setHandled(self)
def isHandled(self):
"""isHandled(SoHandleEventAction self) -> SbBool"""
return _coin.SoHandleEventAction_isHandled(self)
def setGrabber(self, node):
"""setGrabber(SoHandleEventAction self, SoNode node)"""
return _coin.SoHandleEventAction_setGrabber(self, node)
def releaseGrabber(self):
"""releaseGrabber(SoHandleEventAction self)"""
return _coin.SoHandleEventAction_releaseGrabber(self)
def getGrabber(self):
"""getGrabber(SoHandleEventAction self) -> SoNode"""
return _coin.SoHandleEventAction_getGrabber(self)
def setPickRoot(self, node):
"""setPickRoot(SoHandleEventAction self, SoNode node)"""
return _coin.SoHandleEventAction_setPickRoot(self, node)
def getPickRoot(self):
"""getPickRoot(SoHandleEventAction self) -> SoNode"""
return _coin.SoHandleEventAction_getPickRoot(self)
def setPickRadius(self, radiusinpixels):
"""setPickRadius(SoHandleEventAction self, float const radiusinpixels)"""
return _coin.SoHandleEventAction_setPickRadius(self, radiusinpixels)
def getPickedPoint(self):
"""getPickedPoint(SoHandleEventAction self) -> SoPickedPoint"""
return _coin.SoHandleEventAction_getPickedPoint(self)
def getPickedPointList(self):
"""getPickedPointList(SoHandleEventAction self) -> SoPickedPointList"""
return _coin.SoHandleEventAction_getPickedPointList(self)
SoHandleEventAction_swigregister = _coin.SoHandleEventAction_swigregister
SoHandleEventAction_swigregister(SoHandleEventAction)
def SoHandleEventAction_getClassTypeId():
"""SoHandleEventAction_getClassTypeId() -> SoType"""
return _coin.SoHandleEventAction_getClassTypeId()
def SoHandleEventAction_addMethod(type, method):
"""SoHandleEventAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoHandleEventAction_addMethod(type, method)
def SoHandleEventAction_enableElement(type, stackindex):
"""SoHandleEventAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoHandleEventAction_enableElement(type, stackindex)
def SoHandleEventAction_initClass():
"""SoHandleEventAction_initClass()"""
return _coin.SoHandleEventAction_initClass()
class SoPickAction(SoAction):
"""Proxy of C++ SoPickAction class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoPickAction self) -> SoType"""
return _coin.SoPickAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoPickAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoPickAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoPickAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoPickAction_initClass()
initClass = staticmethod(initClass)
def setViewportRegion(self, newregion):
"""setViewportRegion(SoPickAction self, SbViewportRegion newregion)"""
return _coin.SoPickAction_setViewportRegion(self, newregion)
def getViewportRegion(self):
"""getViewportRegion(SoPickAction self) -> SbViewportRegion"""
return _coin.SoPickAction_getViewportRegion(self)
def enableCulling(self, flag):
"""enableCulling(SoPickAction self, SbBool const flag)"""
return _coin.SoPickAction_enableCulling(self, flag)
def isCullingEnabled(self):
"""isCullingEnabled(SoPickAction self) -> SbBool"""
return _coin.SoPickAction_isCullingEnabled(self)
SoPickAction_swigregister = _coin.SoPickAction_swigregister
SoPickAction_swigregister(SoPickAction)
def SoPickAction_getClassTypeId():
"""SoPickAction_getClassTypeId() -> SoType"""
return _coin.SoPickAction_getClassTypeId()
def SoPickAction_addMethod(type, method):
"""SoPickAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoPickAction_addMethod(type, method)
def SoPickAction_enableElement(type, stackindex):
"""SoPickAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoPickAction_enableElement(type, stackindex)
def SoPickAction_initClass():
"""SoPickAction_initClass()"""
return _coin.SoPickAction_initClass()
class SoRayPickAction(SoPickAction):
"""Proxy of C++ SoRayPickAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoRayPickAction self) -> SoType"""
return _coin.SoRayPickAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoRayPickAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoRayPickAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoRayPickAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def __init__(self, viewportregion):
"""__init__(SoRayPickAction self, SbViewportRegion viewportregion) -> SoRayPickAction"""
this = _coin.new_SoRayPickAction(viewportregion)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoRayPickAction
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoRayPickAction_initClass()
initClass = staticmethod(initClass)
def setPoint(self, viewportPoint):
"""setPoint(SoRayPickAction self, SbVec2s viewportPoint)"""
return _coin.SoRayPickAction_setPoint(self, viewportPoint)
def setNormalizedPoint(self, normpoint):
"""setNormalizedPoint(SoRayPickAction self, SbVec2f normpoint)"""
return _coin.SoRayPickAction_setNormalizedPoint(self, normpoint)
def setRadius(self, radiusinpixels):
"""setRadius(SoRayPickAction self, float const radiusinpixels)"""
return _coin.SoRayPickAction_setRadius(self, radiusinpixels)
def setRay(self, start, direction, neardistance=-1.0, fardistance=-1.0):
"""
setRay(SoRayPickAction self, SbVec3f start, SbVec3f direction, float neardistance=-1.0, float fardistance=-1.0)
setRay(SoRayPickAction self, SbVec3f start, SbVec3f direction, float neardistance=-1.0)
setRay(SoRayPickAction self, SbVec3f start, SbVec3f direction)
"""
return _coin.SoRayPickAction_setRay(self, start, direction, neardistance, fardistance)
def setPickAll(self, flag):
"""setPickAll(SoRayPickAction self, SbBool const flag)"""
return _coin.SoRayPickAction_setPickAll(self, flag)
def isPickAll(self):
"""isPickAll(SoRayPickAction self) -> SbBool"""
return _coin.SoRayPickAction_isPickAll(self)
def getPickedPointList(self):
"""getPickedPointList(SoRayPickAction self) -> SoPickedPointList"""
return _coin.SoRayPickAction_getPickedPointList(self)
def getPickedPoint(self, index=0):
"""
getPickedPoint(SoRayPickAction self, int const index=0) -> SoPickedPoint
getPickedPoint(SoRayPickAction self) -> SoPickedPoint
"""
return _coin.SoRayPickAction_getPickedPoint(self, index)
def computeWorldSpaceRay(self):
"""computeWorldSpaceRay(SoRayPickAction self)"""
return _coin.SoRayPickAction_computeWorldSpaceRay(self)
def hasWorldSpaceRay(self):
"""hasWorldSpaceRay(SoRayPickAction self) -> SbBool"""
return _coin.SoRayPickAction_hasWorldSpaceRay(self)
def setObjectSpace(self, *args):
"""
setObjectSpace(SoRayPickAction self)
setObjectSpace(SoRayPickAction self)
"""
return _coin.SoRayPickAction_setObjectSpace(self, *args)
def intersect(self, *args):
"""
intersect(SoRayPickAction self, SbVec3f v0, SbVec3f v1, SbVec3f v2, SbVec3f intersection, SbVec3f barycentric, SbBool & front) -> SbBool
intersect(SoRayPickAction self, SbVec3f v0, SbVec3f v1, SbVec3f intersection) -> SbBool
intersect(SoRayPickAction self, SbVec3f point) -> SbBool
intersect(SoRayPickAction self, SbBox3f box, SbBool const usefullviewvolume=1) -> SbBool
intersect(SoRayPickAction self, SbBox3f box) -> SbBool
intersect(SoRayPickAction self, SbBox3f box, SbVec3f intersection, SbBool const usefullviewvolume=1) -> SbBool
intersect(SoRayPickAction self, SbBox3f box, SbVec3f intersection) -> SbBool
"""
return _coin.SoRayPickAction_intersect(self, *args)
def getViewVolume(self):
"""getViewVolume(SoRayPickAction self) -> SbViewVolume"""
return _coin.SoRayPickAction_getViewVolume(self)
def getLine(self):
"""getLine(SoRayPickAction self) -> SbLine"""
return _coin.SoRayPickAction_getLine(self)
def isBetweenPlanes(self, intersection):
"""isBetweenPlanes(SoRayPickAction self, SbVec3f intersection) -> SbBool"""
return _coin.SoRayPickAction_isBetweenPlanes(self, intersection)
def addIntersection(self, objectspacepoint, frontpick=1):
"""
addIntersection(SoRayPickAction self, SbVec3f objectspacepoint, SbBool frontpick=1) -> SoPickedPoint
addIntersection(SoRayPickAction self, SbVec3f objectspacepoint) -> SoPickedPoint
"""
return _coin.SoRayPickAction_addIntersection(self, objectspacepoint, frontpick)
def reset(self):
"""reset(SoRayPickAction self)"""
return _coin.SoRayPickAction_reset(self)
SoRayPickAction_swigregister = _coin.SoRayPickAction_swigregister
SoRayPickAction_swigregister(SoRayPickAction)
def SoRayPickAction_getClassTypeId():
"""SoRayPickAction_getClassTypeId() -> SoType"""
return _coin.SoRayPickAction_getClassTypeId()
def SoRayPickAction_addMethod(type, method):
"""SoRayPickAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoRayPickAction_addMethod(type, method)
def SoRayPickAction_enableElement(type, stackindex):
"""SoRayPickAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoRayPickAction_enableElement(type, stackindex)
def SoRayPickAction_initClass():
"""SoRayPickAction_initClass()"""
return _coin.SoRayPickAction_initClass()
class SoSearchAction(SoAction):
"""Proxy of C++ SoSearchAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoSearchAction self) -> SoType"""
return _coin.SoSearchAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSearchAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoSearchAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoSearchAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoSearchAction_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoSearchAction self) -> SoSearchAction"""
this = _coin.new_SoSearchAction()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSearchAction
__del__ = lambda self: None
NODE = _coin.SoSearchAction_NODE
TYPE = _coin.SoSearchAction_TYPE
NAME = _coin.SoSearchAction_NAME
FIRST = _coin.SoSearchAction_FIRST
LAST = _coin.SoSearchAction_LAST
ALL = _coin.SoSearchAction_ALL
def setNode(self, node):
"""setNode(SoSearchAction self, SoNode node)"""
return _coin.SoSearchAction_setNode(self, node)
def getNode(self):
"""getNode(SoSearchAction self) -> SoNode"""
return _coin.SoSearchAction_getNode(self)
def setType(self, type, chkderived=1):
"""
setType(SoSearchAction self, SoType type, SbBool const chkderived=1)
setType(SoSearchAction self, SoType type)
"""
return _coin.SoSearchAction_setType(self, type, chkderived)
def getType(self, chkderived):
"""getType(SoSearchAction self, SbBool & chkderived) -> SoType"""
return _coin.SoSearchAction_getType(self, chkderived)
def setName(self, name):
"""setName(SoSearchAction self, SbName name)"""
return _coin.SoSearchAction_setName(self, name)
def getName(self):
"""getName(SoSearchAction self) -> SbName"""
return _coin.SoSearchAction_getName(self)
def setFind(self, what):
"""setFind(SoSearchAction self, int const what)"""
return _coin.SoSearchAction_setFind(self, what)
def getFind(self):
"""getFind(SoSearchAction self) -> int"""
return _coin.SoSearchAction_getFind(self)
def setInterest(self, interest):
"""setInterest(SoSearchAction self, SoSearchAction::Interest const interest)"""
return _coin.SoSearchAction_setInterest(self, interest)
def getInterest(self):
"""getInterest(SoSearchAction self) -> SoSearchAction::Interest"""
return _coin.SoSearchAction_getInterest(self)
def setSearchingAll(self, searchall):
"""setSearchingAll(SoSearchAction self, SbBool const searchall)"""
return _coin.SoSearchAction_setSearchingAll(self, searchall)
def isSearchingAll(self):
"""isSearchingAll(SoSearchAction self) -> SbBool"""
return _coin.SoSearchAction_isSearchingAll(self)
def getPath(self):
"""getPath(SoSearchAction self) -> SoPath"""
return _coin.SoSearchAction_getPath(self)
def getPaths(self):
"""getPaths(SoSearchAction self) -> SoPathList"""
return _coin.SoSearchAction_getPaths(self)
def reset(self):
"""reset(SoSearchAction self)"""
return _coin.SoSearchAction_reset(self)
def setFound(self):
"""setFound(SoSearchAction self)"""
return _coin.SoSearchAction_setFound(self)
def isFound(self):
"""isFound(SoSearchAction self) -> SbBool"""
return _coin.SoSearchAction_isFound(self)
def addPath(self, path):
"""addPath(SoSearchAction self, SoPath path)"""
return _coin.SoSearchAction_addPath(self, path)
duringSearchAll = _swig_property(_coin.SoSearchAction_duringSearchAll_get, _coin.SoSearchAction_duringSearchAll_set)
SoSearchAction_swigregister = _coin.SoSearchAction_swigregister
SoSearchAction_swigregister(SoSearchAction)
def SoSearchAction_getClassTypeId():
"""SoSearchAction_getClassTypeId() -> SoType"""
return _coin.SoSearchAction_getClassTypeId()
def SoSearchAction_addMethod(type, method):
"""SoSearchAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoSearchAction_addMethod(type, method)
def SoSearchAction_enableElement(type, stackindex):
"""SoSearchAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoSearchAction_enableElement(type, stackindex)
def SoSearchAction_initClass():
"""SoSearchAction_initClass()"""
return _coin.SoSearchAction_initClass()
cvar = _coin.cvar
class SoSimplifyAction(SoAction):
"""Proxy of C++ SoSimplifyAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoSimplifyAction self) -> SoType"""
return _coin.SoSimplifyAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSimplifyAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoSimplifyAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoSimplifyAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoSimplifyAction_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoSimplifyAction self) -> SoSimplifyAction"""
this = _coin.new_SoSimplifyAction()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSimplifyAction
__del__ = lambda self: None
def apply(self, *args):
"""
apply(SoSimplifyAction self, SoNode root)
apply(SoSimplifyAction self, SoPath path)
apply(SoSimplifyAction self, SoPathList pathlist, SbBool obeysrules=0)
apply(SoSimplifyAction self, SoPathList pathlist)
"""
return _coin.SoSimplifyAction_apply(self, *args)
SoSimplifyAction_swigregister = _coin.SoSimplifyAction_swigregister
SoSimplifyAction_swigregister(SoSimplifyAction)
def SoSimplifyAction_getClassTypeId():
"""SoSimplifyAction_getClassTypeId() -> SoType"""
return _coin.SoSimplifyAction_getClassTypeId()
def SoSimplifyAction_addMethod(type, method):
"""SoSimplifyAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoSimplifyAction_addMethod(type, method)
def SoSimplifyAction_enableElement(type, stackindex):
"""SoSimplifyAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoSimplifyAction_enableElement(type, stackindex)
def SoSimplifyAction_initClass():
"""SoSimplifyAction_initClass()"""
return _coin.SoSimplifyAction_initClass()
class SoReorganizeAction(SoSimplifyAction):
"""Proxy of C++ SoReorganizeAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoReorganizeAction self) -> SoType"""
return _coin.SoReorganizeAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoReorganizeAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoReorganizeAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoReorganizeAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoReorganizeAction_initClass()
initClass = staticmethod(initClass)
def __init__(self, simplifier=None):
"""
__init__(SoReorganizeAction self, SoSimplifier * simplifier=None) -> SoReorganizeAction
__init__(SoReorganizeAction self) -> SoReorganizeAction
"""
this = _coin.new_SoReorganizeAction(simplifier)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoReorganizeAction
__del__ = lambda self: None
def getSimplifiedSceneGraph(self):
"""getSimplifiedSceneGraph(SoReorganizeAction self) -> SoSeparator"""
return _coin.SoReorganizeAction_getSimplifiedSceneGraph(self)
def generateNormals(self, onoff):
"""generateNormals(SoReorganizeAction self, SbBool onoff)"""
return _coin.SoReorganizeAction_generateNormals(self, onoff)
def areNormalGenerated(self):
"""areNormalGenerated(SoReorganizeAction self) -> SbBool"""
return _coin.SoReorganizeAction_areNormalGenerated(self)
def generateTriangleStrips(self, onoff):
"""generateTriangleStrips(SoReorganizeAction self, SbBool onoff)"""
return _coin.SoReorganizeAction_generateTriangleStrips(self, onoff)
def areTriangleStripGenerated(self):
"""areTriangleStripGenerated(SoReorganizeAction self) -> SbBool"""
return _coin.SoReorganizeAction_areTriangleStripGenerated(self)
def generateTexCoords(self, onoff):
"""generateTexCoords(SoReorganizeAction self, SbBool onoff)"""
return _coin.SoReorganizeAction_generateTexCoords(self, onoff)
def areTexCoordsGenerated(self):
"""areTexCoordsGenerated(SoReorganizeAction self) -> SbBool"""
return _coin.SoReorganizeAction_areTexCoordsGenerated(self)
def generateVPNodes(self, onoff):
"""generateVPNodes(SoReorganizeAction self, SbBool onoff)"""
return _coin.SoReorganizeAction_generateVPNodes(self, onoff)
def areVPNodesGenerated(self):
"""areVPNodesGenerated(SoReorganizeAction self) -> SbBool"""
return _coin.SoReorganizeAction_areVPNodesGenerated(self)
def matchIndexArrays(self, onoff):
"""matchIndexArrays(SoReorganizeAction self, SbBool onoff)"""
return _coin.SoReorganizeAction_matchIndexArrays(self, onoff)
def areIndexArraysMatched(self):
"""areIndexArraysMatched(SoReorganizeAction self) -> SbBool"""
return _coin.SoReorganizeAction_areIndexArraysMatched(self)
def getSimplifier(self):
"""getSimplifier(SoReorganizeAction self) -> SoSimplifier *"""
return _coin.SoReorganizeAction_getSimplifier(self)
def apply(self, *args):
"""
apply(SoReorganizeAction self, SoNode root)
apply(SoReorganizeAction self, SoPath path)
apply(SoReorganizeAction self, SoPathList pathlist, SbBool obeysrules=0)
apply(SoReorganizeAction self, SoPathList pathlist)
"""
return _coin.SoReorganizeAction_apply(self, *args)
def startReport(msg):
"""startReport(char const * msg)"""
return _coin.SoReorganizeAction_startReport(msg)
startReport = staticmethod(startReport)
def finishReport():
"""finishReport()"""
return _coin.SoReorganizeAction_finishReport()
finishReport = staticmethod(finishReport)
SoReorganizeAction_swigregister = _coin.SoReorganizeAction_swigregister
SoReorganizeAction_swigregister(SoReorganizeAction)
def SoReorganizeAction_getClassTypeId():
"""SoReorganizeAction_getClassTypeId() -> SoType"""
return _coin.SoReorganizeAction_getClassTypeId()
def SoReorganizeAction_addMethod(type, method):
"""SoReorganizeAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoReorganizeAction_addMethod(type, method)
def SoReorganizeAction_enableElement(type, stackindex):
"""SoReorganizeAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoReorganizeAction_enableElement(type, stackindex)
def SoReorganizeAction_initClass():
"""SoReorganizeAction_initClass()"""
return _coin.SoReorganizeAction_initClass()
def SoReorganizeAction_startReport(msg):
"""SoReorganizeAction_startReport(char const * msg)"""
return _coin.SoReorganizeAction_startReport(msg)
def SoReorganizeAction_finishReport():
"""SoReorganizeAction_finishReport()"""
return _coin.SoReorganizeAction_finishReport()
class SoWriteAction(SoAction):
"""Proxy of C++ SoWriteAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoWriteAction self) -> SoType"""
return _coin.SoWriteAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoWriteAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoWriteAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoWriteAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def __init__(self, *args):
"""
__init__(SoWriteAction self) -> SoWriteAction
__init__(SoWriteAction self, SoOutput out) -> SoWriteAction
"""
this = _coin.new_SoWriteAction(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoWriteAction
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoWriteAction_initClass()
initClass = staticmethod(initClass)
def getOutput(self):
"""getOutput(SoWriteAction self) -> SoOutput"""
return _coin.SoWriteAction_getOutput(self)
def continueToApply(self, *args):
"""
continueToApply(SoWriteAction self, SoNode node)
continueToApply(SoWriteAction self, SoPath path)
"""
return _coin.SoWriteAction_continueToApply(self, *args)
SoWriteAction_swigregister = _coin.SoWriteAction_swigregister
SoWriteAction_swigregister(SoWriteAction)
def SoWriteAction_getClassTypeId():
"""SoWriteAction_getClassTypeId() -> SoType"""
return _coin.SoWriteAction_getClassTypeId()
def SoWriteAction_addMethod(type, method):
"""SoWriteAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoWriteAction_addMethod(type, method)
def SoWriteAction_enableElement(type, stackindex):
"""SoWriteAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoWriteAction_enableElement(type, stackindex)
def SoWriteAction_initClass():
"""SoWriteAction_initClass()"""
return _coin.SoWriteAction_initClass()
class SoAudioRenderAction(SoAction):
"""Proxy of C++ SoAudioRenderAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoAudioRenderAction self) -> SoType"""
return _coin.SoAudioRenderAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoAudioRenderAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoAudioRenderAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoAudioRenderAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoAudioRenderAction_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoAudioRenderAction self) -> SoAudioRenderAction"""
this = _coin.new_SoAudioRenderAction()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoAudioRenderAction
__del__ = lambda self: None
def callDoAction(action, node):
"""callDoAction(SoAction action, SoNode node)"""
return _coin.SoAudioRenderAction_callDoAction(action, node)
callDoAction = staticmethod(callDoAction)
def callAudioRender(action, node):
"""callAudioRender(SoAction action, SoNode node)"""
return _coin.SoAudioRenderAction_callAudioRender(action, node)
callAudioRender = staticmethod(callAudioRender)
SoAudioRenderAction_swigregister = _coin.SoAudioRenderAction_swigregister
SoAudioRenderAction_swigregister(SoAudioRenderAction)
def SoAudioRenderAction_getClassTypeId():
"""SoAudioRenderAction_getClassTypeId() -> SoType"""
return _coin.SoAudioRenderAction_getClassTypeId()
def SoAudioRenderAction_addMethod(type, method):
"""SoAudioRenderAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoAudioRenderAction_addMethod(type, method)
def SoAudioRenderAction_enableElement(type, stackindex):
"""SoAudioRenderAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoAudioRenderAction_enableElement(type, stackindex)
def SoAudioRenderAction_initClass():
"""SoAudioRenderAction_initClass()"""
return _coin.SoAudioRenderAction_initClass()
def SoAudioRenderAction_callDoAction(action, node):
"""SoAudioRenderAction_callDoAction(SoAction action, SoNode node)"""
return _coin.SoAudioRenderAction_callDoAction(action, node)
def SoAudioRenderAction_callAudioRender(action, node):
"""SoAudioRenderAction_callAudioRender(SoAction action, SoNode node)"""
return _coin.SoAudioRenderAction_callAudioRender(action, node)
class SoIntersectingPrimitive(object):
"""Proxy of C++ SoIntersectingPrimitive class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
path = _swig_property(_coin.SoIntersectingPrimitive_path_get, _coin.SoIntersectingPrimitive_path_set)
SEGMENT = _coin.SoIntersectingPrimitive_SEGMENT
LINE_SEGMENT = _coin.SoIntersectingPrimitive_LINE_SEGMENT
TRIANGLE = _coin.SoIntersectingPrimitive_TRIANGLE
type = _swig_property(_coin.SoIntersectingPrimitive_type_get, _coin.SoIntersectingPrimitive_type_set)
vertex = _swig_property(_coin.SoIntersectingPrimitive_vertex_get, _coin.SoIntersectingPrimitive_vertex_set)
xf_vertex = _swig_property(_coin.SoIntersectingPrimitive_xf_vertex_get, _coin.SoIntersectingPrimitive_xf_vertex_set)
def __init__(self):
"""__init__(SoIntersectingPrimitive self) -> SoIntersectingPrimitive"""
this = _coin.new_SoIntersectingPrimitive()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoIntersectingPrimitive
__del__ = lambda self: None
SoIntersectingPrimitive_swigregister = _coin.SoIntersectingPrimitive_swigregister
SoIntersectingPrimitive_swigregister(SoIntersectingPrimitive)
class SoIntersectionDetectionAction(SoAction):
"""Proxy of C++ SoIntersectionDetectionAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoIntersectionDetectionAction self) -> SoType"""
return _coin.SoIntersectionDetectionAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoIntersectionDetectionAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoIntersectionDetectionAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoIntersectionDetectionAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoIntersectionDetectionAction_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoIntersectionDetectionAction self) -> SoIntersectionDetectionAction"""
this = _coin.new_SoIntersectionDetectionAction()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoIntersectionDetectionAction
__del__ = lambda self: None
NEXT_PRIMITIVE = _coin.SoIntersectionDetectionAction_NEXT_PRIMITIVE
NEXT_SHAPE = _coin.SoIntersectionDetectionAction_NEXT_SHAPE
ABORT = _coin.SoIntersectionDetectionAction_ABORT
def setIntersectionDetectionEpsilon(self, epsilon):
"""setIntersectionDetectionEpsilon(SoIntersectionDetectionAction self, float epsilon)"""
return _coin.SoIntersectionDetectionAction_setIntersectionDetectionEpsilon(self, epsilon)
def getIntersectionDetectionEpsilon(self):
"""getIntersectionDetectionEpsilon(SoIntersectionDetectionAction self) -> float"""
return _coin.SoIntersectionDetectionAction_getIntersectionDetectionEpsilon(self)
def setIntersectionEpsilon(epsilon):
"""setIntersectionEpsilon(float epsilon)"""
return _coin.SoIntersectionDetectionAction_setIntersectionEpsilon(epsilon)
setIntersectionEpsilon = staticmethod(setIntersectionEpsilon)
def getIntersectionEpsilon():
"""getIntersectionEpsilon() -> float"""
return _coin.SoIntersectionDetectionAction_getIntersectionEpsilon()
getIntersectionEpsilon = staticmethod(getIntersectionEpsilon)
def setTypeEnabled(self, type, enable):
"""setTypeEnabled(SoIntersectionDetectionAction self, SoType type, SbBool enable)"""
return _coin.SoIntersectionDetectionAction_setTypeEnabled(self, type, enable)
def isTypeEnabled(self, type, checkgroups=0):
"""
isTypeEnabled(SoIntersectionDetectionAction self, SoType type, SbBool checkgroups=0) -> SbBool
isTypeEnabled(SoIntersectionDetectionAction self, SoType type) -> SbBool
"""
return _coin.SoIntersectionDetectionAction_isTypeEnabled(self, type, checkgroups)
def setManipsEnabled(self, enable):
"""setManipsEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
return _coin.SoIntersectionDetectionAction_setManipsEnabled(self, enable)
def isManipsEnabled(self):
"""isManipsEnabled(SoIntersectionDetectionAction self) -> SbBool"""
return _coin.SoIntersectionDetectionAction_isManipsEnabled(self)
def setDraggersEnabled(self, enable):
"""setDraggersEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
return _coin.SoIntersectionDetectionAction_setDraggersEnabled(self, enable)
def isDraggersEnabled(self):
"""isDraggersEnabled(SoIntersectionDetectionAction self) -> SbBool"""
return _coin.SoIntersectionDetectionAction_isDraggersEnabled(self)
def setShapeInternalsEnabled(self, enable):
"""setShapeInternalsEnabled(SoIntersectionDetectionAction self, SbBool enable)"""
return _coin.SoIntersectionDetectionAction_setShapeInternalsEnabled(self, enable)
def isShapeInternalsEnabled(self):
"""isShapeInternalsEnabled(SoIntersectionDetectionAction self) -> SbBool"""
return _coin.SoIntersectionDetectionAction_isShapeInternalsEnabled(self)
def apply(self, *args):
"""
apply(SoIntersectionDetectionAction self, SoNode node)
apply(SoIntersectionDetectionAction self, SoPath path)
apply(SoIntersectionDetectionAction self, SoPathList paths, SbBool obeysRules=0)
apply(SoIntersectionDetectionAction self, SoPathList paths)
"""
return _coin.SoIntersectionDetectionAction_apply(self, *args)
def addVisitationCallback(self, *args):
"""
addVisitationCallback(SoIntersectionDetectionAction self, SoType type, SoIntersectionDetectionAction::SoIntersectionVisitationCB * cb, void * closure)
addVisitationCallback(SoIntersectionDetectionAction self, SoType type, PyObject * pyfunc, PyObject * closure)
"""
return _coin.SoIntersectionDetectionAction_addVisitationCallback(self, *args)
def removeVisitationCallback(self, *args):
"""
removeVisitationCallback(SoIntersectionDetectionAction self, SoType type, SoIntersectionDetectionAction::SoIntersectionVisitationCB * cb, void * closure)
removeVisitationCallback(SoIntersectionDetectionAction self, SoType type, PyObject * pyfunc, PyObject * closure)
"""
return _coin.SoIntersectionDetectionAction_removeVisitationCallback(self, *args)
def setFilterCallback(self, *args):
"""
setFilterCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionFilterCB * cb, void * closure=None)
setFilterCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionFilterCB * cb)
setFilterCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
setFilterCallback(SoIntersectionDetectionAction self, PyObject * pyfunc)
"""
return _coin.SoIntersectionDetectionAction_setFilterCallback(self, *args)
def addIntersectionCallback(self, *args):
"""
addIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb, void * closure=None)
addIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb)
addIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
addIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc)
"""
return _coin.SoIntersectionDetectionAction_addIntersectionCallback(self, *args)
def removeIntersectionCallback(self, *args):
"""
removeIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb, void * closure=None)
removeIntersectionCallback(SoIntersectionDetectionAction self, SoIntersectionDetectionAction::SoIntersectionCB * cb)
removeIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc, PyObject * closure=None)
removeIntersectionCallback(SoIntersectionDetectionAction self, PyObject * pyfunc)
"""
return _coin.SoIntersectionDetectionAction_removeIntersectionCallback(self, *args)
SoIntersectionDetectionAction_swigregister = _coin.SoIntersectionDetectionAction_swigregister
SoIntersectionDetectionAction_swigregister(SoIntersectionDetectionAction)
def SoIntersectionDetectionAction_getClassTypeId():
"""SoIntersectionDetectionAction_getClassTypeId() -> SoType"""
return _coin.SoIntersectionDetectionAction_getClassTypeId()
def SoIntersectionDetectionAction_addMethod(type, method):
"""SoIntersectionDetectionAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoIntersectionDetectionAction_addMethod(type, method)
def SoIntersectionDetectionAction_enableElement(type, stackindex):
"""SoIntersectionDetectionAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoIntersectionDetectionAction_enableElement(type, stackindex)
def SoIntersectionDetectionAction_initClass():
"""SoIntersectionDetectionAction_initClass()"""
return _coin.SoIntersectionDetectionAction_initClass()
def SoIntersectionDetectionAction_setIntersectionEpsilon(epsilon):
"""SoIntersectionDetectionAction_setIntersectionEpsilon(float epsilon)"""
return _coin.SoIntersectionDetectionAction_setIntersectionEpsilon(epsilon)
def SoIntersectionDetectionAction_getIntersectionEpsilon():
"""SoIntersectionDetectionAction_getIntersectionEpsilon() -> float"""
return _coin.SoIntersectionDetectionAction_getIntersectionEpsilon()
class SoToVRMLAction(SoAction):
"""Proxy of C++ SoToVRMLAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoToVRMLAction self) -> SoType"""
return _coin.SoToVRMLAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoToVRMLAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoToVRMLAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoToVRMLAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoToVRMLAction_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoToVRMLAction self) -> SoToVRMLAction"""
this = _coin.new_SoToVRMLAction()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoToVRMLAction
__del__ = lambda self: None
def apply(self, *args):
"""
apply(SoToVRMLAction self, SoNode node)
apply(SoToVRMLAction self, SoPath path)
apply(SoToVRMLAction self, SoPathList pathlist, SbBool obeysrules=0)
apply(SoToVRMLAction self, SoPathList pathlist)
"""
return _coin.SoToVRMLAction_apply(self, *args)
def getVRMLSceneGraph(self):
"""getVRMLSceneGraph(SoToVRMLAction self) -> SoNode"""
return _coin.SoToVRMLAction_getVRMLSceneGraph(self)
def expandSoFile(self, flag):
"""expandSoFile(SoToVRMLAction self, SbBool flag)"""
return _coin.SoToVRMLAction_expandSoFile(self, flag)
def areSoFileExpanded(self):
"""areSoFileExpanded(SoToVRMLAction self) -> SbBool"""
return _coin.SoToVRMLAction_areSoFileExpanded(self)
def setUrlName(self, name):
"""setUrlName(SoToVRMLAction self, SbString name)"""
return _coin.SoToVRMLAction_setUrlName(self, name)
def getUrlName(self):
"""getUrlName(SoToVRMLAction self) -> SbString"""
return _coin.SoToVRMLAction_getUrlName(self)
def writeTexCoords(self, flag):
"""writeTexCoords(SoToVRMLAction self, SbBool flag)"""
return _coin.SoToVRMLAction_writeTexCoords(self, flag)
def areTexCoordWritten(self):
"""areTexCoordWritten(SoToVRMLAction self) -> SbBool"""
return _coin.SoToVRMLAction_areTexCoordWritten(self)
def expandTexture2Node(self, flag):
"""expandTexture2Node(SoToVRMLAction self, SbBool flag)"""
return _coin.SoToVRMLAction_expandTexture2Node(self, flag)
def areTexture2NodeExpanded(self):
"""areTexture2NodeExpanded(SoToVRMLAction self) -> SbBool"""
return _coin.SoToVRMLAction_areTexture2NodeExpanded(self)
def keepUnknownNodes(self, flag):
"""keepUnknownNodes(SoToVRMLAction self, SbBool flag)"""
return _coin.SoToVRMLAction_keepUnknownNodes(self, flag)
def areUnknownNodeKept(self):
"""areUnknownNodeKept(SoToVRMLAction self) -> SbBool"""
return _coin.SoToVRMLAction_areUnknownNodeKept(self)
def convertInlineNodes(self, flag):
"""convertInlineNodes(SoToVRMLAction self, SbBool flag)"""
return _coin.SoToVRMLAction_convertInlineNodes(self, flag)
def doConvertInlineNodes(self):
"""doConvertInlineNodes(SoToVRMLAction self) -> SbBool"""
return _coin.SoToVRMLAction_doConvertInlineNodes(self)
def conditionalConversion(self, flag):
"""conditionalConversion(SoToVRMLAction self, SbBool flag)"""
return _coin.SoToVRMLAction_conditionalConversion(self, flag)
def doConditionalConversion(self):
"""doConditionalConversion(SoToVRMLAction self) -> SbBool"""
return _coin.SoToVRMLAction_doConditionalConversion(self)
def setVerbosity(self, flag):
"""setVerbosity(SoToVRMLAction self, SbBool flag)"""
return _coin.SoToVRMLAction_setVerbosity(self, flag)
def isVerbose(self):
"""isVerbose(SoToVRMLAction self) -> SbBool"""
return _coin.SoToVRMLAction_isVerbose(self)
SoToVRMLAction_swigregister = _coin.SoToVRMLAction_swigregister
SoToVRMLAction_swigregister(SoToVRMLAction)
def SoToVRMLAction_getClassTypeId():
"""SoToVRMLAction_getClassTypeId() -> SoType"""
return _coin.SoToVRMLAction_getClassTypeId()
def SoToVRMLAction_addMethod(type, method):
"""SoToVRMLAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoToVRMLAction_addMethod(type, method)
def SoToVRMLAction_enableElement(type, stackindex):
"""SoToVRMLAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoToVRMLAction_enableElement(type, stackindex)
def SoToVRMLAction_initClass():
"""SoToVRMLAction_initClass()"""
return _coin.SoToVRMLAction_initClass()
class SoToVRML2Action(SoToVRMLAction):
"""Proxy of C++ SoToVRML2Action class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoToVRML2Action self) -> SoType"""
return _coin.SoToVRML2Action_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoToVRML2Action_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoToVRML2Action_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoToVRML2Action_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def initClass():
"""initClass()"""
return _coin.SoToVRML2Action_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoToVRML2Action self) -> SoToVRML2Action"""
this = _coin.new_SoToVRML2Action()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoToVRML2Action
__del__ = lambda self: None
def apply(self, *args):
"""
apply(SoToVRML2Action self, SoNode node)
apply(SoToVRML2Action self, SoPath path)
apply(SoToVRML2Action self, SoPathList pathlist, SbBool obeysrules=0)
apply(SoToVRML2Action self, SoPathList pathlist)
"""
return _coin.SoToVRML2Action_apply(self, *args)
def getVRML2SceneGraph(self):
"""getVRML2SceneGraph(SoToVRML2Action self) -> SoVRMLGroup"""
return _coin.SoToVRML2Action_getVRML2SceneGraph(self)
def reuseAppearanceNodes(self, appearance):
"""reuseAppearanceNodes(SoToVRML2Action self, SbBool appearance)"""
return _coin.SoToVRML2Action_reuseAppearanceNodes(self, appearance)
def doReuseAppearanceNodes(self):
"""doReuseAppearanceNodes(SoToVRML2Action self) -> SbBool"""
return _coin.SoToVRML2Action_doReuseAppearanceNodes(self)
def reusePropertyNodes(self, property):
"""reusePropertyNodes(SoToVRML2Action self, SbBool property)"""
return _coin.SoToVRML2Action_reusePropertyNodes(self, property)
def doReusePropertyNodes(self):
"""doReusePropertyNodes(SoToVRML2Action self) -> SbBool"""
return _coin.SoToVRML2Action_doReusePropertyNodes(self)
def reuseGeometryNodes(self, geometry):
"""reuseGeometryNodes(SoToVRML2Action self, SbBool geometry)"""
return _coin.SoToVRML2Action_reuseGeometryNodes(self, geometry)
def doReuseGeometryNodes(self):
"""doReuseGeometryNodes(SoToVRML2Action self) -> SbBool"""
return _coin.SoToVRML2Action_doReuseGeometryNodes(self)
SoToVRML2Action_swigregister = _coin.SoToVRML2Action_swigregister
SoToVRML2Action_swigregister(SoToVRML2Action)
def SoToVRML2Action_getClassTypeId():
"""SoToVRML2Action_getClassTypeId() -> SoType"""
return _coin.SoToVRML2Action_getClassTypeId()
def SoToVRML2Action_addMethod(type, method):
"""SoToVRML2Action_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoToVRML2Action_addMethod(type, method)
def SoToVRML2Action_enableElement(type, stackindex):
"""SoToVRML2Action_enableElement(SoType type, int const stackindex)"""
return _coin.SoToVRML2Action_enableElement(type, stackindex)
def SoToVRML2Action_initClass():
"""SoToVRML2Action_initClass()"""
return _coin.SoToVRML2Action_initClass()
class SoHardCopy(object):
"""Proxy of C++ SoHardCopy class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def init():
"""init()"""
return _coin.SoHardCopy_init()
init = staticmethod(init)
def getProductName():
"""getProductName() -> char const *"""
return _coin.SoHardCopy_getProductName()
getProductName = staticmethod(getProductName)
def getVersion():
"""getVersion() -> char const *"""
return _coin.SoHardCopy_getVersion()
getVersion = staticmethod(getVersion)
def __init__(self):
"""__init__(SoHardCopy self) -> SoHardCopy"""
this = _coin.new_SoHardCopy()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoHardCopy
__del__ = lambda self: None
SoHardCopy_swigregister = _coin.SoHardCopy_swigregister
SoHardCopy_swigregister(SoHardCopy)
def SoHardCopy_init():
"""SoHardCopy_init()"""
return _coin.SoHardCopy_init()
def SoHardCopy_getProductName():
"""SoHardCopy_getProductName() -> char const *"""
return _coin.SoHardCopy_getProductName()
def SoHardCopy_getVersion():
"""SoHardCopy_getVersion() -> char const *"""
return _coin.SoHardCopy_getVersion()
class SoVectorOutput(object):
"""Proxy of C++ SoVectorOutput class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoVectorOutput self) -> SoVectorOutput"""
this = _coin.new_SoVectorOutput()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoVectorOutput
__del__ = lambda self: None
def openFile(self, filename):
"""openFile(SoVectorOutput self, char const * filename) -> SbBool"""
return _coin.SoVectorOutput_openFile(self, filename)
def closeFile(self):
"""closeFile(SoVectorOutput self)"""
return _coin.SoVectorOutput_closeFile(self)
def getFilePointer(self):
"""getFilePointer(SoVectorOutput self) -> FILE *"""
return _coin.SoVectorOutput_getFilePointer(self)
SoVectorOutput_swigregister = _coin.SoVectorOutput_swigregister
SoVectorOutput_swigregister(SoVectorOutput)
class SoPSVectorOutput(SoVectorOutput):
"""Proxy of C++ SoPSVectorOutput class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoPSVectorOutput self) -> SoPSVectorOutput"""
this = _coin.new_SoPSVectorOutput()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoPSVectorOutput
__del__ = lambda self: None
def setColored(self, flag=1):
"""
setColored(SoPSVectorOutput self, SbBool flag=1)
setColored(SoPSVectorOutput self)
"""
return _coin.SoPSVectorOutput_setColored(self, flag)
def getColored(self):
"""getColored(SoPSVectorOutput self) -> SbBool"""
return _coin.SoPSVectorOutput_getColored(self)
SoPSVectorOutput_swigregister = _coin.SoPSVectorOutput_swigregister
SoPSVectorOutput_swigregister(SoPSVectorOutput)
class SoVectorizeAction(SoCallbackAction):
"""Proxy of C++ SoVectorizeAction class."""
thisown = _swig_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 getTypeId(self):
"""getTypeId(SoVectorizeAction self) -> SoType"""
return _coin.SoVectorizeAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoVectorizeAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoVectorizeAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoVectorizeAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
__swig_destroy__ = _coin.delete_SoVectorizeAction
__del__ = lambda self: None
def getOutput(self):
"""getOutput(SoVectorizeAction self) -> SoVectorOutput"""
return _coin.SoVectorizeAction_getOutput(self)
def initClass():
"""initClass()"""
return _coin.SoVectorizeAction_initClass()
initClass = staticmethod(initClass)
INCH = _coin.SoVectorizeAction_INCH
MM = _coin.SoVectorizeAction_MM
METER = _coin.SoVectorizeAction_METER
PORTRAIT = _coin.SoVectorizeAction_PORTRAIT
LANDSCAPE = _coin.SoVectorizeAction_LANDSCAPE
A0 = _coin.SoVectorizeAction_A0
A1 = _coin.SoVectorizeAction_A1
A2 = _coin.SoVectorizeAction_A2
A3 = _coin.SoVectorizeAction_A3
A4 = _coin.SoVectorizeAction_A4
A5 = _coin.SoVectorizeAction_A5
A6 = _coin.SoVectorizeAction_A6
A7 = _coin.SoVectorizeAction_A7
A8 = _coin.SoVectorizeAction_A8
A9 = _coin.SoVectorizeAction_A9
A10 = _coin.SoVectorizeAction_A10
def apply(self, *args):
"""
apply(SoVectorizeAction self, SoNode node)
apply(SoVectorizeAction self, SoPath path)
apply(SoVectorizeAction self, SoPathList pathlist, SbBool obeysrules=0)
apply(SoVectorizeAction self, SoPathList pathlist)
"""
return _coin.SoVectorizeAction_apply(self, *args)
def beginStandardPage(self, pagesize, border=10.0):
"""
beginStandardPage(SoVectorizeAction self, SoVectorizeAction::PageSize const & pagesize, float const border=10.0)
beginStandardPage(SoVectorizeAction self, SoVectorizeAction::PageSize const & pagesize)
"""
return _coin.SoVectorizeAction_beginStandardPage(self, pagesize, border)
def beginPage(self, *args):
"""
beginPage(SoVectorizeAction self, SbVec2f startpagepos, SbVec2f pagesize, SoVectorizeAction::DimensionUnit u)
beginPage(SoVectorizeAction self, SbVec2f startpagepos, SbVec2f pagesize)
"""
return _coin.SoVectorizeAction_beginPage(self, *args)
def endPage(self):
"""endPage(SoVectorizeAction self)"""
return _coin.SoVectorizeAction_endPage(self)
def calibrate(self, vp):
"""calibrate(SoVectorizeAction self, SbViewportRegion vp)"""
return _coin.SoVectorizeAction_calibrate(self, vp)
def beginViewport(self, *args):
"""
beginViewport(SoVectorizeAction self, SbVec2f startpos, SbVec2f size, SoVectorizeAction::DimensionUnit u)
beginViewport(SoVectorizeAction self, SbVec2f startpos, SbVec2f size)
beginViewport(SoVectorizeAction self, SbVec2f startpos)
beginViewport(SoVectorizeAction self)
"""
return _coin.SoVectorizeAction_beginViewport(self, *args)
def endViewport(self):
"""endViewport(SoVectorizeAction self)"""
return _coin.SoVectorizeAction_endViewport(self)
def setOrientation(self, o):
"""setOrientation(SoVectorizeAction self, SoVectorizeAction::Orientation o)"""
return _coin.SoVectorizeAction_setOrientation(self, o)
def getOrientation(self):
"""getOrientation(SoVectorizeAction self) -> SoVectorizeAction::Orientation"""
return _coin.SoVectorizeAction_getOrientation(self)
def setBackgroundColor(self, *args):
"""
setBackgroundColor(SoVectorizeAction self, SbBool bg, SbColor col)
setBackgroundColor(SoVectorizeAction self, SbBool bg)
"""
return _coin.SoVectorizeAction_setBackgroundColor(self, *args)
def getBackgroundColor(self, col):
"""getBackgroundColor(SoVectorizeAction self, SbColor col) -> SbBool"""
return _coin.SoVectorizeAction_getBackgroundColor(self, col)
def setNominalWidth(self, *args):
"""
setNominalWidth(SoVectorizeAction self, float w, SoVectorizeAction::DimensionUnit u)
setNominalWidth(SoVectorizeAction self, float w)
"""
return _coin.SoVectorizeAction_setNominalWidth(self, *args)
def getNominalWidth(self, *args):
"""
getNominalWidth(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u) -> float
getNominalWidth(SoVectorizeAction self) -> float
"""
return _coin.SoVectorizeAction_getNominalWidth(self, *args)
def setPixelImageSize(self, *args):
"""
setPixelImageSize(SoVectorizeAction self, float w, SoVectorizeAction::DimensionUnit u)
setPixelImageSize(SoVectorizeAction self, float w)
"""
return _coin.SoVectorizeAction_setPixelImageSize(self, *args)
def getPixelImageSize(self, *args):
"""
getPixelImageSize(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u) -> float
getPixelImageSize(SoVectorizeAction self) -> float
"""
return _coin.SoVectorizeAction_getPixelImageSize(self, *args)
CIRCLE = _coin.SoVectorizeAction_CIRCLE
SQUARE = _coin.SoVectorizeAction_SQUARE
def setPointStyle(self, style):
"""setPointStyle(SoVectorizeAction self, SoVectorizeAction::PointStyle const & style)"""
return _coin.SoVectorizeAction_setPointStyle(self, style)
def getPointStyle(self):
"""getPointStyle(SoVectorizeAction self) -> SoVectorizeAction::PointStyle"""
return _coin.SoVectorizeAction_getPointStyle(self)
def getPageStartpos(self):
"""getPageStartpos(SoVectorizeAction self) -> SbVec2f"""
return _coin.SoVectorizeAction_getPageStartpos(self)
def getPageSize(self):
"""getPageSize(SoVectorizeAction self) -> SbVec2f"""
return _coin.SoVectorizeAction_getPageSize(self)
REVERSE_ONLY_BLACK_AND_WHITE = _coin.SoVectorizeAction_REVERSE_ONLY_BLACK_AND_WHITE
AS_IS = _coin.SoVectorizeAction_AS_IS
REVERSE = _coin.SoVectorizeAction_REVERSE
NO_JOIN = _coin.SoVectorizeAction_NO_JOIN
MITERED_JOIN = _coin.SoVectorizeAction_MITERED_JOIN
MITERED_BEVELED_JOIN = _coin.SoVectorizeAction_MITERED_BEVELED_JOIN
BEVELED_JOIN = _coin.SoVectorizeAction_BEVELED_JOIN
TRIANGULAR_JOIN = _coin.SoVectorizeAction_TRIANGULAR_JOIN
ROUNDED_JOIN = _coin.SoVectorizeAction_ROUNDED_JOIN
BUTT_END = _coin.SoVectorizeAction_BUTT_END
SQUARE_END = _coin.SoVectorizeAction_SQUARE_END
TRIANGULAR_END = _coin.SoVectorizeAction_TRIANGULAR_END
ROUND_END = _coin.SoVectorizeAction_ROUND_END
NO_HLHSR = _coin.SoVectorizeAction_NO_HLHSR
HLHSR_SIMPLE_PAINTER = _coin.SoVectorizeAction_HLHSR_SIMPLE_PAINTER
HLHSR_PAINTER = _coin.SoVectorizeAction_HLHSR_PAINTER
HLHSR_PAINTER_SURFACE_REMOVAL = _coin.SoVectorizeAction_HLHSR_PAINTER_SURFACE_REMOVAL
HIDDEN_LINES_REMOVAL = _coin.SoVectorizeAction_HIDDEN_LINES_REMOVAL
def setDrawingDimensions(self, *args):
"""
setDrawingDimensions(SoVectorizeAction self, SbVec2f d, SoVectorizeAction::DimensionUnit u)
setDrawingDimensions(SoVectorizeAction self, SbVec2f d)
setDrawingDimensions(SoVectorizeAction self, float w, float h, SoVectorizeAction::DimensionUnit u)
setDrawingDimensions(SoVectorizeAction self, float w, float h)
"""
return _coin.SoVectorizeAction_setDrawingDimensions(self, *args)
def getDrawingDimensions(self, *args):
"""
getDrawingDimensions(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u) -> SbVec2f
getDrawingDimensions(SoVectorizeAction self) -> SbVec2f
"""
return _coin.SoVectorizeAction_getDrawingDimensions(self, *args)
def setStartPosition(self, *args):
"""
setStartPosition(SoVectorizeAction self, SbVec2f p, SoVectorizeAction::DimensionUnit u)
setStartPosition(SoVectorizeAction self, SbVec2f p)
setStartPosition(SoVectorizeAction self, float x, float y, SoVectorizeAction::DimensionUnit u)
setStartPosition(SoVectorizeAction self, float x, float y)
"""
return _coin.SoVectorizeAction_setStartPosition(self, *args)
def getStartPosition(self, *args):
"""
getStartPosition(SoVectorizeAction self, SoVectorizeAction::DimensionUnit u) -> SbVec2f
getStartPosition(SoVectorizeAction self) -> SbVec2f
"""
return _coin.SoVectorizeAction_getStartPosition(self, *args)
def setColorTranslationMethod(self, method):
"""setColorTranslationMethod(SoVectorizeAction self, SoVectorizeAction::ColorTranslationMethod method)"""
return _coin.SoVectorizeAction_setColorTranslationMethod(self, method)
def getColorTranslationMethod(self):
"""getColorTranslationMethod(SoVectorizeAction self) -> SoVectorizeAction::ColorTranslationMethod"""
return _coin.SoVectorizeAction_getColorTranslationMethod(self)
def setLineEndStyle(self, style):
"""setLineEndStyle(SoVectorizeAction self, SoVectorizeAction::EndLineStyle style)"""
return _coin.SoVectorizeAction_setLineEndStyle(self, style)
def getLineEndStyle(self):
"""getLineEndStyle(SoVectorizeAction self) -> SoVectorizeAction::EndLineStyle"""
return _coin.SoVectorizeAction_getLineEndStyle(self)
def setLineJoinsStyle(self, style):
"""setLineJoinsStyle(SoVectorizeAction self, SoVectorizeAction::JoinLineStyle style)"""
return _coin.SoVectorizeAction_setLineJoinsStyle(self, style)
def getLineJoinsStyle(self):
"""getLineJoinsStyle(SoVectorizeAction self) -> SoVectorizeAction::JoinLineStyle"""
return _coin.SoVectorizeAction_getLineJoinsStyle(self)
def setHLHSRMode(self, mode):
"""setHLHSRMode(SoVectorizeAction self, SoVectorizeAction::HLHSRMode mode)"""
return _coin.SoVectorizeAction_setHLHSRMode(self, mode)
def getHLHSRMode(self):
"""getHLHSRMode(SoVectorizeAction self) -> SoVectorizeAction::HLHSRMode"""
return _coin.SoVectorizeAction_getHLHSRMode(self)
def setBorder(self, *args):
"""
setBorder(SoVectorizeAction self, float width)
setBorder(SoVectorizeAction self, float width, SbColor color)
"""
return _coin.SoVectorizeAction_setBorder(self, *args)
def setMiterLimit(self, limit):
"""setMiterLimit(SoVectorizeAction self, float limit)"""
return _coin.SoVectorizeAction_setMiterLimit(self, limit)
def getMiterLimit(self):
"""getMiterLimit(SoVectorizeAction self) -> float"""
return _coin.SoVectorizeAction_getMiterLimit(self)
def setPenDescription(self, *args):
"""
setPenDescription(SoVectorizeAction self, int num_pens, SbColor colors=None, float const * widths=None, SoVectorizeAction::DimensionUnit u)
setPenDescription(SoVectorizeAction self, int num_pens, SbColor colors=None, float const * widths=None)
setPenDescription(SoVectorizeAction self, int num_pens, SbColor colors=None)
setPenDescription(SoVectorizeAction self, int num_pens)
"""
return _coin.SoVectorizeAction_setPenDescription(self, *args)
def getPenDescription(self, *args):
"""
getPenDescription(SoVectorizeAction self, SbColor colors, float * widths, SoVectorizeAction::DimensionUnit u)
getPenDescription(SoVectorizeAction self, SbColor colors, float * widths)
"""
return _coin.SoVectorizeAction_getPenDescription(self, *args)
def getPenNum(self):
"""getPenNum(SoVectorizeAction self) -> int"""
return _coin.SoVectorizeAction_getPenNum(self)
def setColorPriority(self, priority):
"""setColorPriority(SoVectorizeAction self, SbBool priority)"""
return _coin.SoVectorizeAction_setColorPriority(self, priority)
def getColorPriority(self):
"""getColorPriority(SoVectorizeAction self) -> SbBool"""
return _coin.SoVectorizeAction_getColorPriority(self)
def enableLighting(self, flag):
"""enableLighting(SoVectorizeAction self, SbBool flag)"""
return _coin.SoVectorizeAction_enableLighting(self, flag)
def isLightingEnabled(self):
"""isLightingEnabled(SoVectorizeAction self) -> SbBool"""
return _coin.SoVectorizeAction_isLightingEnabled(self)
SoVectorizeAction_swigregister = _coin.SoVectorizeAction_swigregister
SoVectorizeAction_swigregister(SoVectorizeAction)
def SoVectorizeAction_getClassTypeId():
"""SoVectorizeAction_getClassTypeId() -> SoType"""
return _coin.SoVectorizeAction_getClassTypeId()
def SoVectorizeAction_addMethod(type, method):
"""SoVectorizeAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoVectorizeAction_addMethod(type, method)
def SoVectorizeAction_enableElement(type, stackindex):
"""SoVectorizeAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoVectorizeAction_enableElement(type, stackindex)
def SoVectorizeAction_initClass():
"""SoVectorizeAction_initClass()"""
return _coin.SoVectorizeAction_initClass()
class SoMultiTextureCoordinateElement(SoElement):
"""Proxy of C++ SoMultiTextureCoordinateElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoMultiTextureCoordinateElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoMultiTextureCoordinateElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoMultiTextureCoordinateElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoMultiTextureCoordinateElement_initClass()
initClass = staticmethod(initClass)
NONE = _coin.SoMultiTextureCoordinateElement_NONE
TEXGEN = _coin.SoMultiTextureCoordinateElement_TEXGEN
EXPLICIT = _coin.SoMultiTextureCoordinateElement_EXPLICIT
FUNCTION = _coin.SoMultiTextureCoordinateElement_FUNCTION
DEFAULT = _coin.SoMultiTextureCoordinateElement_DEFAULT
def init(self, state):
"""init(SoMultiTextureCoordinateElement self, SoState state)"""
return _coin.SoMultiTextureCoordinateElement_init(self, state)
def setDefault(state, node, unit=0):
"""
setDefault(SoState state, SoNode node, int const unit=0)
setDefault(SoState state, SoNode node)
"""
return _coin.SoMultiTextureCoordinateElement_setDefault(state, node, unit)
setDefault = staticmethod(setDefault)
def getType(self, *args):
"""
getType(SoMultiTextureCoordinateElement self, SoState state, int const unit=0) -> SoMultiTextureCoordinateElement::CoordType
getType(SoMultiTextureCoordinateElement self, SoState state) -> SoMultiTextureCoordinateElement::CoordType
getType(SoMultiTextureCoordinateElement self, int const unit=0) -> SoMultiTextureCoordinateElement::CoordType
getType(SoMultiTextureCoordinateElement self) -> SoMultiTextureCoordinateElement::CoordType
"""
return _coin.SoMultiTextureCoordinateElement_getType(self, *args)
def getInstance(state):
"""getInstance(SoState state) -> SoMultiTextureCoordinateElement"""
return _coin.SoMultiTextureCoordinateElement_getInstance(state)
getInstance = staticmethod(getInstance)
def getNum(self, unit=0):
"""
getNum(SoMultiTextureCoordinateElement self, int const unit=0) -> int32_t
getNum(SoMultiTextureCoordinateElement self) -> int32_t
"""
return _coin.SoMultiTextureCoordinateElement_getNum(self, unit)
def is2D(self, unit=0):
"""
is2D(SoMultiTextureCoordinateElement self, int const unit=0) -> SbBool
is2D(SoMultiTextureCoordinateElement self) -> SbBool
"""
return _coin.SoMultiTextureCoordinateElement_is2D(self, unit)
def getDimension(self, unit=0):
"""
getDimension(SoMultiTextureCoordinateElement self, int const unit=0) -> int32_t
getDimension(SoMultiTextureCoordinateElement self) -> int32_t
"""
return _coin.SoMultiTextureCoordinateElement_getDimension(self, unit)
def getArrayPtr2(self, unit=0):
"""
getArrayPtr2(SoMultiTextureCoordinateElement self, int const unit=0) -> SbVec2f
getArrayPtr2(SoMultiTextureCoordinateElement self) -> SbVec2f
"""
return _coin.SoMultiTextureCoordinateElement_getArrayPtr2(self, unit)
def getArrayPtr3(self, unit=0):
"""
getArrayPtr3(SoMultiTextureCoordinateElement self, int const unit=0) -> SbVec3f
getArrayPtr3(SoMultiTextureCoordinateElement self) -> SbVec3f
"""
return _coin.SoMultiTextureCoordinateElement_getArrayPtr3(self, unit)
def getArrayPtr4(self, unit=0):
"""
getArrayPtr4(SoMultiTextureCoordinateElement self, int const unit=0) -> SbVec4f
getArrayPtr4(SoMultiTextureCoordinateElement self) -> SbVec4f
"""
return _coin.SoMultiTextureCoordinateElement_getArrayPtr4(self, unit)
def push(self, state):
"""push(SoMultiTextureCoordinateElement self, SoState state)"""
return _coin.SoMultiTextureCoordinateElement_push(self, state)
def matches(self, elem):
"""matches(SoMultiTextureCoordinateElement self, SoElement elem) -> SbBool"""
return _coin.SoMultiTextureCoordinateElement_matches(self, elem)
def copyMatchInfo(self):
"""copyMatchInfo(SoMultiTextureCoordinateElement self) -> SoElement"""
return _coin.SoMultiTextureCoordinateElement_copyMatchInfo(self)
def get(self, *args):
"""
get(SoMultiTextureCoordinateElement self, int const unit, SbVec3f point, SbVec3f normal) -> SbVec4f
get(SoMultiTextureCoordinateElement self, SbVec3f point, SbVec3f normal) -> SbVec4f
"""
return _coin.SoMultiTextureCoordinateElement_get(self, *args)
def set2(*args):
"""
set2(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec2f coords)
set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)
"""
return _coin.SoMultiTextureCoordinateElement_set2(*args)
set2 = staticmethod(set2)
def set3(*args):
"""
set3(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec3f coords)
set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)
"""
return _coin.SoMultiTextureCoordinateElement_set3(*args)
set3 = staticmethod(set3)
def set4(*args):
"""
set4(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec4f coords)
set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)
"""
return _coin.SoMultiTextureCoordinateElement_set4(*args)
set4 = staticmethod(set4)
def get2(self, *args):
"""
get2(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec2f
get2(SoMultiTextureCoordinateElement self, int const index) -> SbVec2f
"""
return _coin.SoMultiTextureCoordinateElement_get2(self, *args)
def get3(self, *args):
"""
get3(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec3f
get3(SoMultiTextureCoordinateElement self, int const index) -> SbVec3f
"""
return _coin.SoMultiTextureCoordinateElement_get3(self, *args)
def get4(self, *args):
"""
get4(SoMultiTextureCoordinateElement self, int const unit, int const index) -> SbVec4f
get4(SoMultiTextureCoordinateElement self, int const index) -> SbVec4f
"""
return _coin.SoMultiTextureCoordinateElement_get4(self, *args)
SoMultiTextureCoordinateElement_swigregister = _coin.SoMultiTextureCoordinateElement_swigregister
SoMultiTextureCoordinateElement_swigregister(SoMultiTextureCoordinateElement)
def SoMultiTextureCoordinateElement_getClassTypeId():
"""SoMultiTextureCoordinateElement_getClassTypeId() -> SoType"""
return _coin.SoMultiTextureCoordinateElement_getClassTypeId()
def SoMultiTextureCoordinateElement_getClassStackIndex():
"""SoMultiTextureCoordinateElement_getClassStackIndex() -> int"""
return _coin.SoMultiTextureCoordinateElement_getClassStackIndex()
def SoMultiTextureCoordinateElement_createInstance():
"""SoMultiTextureCoordinateElement_createInstance() -> void *"""
return _coin.SoMultiTextureCoordinateElement_createInstance()
def SoMultiTextureCoordinateElement_initClass():
"""SoMultiTextureCoordinateElement_initClass()"""
return _coin.SoMultiTextureCoordinateElement_initClass()
def SoMultiTextureCoordinateElement_setDefault(state, node, unit=0):
"""
setDefault(SoState state, SoNode node, int const unit=0)
SoMultiTextureCoordinateElement_setDefault(SoState state, SoNode node)
"""
return _coin.SoMultiTextureCoordinateElement_setDefault(state, node, unit)
def SoMultiTextureCoordinateElement_getInstance(state):
"""SoMultiTextureCoordinateElement_getInstance(SoState state) -> SoMultiTextureCoordinateElement"""
return _coin.SoMultiTextureCoordinateElement_getInstance(state)
def SoMultiTextureCoordinateElement_set2(*args):
"""
set2(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec2f coords)
SoMultiTextureCoordinateElement_set2(SoState state, SoNode node, int32_t const numCoords, SbVec2f coords)
"""
return _coin.SoMultiTextureCoordinateElement_set2(*args)
def SoMultiTextureCoordinateElement_set3(*args):
"""
set3(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec3f coords)
SoMultiTextureCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)
"""
return _coin.SoMultiTextureCoordinateElement_set3(*args)
def SoMultiTextureCoordinateElement_set4(*args):
"""
set4(SoState state, SoNode node, int const unit, int32_t const numCoords, SbVec4f coords)
SoMultiTextureCoordinateElement_set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)
"""
return _coin.SoMultiTextureCoordinateElement_set4(*args)
class SoShape(SoNode):
"""Proxy of C++ SoShape class."""
thisown = _swig_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 getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoShape_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoShape self) -> SoType"""
return _coin.SoShape_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoShape_initClass()
initClass = staticmethod(initClass)
TRIANGLE_STRIP = _coin.SoShape_TRIANGLE_STRIP
TRIANGLE_FAN = _coin.SoShape_TRIANGLE_FAN
TRIANGLES = _coin.SoShape_TRIANGLES
POLYGON = _coin.SoShape_POLYGON
QUADS = _coin.SoShape_QUADS
QUAD_STRIP = _coin.SoShape_QUAD_STRIP
POINTS = _coin.SoShape_POINTS
LINES = _coin.SoShape_LINES
LINE_STRIP = _coin.SoShape_LINE_STRIP
def affectsState(self):
"""affectsState(SoShape self) -> SbBool"""
return _coin.SoShape_affectsState(self)
def notify(self, nl):
"""notify(SoShape self, SoNotList nl)"""
return _coin.SoShape_notify(self, nl)
def getBoundingBox(self, action):
"""getBoundingBox(SoShape self, SoGetBoundingBoxAction action)"""
return _coin.SoShape_getBoundingBox(self, action)
def GLRender(self, action):
"""GLRender(SoShape self, SoGLRenderAction action)"""
return _coin.SoShape_GLRender(self, action)
def rayPick(self, action):
"""rayPick(SoShape self, SoRayPickAction action)"""
return _coin.SoShape_rayPick(self, action)
def callback(self, action):
"""callback(SoShape self, SoCallbackAction action)"""
return _coin.SoShape_callback(self, action)
def computeBBox(self, action, box, center):
"""computeBBox(SoShape self, SoAction action, SbBox3f box, SbVec3f center)"""
return _coin.SoShape_computeBBox(self, action, box, center)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoShape self, SoGetPrimitiveCountAction action)"""
return _coin.SoShape_getPrimitiveCount(self, action)
def getScreenSize(state, boundingbox, rectsize):
"""getScreenSize(SoState state, SbBox3f boundingbox, SbVec2s rectsize)"""
return _coin.SoShape_getScreenSize(state, boundingbox, rectsize)
getScreenSize = staticmethod(getScreenSize)
def getDecimatedComplexity(state, complexity):
"""getDecimatedComplexity(SoState state, float complexity) -> float"""
return _coin.SoShape_getDecimatedComplexity(state, complexity)
getDecimatedComplexity = staticmethod(getDecimatedComplexity)
def getBoundingBoxCache(self):
"""getBoundingBoxCache(SoShape self) -> SoBoundingBoxCache"""
return _coin.SoShape_getBoundingBoxCache(self)
SoShape_swigregister = _coin.SoShape_swigregister
SoShape_swigregister(SoShape)
def SoShape_getClassTypeId():
"""SoShape_getClassTypeId() -> SoType"""
return _coin.SoShape_getClassTypeId()
def SoShape_initClass():
"""SoShape_initClass()"""
return _coin.SoShape_initClass()
def SoShape_getScreenSize(state, boundingbox, rectsize):
"""SoShape_getScreenSize(SoState state, SbBox3f boundingbox, SbVec2s rectsize)"""
return _coin.SoShape_getScreenSize(state, boundingbox, rectsize)
def SoShape_getDecimatedComplexity(state, complexity):
"""SoShape_getDecimatedComplexity(SoState state, float complexity) -> float"""
return _coin.SoShape_getDecimatedComplexity(state, complexity)
class SoImage(SoShape):
"""Proxy of C++ SoImage class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoImage_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoImage self) -> SoType"""
return _coin.SoImage_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoImage_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoImage self) -> SoImage"""
this = _coin.new_SoImage()
try:
self.this.append(this)
except Exception:
self.this = this
BOTTOM = _coin.SoImage_BOTTOM
HALF = _coin.SoImage_HALF
TOP = _coin.SoImage_TOP
LEFT = _coin.SoImage_LEFT
CENTER = _coin.SoImage_CENTER
RIGHT = _coin.SoImage_RIGHT
width = _swig_property(_coin.SoImage_width_get, _coin.SoImage_width_set)
height = _swig_property(_coin.SoImage_height_get, _coin.SoImage_height_set)
vertAlignment = _swig_property(_coin.SoImage_vertAlignment_get, _coin.SoImage_vertAlignment_set)
horAlignment = _swig_property(_coin.SoImage_horAlignment_get, _coin.SoImage_horAlignment_set)
image = _swig_property(_coin.SoImage_image_get, _coin.SoImage_image_set)
filename = _swig_property(_coin.SoImage_filename_get, _coin.SoImage_filename_set)
def GLRender(self, action):
"""GLRender(SoImage self, SoGLRenderAction action)"""
return _coin.SoImage_GLRender(self, action)
def rayPick(self, action):
"""rayPick(SoImage self, SoRayPickAction action)"""
return _coin.SoImage_rayPick(self, action)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoImage self, SoGetPrimitiveCountAction action)"""
return _coin.SoImage_getPrimitiveCount(self, action)
SoImage_swigregister = _coin.SoImage_swigregister
SoImage_swigregister(SoImage)
def SoImage_getClassTypeId():
"""SoImage_getClassTypeId() -> SoType"""
return _coin.SoImage_getClassTypeId()
def SoImage_initClass():
"""SoImage_initClass()"""
return _coin.SoImage_initClass()
class SoVectorizePSAction(SoVectorizeAction):
"""Proxy of C++ SoVectorizePSAction class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoVectorizePSAction self) -> SoType"""
return _coin.SoVectorizePSAction_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoVectorizePSAction_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def addMethod(type, method):
"""addMethod(SoType type, SoActionMethod method)"""
return _coin.SoVectorizePSAction_addMethod(type, method)
addMethod = staticmethod(addMethod)
def enableElement(type, stackindex):
"""enableElement(SoType type, int const stackindex)"""
return _coin.SoVectorizePSAction_enableElement(type, stackindex)
enableElement = staticmethod(enableElement)
def __init__(self):
"""__init__(SoVectorizePSAction self) -> SoVectorizePSAction"""
this = _coin.new_SoVectorizePSAction()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoVectorizePSAction
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoVectorizePSAction_initClass()
initClass = staticmethod(initClass)
def setDefault2DFont(self, fontname):
"""setDefault2DFont(SoVectorizePSAction self, SbString fontname)"""
return _coin.SoVectorizePSAction_setDefault2DFont(self, fontname)
def getDefault2DFont(self):
"""getDefault2DFont(SoVectorizePSAction self) -> SbString"""
return _coin.SoVectorizePSAction_getDefault2DFont(self)
def setGouraudThreshold(self, eps):
"""setGouraudThreshold(SoVectorizePSAction self, double const eps)"""
return _coin.SoVectorizePSAction_setGouraudThreshold(self, eps)
def getOutput(self):
"""getOutput(SoVectorizePSAction self) -> SoPSVectorOutput"""
return _coin.SoVectorizePSAction_getOutput(self)
def getPSOutput(self):
"""getPSOutput(SoVectorizePSAction self) -> SoPSVectorOutput"""
return _coin.SoVectorizePSAction_getPSOutput(self)
SoVectorizePSAction_swigregister = _coin.SoVectorizePSAction_swigregister
SoVectorizePSAction_swigregister(SoVectorizePSAction)
def SoVectorizePSAction_getClassTypeId():
"""SoVectorizePSAction_getClassTypeId() -> SoType"""
return _coin.SoVectorizePSAction_getClassTypeId()
def SoVectorizePSAction_addMethod(type, method):
"""SoVectorizePSAction_addMethod(SoType type, SoActionMethod method)"""
return _coin.SoVectorizePSAction_addMethod(type, method)
def SoVectorizePSAction_enableElement(type, stackindex):
"""SoVectorizePSAction_enableElement(SoType type, int const stackindex)"""
return _coin.SoVectorizePSAction_enableElement(type, stackindex)
def SoVectorizePSAction_initClass():
"""SoVectorizePSAction_initClass()"""
return _coin.SoVectorizePSAction_initClass()
class SoBundle(object):
"""Proxy of C++ SoBundle class."""
thisown = _swig_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")
__repr__ = _swig_repr
SoBundle_swigregister = _coin.SoBundle_swigregister
SoBundle_swigregister(SoBundle)
class SoMaterialBundle(SoBundle):
"""Proxy of C++ SoMaterialBundle class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, action):
"""__init__(SoMaterialBundle self, SoAction action) -> SoMaterialBundle"""
this = _coin.new_SoMaterialBundle(action)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoMaterialBundle
__del__ = lambda self: None
def setUpMultiple(self):
"""setUpMultiple(SoMaterialBundle self)"""
return _coin.SoMaterialBundle_setUpMultiple(self)
def sendFirst(self):
"""sendFirst(SoMaterialBundle self)"""
return _coin.SoMaterialBundle_sendFirst(self)
def forceSend(self, index):
"""forceSend(SoMaterialBundle self, int const index)"""
return _coin.SoMaterialBundle_forceSend(self, index)
def isColorOnly(self):
"""isColorOnly(SoMaterialBundle self) -> SbBool"""
return _coin.SoMaterialBundle_isColorOnly(self)
def send(self, index, betweenbeginend):
"""send(SoMaterialBundle self, int const index, SbBool const betweenbeginend)"""
return _coin.SoMaterialBundle_send(self, index, betweenbeginend)
SoMaterialBundle_swigregister = _coin.SoMaterialBundle_swigregister
SoMaterialBundle_swigregister(SoMaterialBundle)
class SbBSPTree(object):
"""Proxy of C++ SbBSPTree class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, maxnodepts=64, initsize=4):
"""
__init__(SbBSPTree self, int const maxnodepts=64, int const initsize=4) -> SbBSPTree
__init__(SbBSPTree self, int const maxnodepts=64) -> SbBSPTree
__init__(SbBSPTree self) -> SbBSPTree
"""
this = _coin.new_SbBSPTree(maxnodepts, initsize)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SbBSPTree
__del__ = lambda self: None
def numPoints(self):
"""numPoints(SbBSPTree self) -> int"""
return _coin.SbBSPTree_numPoints(self)
def getPoint(self, *args):
"""
getPoint(SbBSPTree self, int const idx) -> SbVec3f
getPoint(SbBSPTree self, int const idx, SbVec3f pt)
"""
return _coin.SbBSPTree_getPoint(self, *args)
def getUserData(self, idx):
"""getUserData(SbBSPTree self, int const idx) -> void *"""
return _coin.SbBSPTree_getUserData(self, idx)
def setUserData(self, idx, data):
"""setUserData(SbBSPTree self, int const idx, void *const data)"""
return _coin.SbBSPTree_setUserData(self, idx, data)
def addPoint(self, pt, userdata=None):
"""
addPoint(SbBSPTree self, SbVec3f pt, void *const userdata=None) -> int
addPoint(SbBSPTree self, SbVec3f pt) -> int
"""
return _coin.SbBSPTree_addPoint(self, pt, userdata)
def removePoint(self, *args):
"""
removePoint(SbBSPTree self, SbVec3f pt) -> int
removePoint(SbBSPTree self, int const idx)
"""
return _coin.SbBSPTree_removePoint(self, *args)
def findPoint(self, pos):
"""findPoint(SbBSPTree self, SbVec3f pos) -> int"""
return _coin.SbBSPTree_findPoint(self, pos)
def clear(self, initsize=4):
"""
clear(SbBSPTree self, int const initsize=4)
clear(SbBSPTree self)
"""
return _coin.SbBSPTree_clear(self, initsize)
def getBBox(self):
"""getBBox(SbBSPTree self) -> SbBox3f"""
return _coin.SbBSPTree_getBBox(self)
def getPointsArrayPtr(self):
"""getPointsArrayPtr(SbBSPTree self) -> SbVec3f"""
return _coin.SbBSPTree_getPointsArrayPtr(self)
def findPoints(self, *args):
"""
findPoints(SbBSPTree self, SbSphere sphere, SbIntList array)
findPoints(SbBSPTree self, SbSphere sphere, SbList< int > & array)
"""
return _coin.SbBSPTree_findPoints(self, *args)
def findClosest(self, *args):
"""
findClosest(SbBSPTree self, SbVec3f pos) -> int
findClosest(SbBSPTree self, SbSphere sphere, SbIntList array) -> int
findClosest(SbBSPTree self, SbSphere sphere, SbList< int > & array) -> int
"""
return _coin.SbBSPTree_findClosest(self, *args)
SbBSPTree_swigregister = _coin.SbBSPTree_swigregister
SbBSPTree_swigregister(SbBSPTree)
class SoNormalGenerator(object):
"""Proxy of C++ SoNormalGenerator class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, ccw, approxVertices=64):
"""
__init__(SoNormalGenerator self, SbBool const ccw, int const approxVertices=64) -> SoNormalGenerator
__init__(SoNormalGenerator self, SbBool const ccw) -> SoNormalGenerator
"""
this = _coin.new_SoNormalGenerator(ccw, approxVertices)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoNormalGenerator
__del__ = lambda self: None
def reset(self, ccw):
"""reset(SoNormalGenerator self, SbBool const ccw)"""
return _coin.SoNormalGenerator_reset(self, ccw)
def beginPolygon(self):
"""beginPolygon(SoNormalGenerator self)"""
return _coin.SoNormalGenerator_beginPolygon(self)
def polygonVertex(self, v):
"""polygonVertex(SoNormalGenerator self, SbVec3f v)"""
return _coin.SoNormalGenerator_polygonVertex(self, v)
def endPolygon(self):
"""endPolygon(SoNormalGenerator self)"""
return _coin.SoNormalGenerator_endPolygon(self)
def triangle(self, v0, v1, v2):
"""triangle(SoNormalGenerator self, SbVec3f v0, SbVec3f v1, SbVec3f v2)"""
return _coin.SoNormalGenerator_triangle(self, v0, v1, v2)
def quad(self, v0, v1, v2, v3):
"""quad(SoNormalGenerator self, SbVec3f v0, SbVec3f v1, SbVec3f v2, SbVec3f v3)"""
return _coin.SoNormalGenerator_quad(self, v0, v1, v2, v3)
def generate(self, creaseAngle, striplens=None, numstrips=0):
"""
generate(SoNormalGenerator self, float const creaseAngle, int32_t const * striplens=None, int const numstrips=0)
generate(SoNormalGenerator self, float const creaseAngle, int32_t const * striplens=None)
generate(SoNormalGenerator self, float const creaseAngle)
"""
return _coin.SoNormalGenerator_generate(self, creaseAngle, striplens, numstrips)
def generatePerStrip(self, striplens, numstrips):
"""generatePerStrip(SoNormalGenerator self, int32_t const * striplens, int const numstrips)"""
return _coin.SoNormalGenerator_generatePerStrip(self, striplens, numstrips)
def generatePerFace(self):
"""generatePerFace(SoNormalGenerator self)"""
return _coin.SoNormalGenerator_generatePerFace(self)
def generateOverall(self):
"""generateOverall(SoNormalGenerator self)"""
return _coin.SoNormalGenerator_generateOverall(self)
def getNumNormals(self):
"""getNumNormals(SoNormalGenerator self) -> int"""
return _coin.SoNormalGenerator_getNumNormals(self)
def setNumNormals(self, num):
"""setNumNormals(SoNormalGenerator self, int const num)"""
return _coin.SoNormalGenerator_setNumNormals(self, num)
def getNormals(self):
"""getNormals(SoNormalGenerator self) -> SbVec3f"""
return _coin.SoNormalGenerator_getNormals(self)
def getNormal(self, i):
"""getNormal(SoNormalGenerator self, int32_t const i) -> SbVec3f"""
return _coin.SoNormalGenerator_getNormal(self, i)
def setNormal(self, index, normal):
"""setNormal(SoNormalGenerator self, int32_t const index, SbVec3f normal)"""
return _coin.SoNormalGenerator_setNormal(self, index, normal)
SoNormalGenerator_swigregister = _coin.SoNormalGenerator_swigregister
SoNormalGenerator_swigregister(SoNormalGenerator)
class SoNormalElement(SoReplacedElement):
"""Proxy of C++ SoNormalElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoNormalElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoNormalElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoNormalElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoNormalElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoNormalElement self, SoState state)"""
return _coin.SoNormalElement_init(self, state)
def set(state, node, numNormals, normals, normalsAreUnitLength=0):
"""
set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals, SbBool const normalsAreUnitLength=0)
set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals)
"""
return _coin.SoNormalElement_set(state, node, numNormals, normals, normalsAreUnitLength)
set = staticmethod(set)
def getInstance(state):
"""getInstance(SoState state) -> SoNormalElement"""
return _coin.SoNormalElement_getInstance(state)
getInstance = staticmethod(getInstance)
def getNum(self):
"""getNum(SoNormalElement self) -> int32_t"""
return _coin.SoNormalElement_getNum(self)
def get(self, index):
"""get(SoNormalElement self, int const index) -> SbVec3f"""
return _coin.SoNormalElement_get(self, index)
def getArrayPtr(self):
"""getArrayPtr(SoNormalElement self) -> SbVec3f"""
return _coin.SoNormalElement_getArrayPtr(self)
def areNormalsUnitLength(self):
"""areNormalsUnitLength(SoNormalElement self) -> SbBool"""
return _coin.SoNormalElement_areNormalsUnitLength(self)
SoNormalElement_swigregister = _coin.SoNormalElement_swigregister
SoNormalElement_swigregister(SoNormalElement)
def SoNormalElement_getClassTypeId():
"""SoNormalElement_getClassTypeId() -> SoType"""
return _coin.SoNormalElement_getClassTypeId()
def SoNormalElement_getClassStackIndex():
"""SoNormalElement_getClassStackIndex() -> int"""
return _coin.SoNormalElement_getClassStackIndex()
def SoNormalElement_createInstance():
"""SoNormalElement_createInstance() -> void *"""
return _coin.SoNormalElement_createInstance()
def SoNormalElement_initClass():
"""SoNormalElement_initClass()"""
return _coin.SoNormalElement_initClass()
def SoNormalElement_set(state, node, numNormals, normals, normalsAreUnitLength=0):
"""
set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals, SbBool const normalsAreUnitLength=0)
SoNormalElement_set(SoState state, SoNode node, int32_t const numNormals, SbVec3f normals)
"""
return _coin.SoNormalElement_set(state, node, numNormals, normals, normalsAreUnitLength)
def SoNormalElement_getInstance(state):
"""SoNormalElement_getInstance(SoState state) -> SoNormalElement"""
return _coin.SoNormalElement_getInstance(state)
class SoGLNormalElement(SoNormalElement):
"""Proxy of C++ SoGLNormalElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLNormalElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLNormalElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLNormalElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLNormalElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLNormalElement self, SoState state)"""
return _coin.SoGLNormalElement_init(self, state)
def send(self, index):
"""send(SoGLNormalElement self, int const index)"""
return _coin.SoGLNormalElement_send(self, index)
SoGLNormalElement_swigregister = _coin.SoGLNormalElement_swigregister
SoGLNormalElement_swigregister(SoGLNormalElement)
def SoGLNormalElement_getClassTypeId():
"""SoGLNormalElement_getClassTypeId() -> SoType"""
return _coin.SoGLNormalElement_getClassTypeId()
def SoGLNormalElement_getClassStackIndex():
"""SoGLNormalElement_getClassStackIndex() -> int"""
return _coin.SoGLNormalElement_getClassStackIndex()
def SoGLNormalElement_createInstance():
"""SoGLNormalElement_createInstance() -> void *"""
return _coin.SoGLNormalElement_createInstance()
def SoGLNormalElement_initClass():
"""SoGLNormalElement_initClass()"""
return _coin.SoGLNormalElement_initClass()
class SoNormalBundle(SoBundle):
"""Proxy of C++ SoNormalBundle class."""
thisown = _swig_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")
__repr__ = _swig_repr
generator = _swig_property(_coin.SoNormalBundle_generator_get, _coin.SoNormalBundle_generator_set)
SoNormalBundle_swigregister = _coin.SoNormalBundle_swigregister
SoNormalBundle_swigregister(SoNormalBundle)
class SoGLMultiTextureCoordinateElement(SoMultiTextureCoordinateElement):
"""Proxy of C++ SoGLMultiTextureCoordinateElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLMultiTextureCoordinateElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLMultiTextureCoordinateElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLMultiTextureCoordinateElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLMultiTextureCoordinateElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLMultiTextureCoordinateElement self, SoState state)"""
return _coin.SoGLMultiTextureCoordinateElement_init(self, state)
def push(self, state):
"""push(SoGLMultiTextureCoordinateElement self, SoState state)"""
return _coin.SoGLMultiTextureCoordinateElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLMultiTextureCoordinateElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLMultiTextureCoordinateElement_pop(self, state, prevTopElement)
def getType(self, unit=0):
"""
getType(SoGLMultiTextureCoordinateElement self, int const unit=0) -> SoMultiTextureCoordinateElement::CoordType
getType(SoGLMultiTextureCoordinateElement self) -> SoMultiTextureCoordinateElement::CoordType
"""
return _coin.SoGLMultiTextureCoordinateElement_getType(self, unit)
def getInstance(state):
"""getInstance(SoState state) -> SoGLMultiTextureCoordinateElement"""
return _coin.SoGLMultiTextureCoordinateElement_getInstance(state)
getInstance = staticmethod(getInstance)
def initRender(self, enabled, maxenabled):
"""initRender(SoGLMultiTextureCoordinateElement self, SbBool const * enabled, int const maxenabled)"""
return _coin.SoGLMultiTextureCoordinateElement_initRender(self, enabled, maxenabled)
def send(self, *args):
"""
send(SoGLMultiTextureCoordinateElement self, int const unit, int const index)
send(SoGLMultiTextureCoordinateElement self, int const unit, int const index, SbVec3f c, SbVec3f n)
send(SoGLMultiTextureCoordinateElement self, int const index)
send(SoGLMultiTextureCoordinateElement self, int const index, SbVec3f c, SbVec3f n)
"""
return _coin.SoGLMultiTextureCoordinateElement_send(self, *args)
def initMulti(self, state):
"""initMulti(SoGLMultiTextureCoordinateElement self, SoState state)"""
return _coin.SoGLMultiTextureCoordinateElement_initMulti(self, state)
SoGLMultiTextureCoordinateElement_swigregister = _coin.SoGLMultiTextureCoordinateElement_swigregister
SoGLMultiTextureCoordinateElement_swigregister(SoGLMultiTextureCoordinateElement)
def SoGLMultiTextureCoordinateElement_getClassTypeId():
"""SoGLMultiTextureCoordinateElement_getClassTypeId() -> SoType"""
return _coin.SoGLMultiTextureCoordinateElement_getClassTypeId()
def SoGLMultiTextureCoordinateElement_getClassStackIndex():
"""SoGLMultiTextureCoordinateElement_getClassStackIndex() -> int"""
return _coin.SoGLMultiTextureCoordinateElement_getClassStackIndex()
def SoGLMultiTextureCoordinateElement_createInstance():
"""SoGLMultiTextureCoordinateElement_createInstance() -> void *"""
return _coin.SoGLMultiTextureCoordinateElement_createInstance()
def SoGLMultiTextureCoordinateElement_initClass():
"""SoGLMultiTextureCoordinateElement_initClass()"""
return _coin.SoGLMultiTextureCoordinateElement_initClass()
def SoGLMultiTextureCoordinateElement_getInstance(state):
"""SoGLMultiTextureCoordinateElement_getInstance(SoState state) -> SoGLMultiTextureCoordinateElement"""
return _coin.SoGLMultiTextureCoordinateElement_getInstance(state)
class SoTextureCoordinateBundle(SoBundle):
"""Proxy of C++ SoTextureCoordinateBundle class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, action, forRendering, setUpDefault=1):
"""
__init__(SoTextureCoordinateBundle self, SoAction action, SbBool const forRendering, SbBool const setUpDefault=1) -> SoTextureCoordinateBundle
__init__(SoTextureCoordinateBundle self, SoAction action, SbBool const forRendering) -> SoTextureCoordinateBundle
"""
this = _coin.new_SoTextureCoordinateBundle(action, forRendering, setUpDefault)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoTextureCoordinateBundle
__del__ = lambda self: None
def needCoordinates(self):
"""needCoordinates(SoTextureCoordinateBundle self) -> SbBool"""
return _coin.SoTextureCoordinateBundle_needCoordinates(self)
def isFunction(self):
"""isFunction(SoTextureCoordinateBundle self) -> SbBool"""
return _coin.SoTextureCoordinateBundle_isFunction(self)
def get(self, *args):
"""
get(SoTextureCoordinateBundle self, int const index) -> SbVec4f
get(SoTextureCoordinateBundle self, SbVec3f point, SbVec3f normal) -> SbVec4f
"""
return _coin.SoTextureCoordinateBundle_get(self, *args)
def send(self, *args):
"""
send(SoTextureCoordinateBundle self, int const index)
send(SoTextureCoordinateBundle self, int const index, SbVec3f point, SbVec3f normal)
"""
return _coin.SoTextureCoordinateBundle_send(self, *args)
def needIndices(self):
"""needIndices(SoTextureCoordinateBundle self) -> SbBool"""
return _coin.SoTextureCoordinateBundle_needIndices(self)
SoTextureCoordinateBundle_swigregister = _coin.SoTextureCoordinateBundle_swigregister
SoTextureCoordinateBundle_swigregister(SoTextureCoordinateBundle)
class SoCache(object):
"""Proxy of C++ SoCache class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, state):
"""__init__(SoCache self, SoState state) -> SoCache"""
this = _coin.new_SoCache(state)
try:
self.this.append(this)
except Exception:
self.this = this
def ref(self):
"""ref(SoCache self)"""
return _coin.SoCache_ref(self)
def unref(self, state=None):
"""
unref(SoCache self, SoState state=None)
unref(SoCache self)
"""
return _coin.SoCache_unref(self, state)
def addElement(self, elem):
"""addElement(SoCache self, SoElement elem)"""
return _coin.SoCache_addElement(self, elem)
def addCacheDependency(self, state, cache):
"""addCacheDependency(SoCache self, SoState state, SoCache cache)"""
return _coin.SoCache_addCacheDependency(self, state, cache)
def isValid(self, state):
"""isValid(SoCache self, SoState state) -> SbBool"""
return _coin.SoCache_isValid(self, state)
def getInvalidElement(self, state):
"""getInvalidElement(SoCache self, SoState state) -> SoElement"""
return _coin.SoCache_getInvalidElement(self, state)
def invalidate(self):
"""invalidate(SoCache self)"""
return _coin.SoCache_invalidate(self)
SoCache_swigregister = _coin.SoCache_swigregister
SoCache_swigregister(SoCache)
class SoBoundingBoxCache(SoCache):
"""Proxy of C++ SoBoundingBoxCache class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, state):
"""__init__(SoBoundingBoxCache self, SoState state) -> SoBoundingBoxCache"""
this = _coin.new_SoBoundingBoxCache(state)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoBoundingBoxCache
__del__ = lambda self: None
def set(self, boundingbox, centerset, centerpoint):
"""set(SoBoundingBoxCache self, SbXfBox3f boundingbox, SbBool centerset, SbVec3f centerpoint)"""
return _coin.SoBoundingBoxCache_set(self, boundingbox, centerset, centerpoint)
def getBox(self):
"""getBox(SoBoundingBoxCache self) -> SbXfBox3f"""
return _coin.SoBoundingBoxCache_getBox(self)
def getProjectedBox(self):
"""getProjectedBox(SoBoundingBoxCache self) -> SbBox3f"""
return _coin.SoBoundingBoxCache_getProjectedBox(self)
def isCenterSet(self):
"""isCenterSet(SoBoundingBoxCache self) -> SbBool"""
return _coin.SoBoundingBoxCache_isCenterSet(self)
def getCenter(self):
"""getCenter(SoBoundingBoxCache self) -> SbVec3f"""
return _coin.SoBoundingBoxCache_getCenter(self)
def setHasLinesOrPoints(state):
"""setHasLinesOrPoints(SoState state)"""
return _coin.SoBoundingBoxCache_setHasLinesOrPoints(state)
setHasLinesOrPoints = staticmethod(setHasLinesOrPoints)
def hasLinesOrPoints(self):
"""hasLinesOrPoints(SoBoundingBoxCache self) -> SbBool"""
return _coin.SoBoundingBoxCache_hasLinesOrPoints(self)
SoBoundingBoxCache_swigregister = _coin.SoBoundingBoxCache_swigregister
SoBoundingBoxCache_swigregister(SoBoundingBoxCache)
def SoBoundingBoxCache_setHasLinesOrPoints(state):
"""SoBoundingBoxCache_setHasLinesOrPoints(SoState state)"""
return _coin.SoBoundingBoxCache_setHasLinesOrPoints(state)
class SoConvexDataCache(SoCache):
"""Proxy of C++ SoConvexDataCache class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, state):
"""__init__(SoConvexDataCache self, SoState state) -> SoConvexDataCache"""
this = _coin.new_SoConvexDataCache(state)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoConvexDataCache
__del__ = lambda self: None
NONE = _coin.SoConvexDataCache_NONE
PER_FACE = _coin.SoConvexDataCache_PER_FACE
PER_FACE_INDEXED = _coin.SoConvexDataCache_PER_FACE_INDEXED
PER_VERTEX = _coin.SoConvexDataCache_PER_VERTEX
PER_VERTEX_INDEXED = _coin.SoConvexDataCache_PER_VERTEX_INDEXED
def generate(self, coords, coordindices, numcoordindices, matindices, normindices, texindices, matbinding, normbinding, texbinding):
"""generate(SoConvexDataCache self, SoCoordinateElement coords, int32_t const * coordindices, int const numcoordindices, int32_t const * matindices, int32_t const * normindices, int32_t const * texindices, SoConvexDataCache::Binding const matbinding, SoConvexDataCache::Binding const normbinding, SoConvexDataCache::Binding const texbinding)"""
return _coin.SoConvexDataCache_generate(self, coords, coordindices, numcoordindices, matindices, normindices, texindices, matbinding, normbinding, texbinding)
def getCoordIndices(self):
"""getCoordIndices(SoConvexDataCache self) -> int32_t const *"""
return _coin.SoConvexDataCache_getCoordIndices(self)
def getNumCoordIndices(self):
"""getNumCoordIndices(SoConvexDataCache self) -> int"""
return _coin.SoConvexDataCache_getNumCoordIndices(self)
def getMaterialIndices(self):
"""getMaterialIndices(SoConvexDataCache self) -> int32_t const *"""
return _coin.SoConvexDataCache_getMaterialIndices(self)
def getNumMaterialIndices(self):
"""getNumMaterialIndices(SoConvexDataCache self) -> int"""
return _coin.SoConvexDataCache_getNumMaterialIndices(self)
def getNormalIndices(self):
"""getNormalIndices(SoConvexDataCache self) -> int32_t const *"""
return _coin.SoConvexDataCache_getNormalIndices(self)
def getNumNormalIndices(self):
"""getNumNormalIndices(SoConvexDataCache self) -> int"""
return _coin.SoConvexDataCache_getNumNormalIndices(self)
def getTexIndices(self):
"""getTexIndices(SoConvexDataCache self) -> int32_t const *"""
return _coin.SoConvexDataCache_getTexIndices(self)
def getNumTexIndices(self):
"""getNumTexIndices(SoConvexDataCache self) -> int"""
return _coin.SoConvexDataCache_getNumTexIndices(self)
SoConvexDataCache_swigregister = _coin.SoConvexDataCache_swigregister
SoConvexDataCache_swigregister(SoConvexDataCache)
class SoGLCacheList(object):
"""Proxy of C++ SoGLCacheList class."""
thisown = _swig_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")
__repr__ = _swig_repr
SoGLCacheList_swigregister = _coin.SoGLCacheList_swigregister
SoGLCacheList_swigregister(SoGLCacheList)
class SoGLLazyElement(SoLazyElement):
"""Proxy of C++ SoGLLazyElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLLazyElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLLazyElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLLazyElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLLazyElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLLazyElement self, SoState state)"""
return _coin.SoGLLazyElement_init(self, state)
def push(self, state):
"""push(SoGLLazyElement self, SoState state)"""
return _coin.SoGLLazyElement_push(self, state)
def pop(self, state, prevtopelement):
"""pop(SoGLLazyElement self, SoState state, SoElement prevtopelement)"""
return _coin.SoGLLazyElement_pop(self, state, prevtopelement)
def sendAllMaterial(state):
"""sendAllMaterial(SoState state)"""
return _coin.SoGLLazyElement_sendAllMaterial(state)
sendAllMaterial = staticmethod(sendAllMaterial)
def sendNoMaterial(state):
"""sendNoMaterial(SoState state)"""
return _coin.SoGLLazyElement_sendNoMaterial(state)
sendNoMaterial = staticmethod(sendNoMaterial)
def sendOnlyDiffuseColor(state):
"""sendOnlyDiffuseColor(SoState state)"""
return _coin.SoGLLazyElement_sendOnlyDiffuseColor(state)
sendOnlyDiffuseColor = staticmethod(sendOnlyDiffuseColor)
def sendLightModel(state, model):
"""sendLightModel(SoState state, int32_t const model)"""
return _coin.SoGLLazyElement_sendLightModel(state, model)
sendLightModel = staticmethod(sendLightModel)
def sendPackedDiffuse(state, diffuse):
"""sendPackedDiffuse(SoState state, uint32_t const diffuse)"""
return _coin.SoGLLazyElement_sendPackedDiffuse(state, diffuse)
sendPackedDiffuse = staticmethod(sendPackedDiffuse)
def sendFlatshading(state, onoff):
"""sendFlatshading(SoState state, SbBool const onoff)"""
return _coin.SoGLLazyElement_sendFlatshading(state, onoff)
sendFlatshading = staticmethod(sendFlatshading)
def sendVertexOrdering(state, ordering):
"""sendVertexOrdering(SoState state, SoLazyElement::VertexOrdering const ordering)"""
return _coin.SoGLLazyElement_sendVertexOrdering(state, ordering)
sendVertexOrdering = staticmethod(sendVertexOrdering)
def sendTwosideLighting(state, onoff):
"""sendTwosideLighting(SoState state, SbBool const onoff)"""
return _coin.SoGLLazyElement_sendTwosideLighting(state, onoff)
sendTwosideLighting = staticmethod(sendTwosideLighting)
def sendBackfaceCulling(state, onoff):
"""sendBackfaceCulling(SoState state, SbBool const onoff)"""
return _coin.SoGLLazyElement_sendBackfaceCulling(state, onoff)
sendBackfaceCulling = staticmethod(sendBackfaceCulling)
def sendDiffuseByIndex(self, index):
"""sendDiffuseByIndex(SoGLLazyElement self, int const index)"""
return _coin.SoGLLazyElement_sendDiffuseByIndex(self, index)
def isColorIndex(state):
"""isColorIndex(SoState state) -> SbBool"""
return _coin.SoGLLazyElement_isColorIndex(state)
isColorIndex = staticmethod(isColorIndex)
def getInstance(state):
"""getInstance(SoState state) -> SoGLLazyElement"""
return _coin.SoGLLazyElement_getInstance(state)
getInstance = staticmethod(getInstance)
def send(self, state, mask):
"""send(SoGLLazyElement self, SoState state, uint32_t mask)"""
return _coin.SoGLLazyElement_send(self, state, mask)
def sendVPPacked(self, state, pcolor):
"""sendVPPacked(SoGLLazyElement self, SoState state, unsigned char const * pcolor)"""
return _coin.SoGLLazyElement_sendVPPacked(self, state, pcolor)
def reset(self, state, bitmask):
"""reset(SoGLLazyElement self, SoState state, uint32_t bitmask)"""
return _coin.SoGLLazyElement_reset(self, state, bitmask)
def setDiffuseElt(self, arg2, numcolors, colors, packer):
"""setDiffuseElt(SoGLLazyElement self, SoNode arg2, int32_t numcolors, SbColor colors, SoColorPacker packer)"""
return _coin.SoGLLazyElement_setDiffuseElt(self, arg2, numcolors, colors, packer)
def setPackedElt(self, node, numcolors, colors, packedtransparency):
"""setPackedElt(SoGLLazyElement self, SoNode node, int32_t numcolors, uint32_t const * colors, SbBool const packedtransparency)"""
return _coin.SoGLLazyElement_setPackedElt(self, node, numcolors, colors, packedtransparency)
def setColorIndexElt(self, node, numindices, indices):
"""setColorIndexElt(SoGLLazyElement self, SoNode node, int32_t numindices, int32_t const * indices)"""
return _coin.SoGLLazyElement_setColorIndexElt(self, node, numindices, indices)
def setTranspElt(self, node, numtransp, transp, packer):
"""setTranspElt(SoGLLazyElement self, SoNode node, int32_t numtransp, float const * transp, SoColorPacker packer)"""
return _coin.SoGLLazyElement_setTranspElt(self, node, numtransp, transp, packer)
def setTranspTypeElt(self, type):
"""setTranspTypeElt(SoGLLazyElement self, int32_t type)"""
return _coin.SoGLLazyElement_setTranspTypeElt(self, type)
def setAmbientElt(self, color):
"""setAmbientElt(SoGLLazyElement self, SbColor color)"""
return _coin.SoGLLazyElement_setAmbientElt(self, color)
def setEmissiveElt(self, color):
"""setEmissiveElt(SoGLLazyElement self, SbColor color)"""
return _coin.SoGLLazyElement_setEmissiveElt(self, color)
def setSpecularElt(self, color):
"""setSpecularElt(SoGLLazyElement self, SbColor color)"""
return _coin.SoGLLazyElement_setSpecularElt(self, color)
def setShininessElt(self, value):
"""setShininessElt(SoGLLazyElement self, float value)"""
return _coin.SoGLLazyElement_setShininessElt(self, value)
def setColorMaterialElt(self, value):
"""setColorMaterialElt(SoGLLazyElement self, SbBool value)"""
return _coin.SoGLLazyElement_setColorMaterialElt(self, value)
def enableBlendingElt(self, sfactor, dfactor, alpha_sfactor, alpha_dfactor):
"""enableBlendingElt(SoGLLazyElement self, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor)"""
return _coin.SoGLLazyElement_enableBlendingElt(self, sfactor, dfactor, alpha_sfactor, alpha_dfactor)
def disableBlendingElt(self):
"""disableBlendingElt(SoGLLazyElement self)"""
return _coin.SoGLLazyElement_disableBlendingElt(self)
def setLightModelElt(self, state, model):
"""setLightModelElt(SoGLLazyElement self, SoState state, int32_t model)"""
return _coin.SoGLLazyElement_setLightModelElt(self, state, model)
def setMaterialElt(self, node, bitmask, packer, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent):
"""setMaterialElt(SoGLLazyElement self, SoNode node, uint32_t bitmask, SoColorPacker packer, SbColor diffuse, int const numdiffuse, float const * transp, int const numtransp, SbColor ambient, SbColor emissive, SbColor specular, float const shininess, SbBool const istransparent)"""
return _coin.SoGLLazyElement_setMaterialElt(self, node, bitmask, packer, diffuse, numdiffuse, transp, numtransp, ambient, emissive, specular, shininess, istransparent)
def setVertexOrderingElt(self, ordering):
"""setVertexOrderingElt(SoGLLazyElement self, SoLazyElement::VertexOrdering ordering)"""
return _coin.SoGLLazyElement_setVertexOrderingElt(self, ordering)
def setBackfaceCullingElt(self, onoff):
"""setBackfaceCullingElt(SoGLLazyElement self, SbBool onoff)"""
return _coin.SoGLLazyElement_setBackfaceCullingElt(self, onoff)
def setTwosideLightingElt(self, onoff):
"""setTwosideLightingElt(SoGLLazyElement self, SbBool onoff)"""
return _coin.SoGLLazyElement_setTwosideLightingElt(self, onoff)
def setShadeModelElt(self, flatshading):
"""setShadeModelElt(SoGLLazyElement self, SbBool flatshading)"""
return _coin.SoGLLazyElement_setShadeModelElt(self, flatshading)
def setAlphaTestElt(self, func, value):
"""setAlphaTestElt(SoGLLazyElement self, int func, float value)"""
return _coin.SoGLLazyElement_setAlphaTestElt(self, func, value)
def beginCaching(state, prestate, poststate):
"""beginCaching(SoState state, SoGLLazyElement::GLState * prestate, SoGLLazyElement::GLState * poststate)"""
return _coin.SoGLLazyElement_beginCaching(state, prestate, poststate)
beginCaching = staticmethod(beginCaching)
def endCaching(state):
"""endCaching(SoState state)"""
return _coin.SoGLLazyElement_endCaching(state)
endCaching = staticmethod(endCaching)
def preCacheCall(state, prestate):
"""preCacheCall(SoState state, SoGLLazyElement::GLState const * prestate) -> SbBool"""
return _coin.SoGLLazyElement_preCacheCall(state, prestate)
preCacheCall = staticmethod(preCacheCall)
def postCacheCall(state, poststate):
"""postCacheCall(SoState state, SoGLLazyElement::GLState const * poststate)"""
return _coin.SoGLLazyElement_postCacheCall(state, poststate)
postCacheCall = staticmethod(postCacheCall)
def mergeCacheInfo(state, childprestate, childpoststate):
"""mergeCacheInfo(SoState state, SoGLLazyElement::GLState * childprestate, SoGLLazyElement::GLState * childpoststate)"""
return _coin.SoGLLazyElement_mergeCacheInfo(state, childprestate, childpoststate)
mergeCacheInfo = staticmethod(mergeCacheInfo)
def updateColorVBO(self, vbo):
"""updateColorVBO(SoGLLazyElement self, SoVBO * vbo)"""
return _coin.SoGLLazyElement_updateColorVBO(self, vbo)
SoGLLazyElement_swigregister = _coin.SoGLLazyElement_swigregister
SoGLLazyElement_swigregister(SoGLLazyElement)
def SoGLLazyElement_getClassTypeId():
"""SoGLLazyElement_getClassTypeId() -> SoType"""
return _coin.SoGLLazyElement_getClassTypeId()
def SoGLLazyElement_getClassStackIndex():
"""SoGLLazyElement_getClassStackIndex() -> int"""
return _coin.SoGLLazyElement_getClassStackIndex()
def SoGLLazyElement_createInstance():
"""SoGLLazyElement_createInstance() -> void *"""
return _coin.SoGLLazyElement_createInstance()
def SoGLLazyElement_initClass():
"""SoGLLazyElement_initClass()"""
return _coin.SoGLLazyElement_initClass()
def SoGLLazyElement_sendAllMaterial(state):
"""SoGLLazyElement_sendAllMaterial(SoState state)"""
return _coin.SoGLLazyElement_sendAllMaterial(state)
def SoGLLazyElement_sendNoMaterial(state):
"""SoGLLazyElement_sendNoMaterial(SoState state)"""
return _coin.SoGLLazyElement_sendNoMaterial(state)
def SoGLLazyElement_sendOnlyDiffuseColor(state):
"""SoGLLazyElement_sendOnlyDiffuseColor(SoState state)"""
return _coin.SoGLLazyElement_sendOnlyDiffuseColor(state)
def SoGLLazyElement_sendLightModel(state, model):
"""SoGLLazyElement_sendLightModel(SoState state, int32_t const model)"""
return _coin.SoGLLazyElement_sendLightModel(state, model)
def SoGLLazyElement_sendPackedDiffuse(state, diffuse):
"""SoGLLazyElement_sendPackedDiffuse(SoState state, uint32_t const diffuse)"""
return _coin.SoGLLazyElement_sendPackedDiffuse(state, diffuse)
def SoGLLazyElement_sendFlatshading(state, onoff):
"""SoGLLazyElement_sendFlatshading(SoState state, SbBool const onoff)"""
return _coin.SoGLLazyElement_sendFlatshading(state, onoff)
def SoGLLazyElement_sendVertexOrdering(state, ordering):
"""SoGLLazyElement_sendVertexOrdering(SoState state, SoLazyElement::VertexOrdering const ordering)"""
return _coin.SoGLLazyElement_sendVertexOrdering(state, ordering)
def SoGLLazyElement_sendTwosideLighting(state, onoff):
"""SoGLLazyElement_sendTwosideLighting(SoState state, SbBool const onoff)"""
return _coin.SoGLLazyElement_sendTwosideLighting(state, onoff)
def SoGLLazyElement_sendBackfaceCulling(state, onoff):
"""SoGLLazyElement_sendBackfaceCulling(SoState state, SbBool const onoff)"""
return _coin.SoGLLazyElement_sendBackfaceCulling(state, onoff)
def SoGLLazyElement_isColorIndex(state):
"""SoGLLazyElement_isColorIndex(SoState state) -> SbBool"""
return _coin.SoGLLazyElement_isColorIndex(state)
def SoGLLazyElement_getInstance(state):
"""SoGLLazyElement_getInstance(SoState state) -> SoGLLazyElement"""
return _coin.SoGLLazyElement_getInstance(state)
def SoGLLazyElement_beginCaching(state, prestate, poststate):
"""SoGLLazyElement_beginCaching(SoState state, SoGLLazyElement::GLState * prestate, SoGLLazyElement::GLState * poststate)"""
return _coin.SoGLLazyElement_beginCaching(state, prestate, poststate)
def SoGLLazyElement_endCaching(state):
"""SoGLLazyElement_endCaching(SoState state)"""
return _coin.SoGLLazyElement_endCaching(state)
def SoGLLazyElement_preCacheCall(state, prestate):
"""SoGLLazyElement_preCacheCall(SoState state, SoGLLazyElement::GLState const * prestate) -> SbBool"""
return _coin.SoGLLazyElement_preCacheCall(state, prestate)
def SoGLLazyElement_postCacheCall(state, poststate):
"""SoGLLazyElement_postCacheCall(SoState state, SoGLLazyElement::GLState const * poststate)"""
return _coin.SoGLLazyElement_postCacheCall(state, poststate)
def SoGLLazyElement_mergeCacheInfo(state, childprestate, childpoststate):
"""SoGLLazyElement_mergeCacheInfo(SoState state, SoGLLazyElement::GLState * childprestate, SoGLLazyElement::GLState * childpoststate)"""
return _coin.SoGLLazyElement_mergeCacheInfo(state, childprestate, childpoststate)
class SoGLRenderCache(SoCache):
"""Proxy of C++ SoGLRenderCache class."""
thisown = _swig_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")
__repr__ = _swig_repr
__swig_destroy__ = _coin.delete_SoGLRenderCache
__del__ = lambda self: None
def isValid(self, state):
"""isValid(SoGLRenderCache self, SoState state) -> SbBool"""
return _coin.SoGLRenderCache_isValid(self, state)
def addNestedCache(self, child):
"""addNestedCache(SoGLRenderCache self, SoGLDisplayList child)"""
return _coin.SoGLRenderCache_addNestedCache(self, child)
SoGLRenderCache_swigregister = _coin.SoGLRenderCache_swigregister
SoGLRenderCache_swigregister(SoGLRenderCache)
class SoNormalCache(SoCache):
"""Proxy of C++ SoNormalCache class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, state):
"""__init__(SoNormalCache self, SoState state) -> SoNormalCache"""
this = _coin.new_SoNormalCache(state)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoNormalCache
__del__ = lambda self: None
def set(self, *args):
"""
set(SoNormalCache self, int const num, SbVec3f normals)
set(SoNormalCache self, SoNormalGenerator generator)
"""
return _coin.SoNormalCache_set(self, *args)
def getNum(self):
"""getNum(SoNormalCache self) -> int"""
return _coin.SoNormalCache_getNum(self)
def getNormals(self):
"""getNormals(SoNormalCache self) -> SbVec3f"""
return _coin.SoNormalCache_getNormals(self)
def getNumIndices(self):
"""getNumIndices(SoNormalCache self) -> int"""
return _coin.SoNormalCache_getNumIndices(self)
def getIndices(self):
"""getIndices(SoNormalCache self) -> int32_t const *"""
return _coin.SoNormalCache_getIndices(self)
def generatePerVertex(self, coords, numcoords, coordindices, numcoordindices, crease_angle, facenormals=None, numfacenormals=-1, ccw=1, tristrip=0):
"""
generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle, SbVec3f facenormals=None, int const numfacenormals=-1, SbBool const ccw=1, SbBool const tristrip=0)
generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle, SbVec3f facenormals=None, int const numfacenormals=-1, SbBool const ccw=1)
generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle, SbVec3f facenormals=None, int const numfacenormals=-1)
generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle, SbVec3f facenormals=None)
generatePerVertex(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoordindices, float const crease_angle)
"""
return _coin.SoNormalCache_generatePerVertex(self, coords, numcoords, coordindices, numcoordindices, crease_angle, facenormals, numfacenormals, ccw, tristrip)
def generatePerFace(self, coords, numcoords, coordindices, numcoorindices, ccw):
"""generatePerFace(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"""
return _coin.SoNormalCache_generatePerFace(self, coords, numcoords, coordindices, numcoorindices, ccw)
def generatePerFaceStrip(self, coords, numcoords, coordindices, numcoorindices, ccw):
"""generatePerFaceStrip(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"""
return _coin.SoNormalCache_generatePerFaceStrip(self, coords, numcoords, coordindices, numcoorindices, ccw)
def generatePerStrip(self, coords, numcoords, coordindices, numcoorindices, ccw):
"""generatePerStrip(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int32_t const * coordindices, int const numcoorindices, SbBool const ccw)"""
return _coin.SoNormalCache_generatePerStrip(self, coords, numcoords, coordindices, numcoorindices, ccw)
def generatePerVertexQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw):
"""generatePerVertexQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"""
return _coin.SoNormalCache_generatePerVertexQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw)
def generatePerFaceQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw):
"""generatePerFaceQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"""
return _coin.SoNormalCache_generatePerFaceQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw)
def generatePerRowQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw):
"""generatePerRowQuad(SoNormalCache self, SbVec3f coords, unsigned int const numcoords, int const vPerRow, int const vPerColumn, SbBool const ccw)"""
return _coin.SoNormalCache_generatePerRowQuad(self, coords, numcoords, vPerRow, vPerColumn, ccw)
SoNormalCache_swigregister = _coin.SoNormalCache_swigregister
SoNormalCache_swigregister(SoNormalCache)
class SoTextureCoordinateCache(SoCache):
"""Proxy of C++ SoTextureCoordinateCache class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, state):
"""__init__(SoTextureCoordinateCache self, SoState state) -> SoTextureCoordinateCache"""
this = _coin.new_SoTextureCoordinateCache(state)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoTextureCoordinateCache
__del__ = lambda self: None
def generate(self, bbox, vertices, numvertices):
"""generate(SoTextureCoordinateCache self, SbBox3f bbox, SbVec3f vertices, int const numvertices)"""
return _coin.SoTextureCoordinateCache_generate(self, bbox, vertices, numvertices)
def get(self):
"""get(SoTextureCoordinateCache self) -> SbVec2f"""
return _coin.SoTextureCoordinateCache_get(self)
def getNum(self):
"""getNum(SoTextureCoordinateCache self) -> int"""
return _coin.SoTextureCoordinateCache_getNum(self)
SoTextureCoordinateCache_swigregister = _coin.SoTextureCoordinateCache_swigregister
SoTextureCoordinateCache_swigregister(SoTextureCoordinateCache)
class SoDetail(object):
"""Proxy of C++ SoDetail class."""
thisown = _swig_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__ = _coin.delete_SoDetail
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoDetail_initClass()
initClass = staticmethod(initClass)
def initClasses():
"""initClasses()"""
return _coin.SoDetail_initClasses()
initClasses = staticmethod(initClasses)
def copy(self):
"""copy(SoDetail self) -> SoDetail"""
return _coin.SoDetail_copy(self)
def getTypeId(self):
"""getTypeId(SoDetail self) -> SoType"""
return _coin.SoDetail_getTypeId(self)
def isOfType(self, type):
"""isOfType(SoDetail self, SoType type) -> SbBool"""
return _coin.SoDetail_isOfType(self, type)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoDetail_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
SoDetail_swigregister = _coin.SoDetail_swigregister
SoDetail_swigregister(SoDetail)
def SoDetail_initClass():
"""SoDetail_initClass()"""
return _coin.SoDetail_initClass()
def SoDetail_initClasses():
"""SoDetail_initClasses()"""
return _coin.SoDetail_initClasses()
def SoDetail_getClassTypeId():
"""SoDetail_getClassTypeId() -> SoType"""
return _coin.SoDetail_getClassTypeId()
class SoConeDetail(SoDetail):
"""Proxy of C++ SoConeDetail class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoConeDetail self) -> SoType"""
return _coin.SoConeDetail_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoConeDetail_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoConeDetail_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def __init__(self):
"""__init__(SoConeDetail self) -> SoConeDetail"""
this = _coin.new_SoConeDetail()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoConeDetail
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoConeDetail_initClass()
initClass = staticmethod(initClass)
def copy(self):
"""copy(SoConeDetail self) -> SoDetail"""
return _coin.SoConeDetail_copy(self)
def setPart(self, part):
"""setPart(SoConeDetail self, int const part)"""
return _coin.SoConeDetail_setPart(self, part)
def getPart(self):
"""getPart(SoConeDetail self) -> int"""
return _coin.SoConeDetail_getPart(self)
SoConeDetail_swigregister = _coin.SoConeDetail_swigregister
SoConeDetail_swigregister(SoConeDetail)
def SoConeDetail_getClassTypeId():
"""SoConeDetail_getClassTypeId() -> SoType"""
return _coin.SoConeDetail_getClassTypeId()
def SoConeDetail_cleanupClass():
"""SoConeDetail_cleanupClass()"""
return _coin.SoConeDetail_cleanupClass()
def SoConeDetail_initClass():
"""SoConeDetail_initClass()"""
return _coin.SoConeDetail_initClass()
class SoCubeDetail(SoDetail):
"""Proxy of C++ SoCubeDetail class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoCubeDetail self) -> SoType"""
return _coin.SoCubeDetail_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoCubeDetail_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoCubeDetail_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def __init__(self):
"""__init__(SoCubeDetail self) -> SoCubeDetail"""
this = _coin.new_SoCubeDetail()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoCubeDetail
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoCubeDetail_initClass()
initClass = staticmethod(initClass)
def copy(self):
"""copy(SoCubeDetail self) -> SoDetail"""
return _coin.SoCubeDetail_copy(self)
def setPart(self, part):
"""setPart(SoCubeDetail self, int const part)"""
return _coin.SoCubeDetail_setPart(self, part)
def getPart(self):
"""getPart(SoCubeDetail self) -> int"""
return _coin.SoCubeDetail_getPart(self)
SoCubeDetail_swigregister = _coin.SoCubeDetail_swigregister
SoCubeDetail_swigregister(SoCubeDetail)
def SoCubeDetail_getClassTypeId():
"""SoCubeDetail_getClassTypeId() -> SoType"""
return _coin.SoCubeDetail_getClassTypeId()
def SoCubeDetail_cleanupClass():
"""SoCubeDetail_cleanupClass()"""
return _coin.SoCubeDetail_cleanupClass()
def SoCubeDetail_initClass():
"""SoCubeDetail_initClass()"""
return _coin.SoCubeDetail_initClass()
class SoCylinderDetail(SoDetail):
"""Proxy of C++ SoCylinderDetail class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoCylinderDetail self) -> SoType"""
return _coin.SoCylinderDetail_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoCylinderDetail_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoCylinderDetail_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def __init__(self):
"""__init__(SoCylinderDetail self) -> SoCylinderDetail"""
this = _coin.new_SoCylinderDetail()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoCylinderDetail
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoCylinderDetail_initClass()
initClass = staticmethod(initClass)
def copy(self):
"""copy(SoCylinderDetail self) -> SoDetail"""
return _coin.SoCylinderDetail_copy(self)
def setPart(self, part):
"""setPart(SoCylinderDetail self, int const part)"""
return _coin.SoCylinderDetail_setPart(self, part)
def getPart(self):
"""getPart(SoCylinderDetail self) -> int"""
return _coin.SoCylinderDetail_getPart(self)
SoCylinderDetail_swigregister = _coin.SoCylinderDetail_swigregister
SoCylinderDetail_swigregister(SoCylinderDetail)
def SoCylinderDetail_getClassTypeId():
"""SoCylinderDetail_getClassTypeId() -> SoType"""
return _coin.SoCylinderDetail_getClassTypeId()
def SoCylinderDetail_cleanupClass():
"""SoCylinderDetail_cleanupClass()"""
return _coin.SoCylinderDetail_cleanupClass()
def SoCylinderDetail_initClass():
"""SoCylinderDetail_initClass()"""
return _coin.SoCylinderDetail_initClass()
class SoPointDetail(SoDetail):
"""Proxy of C++ SoPointDetail class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoPointDetail self) -> SoType"""
return _coin.SoPointDetail_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoPointDetail_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoPointDetail_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def __init__(self):
"""__init__(SoPointDetail self) -> SoPointDetail"""
this = _coin.new_SoPointDetail()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoPointDetail
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoPointDetail_initClass()
initClass = staticmethod(initClass)
def copy(self):
"""copy(SoPointDetail self) -> SoDetail"""
return _coin.SoPointDetail_copy(self)
def getCoordinateIndex(self):
"""getCoordinateIndex(SoPointDetail self) -> int"""
return _coin.SoPointDetail_getCoordinateIndex(self)
def getMaterialIndex(self):
"""getMaterialIndex(SoPointDetail self) -> int"""
return _coin.SoPointDetail_getMaterialIndex(self)
def getNormalIndex(self):
"""getNormalIndex(SoPointDetail self) -> int"""
return _coin.SoPointDetail_getNormalIndex(self)
def getTextureCoordIndex(self):
"""getTextureCoordIndex(SoPointDetail self) -> int"""
return _coin.SoPointDetail_getTextureCoordIndex(self)
def setCoordinateIndex(self, idx):
"""setCoordinateIndex(SoPointDetail self, int const idx)"""
return _coin.SoPointDetail_setCoordinateIndex(self, idx)
def setMaterialIndex(self, idx):
"""setMaterialIndex(SoPointDetail self, int const idx)"""
return _coin.SoPointDetail_setMaterialIndex(self, idx)
def setNormalIndex(self, idx):
"""setNormalIndex(SoPointDetail self, int const idx)"""
return _coin.SoPointDetail_setNormalIndex(self, idx)
def setTextureCoordIndex(self, idx):
"""setTextureCoordIndex(SoPointDetail self, int const idx)"""
return _coin.SoPointDetail_setTextureCoordIndex(self, idx)
SoPointDetail_swigregister = _coin.SoPointDetail_swigregister
SoPointDetail_swigregister(SoPointDetail)
def SoPointDetail_getClassTypeId():
"""SoPointDetail_getClassTypeId() -> SoType"""
return _coin.SoPointDetail_getClassTypeId()
def SoPointDetail_cleanupClass():
"""SoPointDetail_cleanupClass()"""
return _coin.SoPointDetail_cleanupClass()
def SoPointDetail_initClass():
"""SoPointDetail_initClass()"""
return _coin.SoPointDetail_initClass()
class SoFaceDetail(SoDetail):
"""Proxy of C++ SoFaceDetail class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoFaceDetail self) -> SoType"""
return _coin.SoFaceDetail_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoFaceDetail_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoFaceDetail_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def __init__(self):
"""__init__(SoFaceDetail self) -> SoFaceDetail"""
this = _coin.new_SoFaceDetail()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoFaceDetail
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoFaceDetail_initClass()
initClass = staticmethod(initClass)
def copy(self):
"""copy(SoFaceDetail self) -> SoDetail"""
return _coin.SoFaceDetail_copy(self)
def getNumPoints(self):
"""getNumPoints(SoFaceDetail self) -> int"""
return _coin.SoFaceDetail_getNumPoints(self)
def getPoint(self, idx):
"""getPoint(SoFaceDetail self, int const idx) -> SoPointDetail"""
return _coin.SoFaceDetail_getPoint(self, idx)
def getPoints(self):
"""getPoints(SoFaceDetail self) -> SoPointDetail"""
return _coin.SoFaceDetail_getPoints(self)
def getFaceIndex(self):
"""getFaceIndex(SoFaceDetail self) -> int"""
return _coin.SoFaceDetail_getFaceIndex(self)
def getPartIndex(self):
"""getPartIndex(SoFaceDetail self) -> int"""
return _coin.SoFaceDetail_getPartIndex(self)
def setNumPoints(self, num):
"""setNumPoints(SoFaceDetail self, int const num)"""
return _coin.SoFaceDetail_setNumPoints(self, num)
def setPoint(self, idx, detail):
"""setPoint(SoFaceDetail self, int const idx, SoPointDetail detail)"""
return _coin.SoFaceDetail_setPoint(self, idx, detail)
def setFaceIndex(self, idx):
"""setFaceIndex(SoFaceDetail self, int const idx)"""
return _coin.SoFaceDetail_setFaceIndex(self, idx)
def setPartIndex(self, idx):
"""setPartIndex(SoFaceDetail self, int const idx)"""
return _coin.SoFaceDetail_setPartIndex(self, idx)
def incFaceIndex(self):
"""incFaceIndex(SoFaceDetail self)"""
return _coin.SoFaceDetail_incFaceIndex(self)
def incPartIndex(self):
"""incPartIndex(SoFaceDetail self)"""
return _coin.SoFaceDetail_incPartIndex(self)
SoFaceDetail_swigregister = _coin.SoFaceDetail_swigregister
SoFaceDetail_swigregister(SoFaceDetail)
def SoFaceDetail_getClassTypeId():
"""SoFaceDetail_getClassTypeId() -> SoType"""
return _coin.SoFaceDetail_getClassTypeId()
def SoFaceDetail_cleanupClass():
"""SoFaceDetail_cleanupClass()"""
return _coin.SoFaceDetail_cleanupClass()
def SoFaceDetail_initClass():
"""SoFaceDetail_initClass()"""
return _coin.SoFaceDetail_initClass()
class SoLineDetail(SoDetail):
"""Proxy of C++ SoLineDetail class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoLineDetail self) -> SoType"""
return _coin.SoLineDetail_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoLineDetail_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoLineDetail_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def __init__(self):
"""__init__(SoLineDetail self) -> SoLineDetail"""
this = _coin.new_SoLineDetail()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoLineDetail
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoLineDetail_initClass()
initClass = staticmethod(initClass)
def copy(self):
"""copy(SoLineDetail self) -> SoDetail"""
return _coin.SoLineDetail_copy(self)
def getPoint0(self):
"""getPoint0(SoLineDetail self) -> SoPointDetail"""
return _coin.SoLineDetail_getPoint0(self)
def getPoint1(self):
"""getPoint1(SoLineDetail self) -> SoPointDetail"""
return _coin.SoLineDetail_getPoint1(self)
def getLineIndex(self):
"""getLineIndex(SoLineDetail self) -> int"""
return _coin.SoLineDetail_getLineIndex(self)
def getPartIndex(self):
"""getPartIndex(SoLineDetail self) -> int"""
return _coin.SoLineDetail_getPartIndex(self)
def setPoint0(self, detail):
"""setPoint0(SoLineDetail self, SoPointDetail detail)"""
return _coin.SoLineDetail_setPoint0(self, detail)
def setPoint1(self, detail):
"""setPoint1(SoLineDetail self, SoPointDetail detail)"""
return _coin.SoLineDetail_setPoint1(self, detail)
def setLineIndex(self, idx):
"""setLineIndex(SoLineDetail self, int const idx)"""
return _coin.SoLineDetail_setLineIndex(self, idx)
def setPartIndex(self, idx):
"""setPartIndex(SoLineDetail self, int const idx)"""
return _coin.SoLineDetail_setPartIndex(self, idx)
def incLineIndex(self):
"""incLineIndex(SoLineDetail self)"""
return _coin.SoLineDetail_incLineIndex(self)
def incPartIndex(self):
"""incPartIndex(SoLineDetail self)"""
return _coin.SoLineDetail_incPartIndex(self)
SoLineDetail_swigregister = _coin.SoLineDetail_swigregister
SoLineDetail_swigregister(SoLineDetail)
def SoLineDetail_getClassTypeId():
"""SoLineDetail_getClassTypeId() -> SoType"""
return _coin.SoLineDetail_getClassTypeId()
def SoLineDetail_cleanupClass():
"""SoLineDetail_cleanupClass()"""
return _coin.SoLineDetail_cleanupClass()
def SoLineDetail_initClass():
"""SoLineDetail_initClass()"""
return _coin.SoLineDetail_initClass()
class SoNodeKitDetail(SoDetail):
"""Proxy of C++ SoNodeKitDetail class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoNodeKitDetail self) -> SoType"""
return _coin.SoNodeKitDetail_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoNodeKitDetail_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoNodeKitDetail_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def __init__(self):
"""__init__(SoNodeKitDetail self) -> SoNodeKitDetail"""
this = _coin.new_SoNodeKitDetail()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoNodeKitDetail
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoNodeKitDetail_initClass()
initClass = staticmethod(initClass)
def copy(self):
"""copy(SoNodeKitDetail self) -> SoDetail"""
return _coin.SoNodeKitDetail_copy(self)
def setNodeKit(self, kit):
"""setNodeKit(SoNodeKitDetail self, SoBaseKit kit)"""
return _coin.SoNodeKitDetail_setNodeKit(self, kit)
def getNodeKit(self):
"""getNodeKit(SoNodeKitDetail self) -> SoBaseKit"""
return _coin.SoNodeKitDetail_getNodeKit(self)
def setPart(self, part):
"""setPart(SoNodeKitDetail self, SoNode part)"""
return _coin.SoNodeKitDetail_setPart(self, part)
def getPart(self):
"""getPart(SoNodeKitDetail self) -> SoNode"""
return _coin.SoNodeKitDetail_getPart(self)
def setPartName(self, name):
"""setPartName(SoNodeKitDetail self, SbName name)"""
return _coin.SoNodeKitDetail_setPartName(self, name)
def getPartName(self):
"""getPartName(SoNodeKitDetail self) -> SbName"""
return _coin.SoNodeKitDetail_getPartName(self)
SoNodeKitDetail_swigregister = _coin.SoNodeKitDetail_swigregister
SoNodeKitDetail_swigregister(SoNodeKitDetail)
def SoNodeKitDetail_getClassTypeId():
"""SoNodeKitDetail_getClassTypeId() -> SoType"""
return _coin.SoNodeKitDetail_getClassTypeId()
def SoNodeKitDetail_cleanupClass():
"""SoNodeKitDetail_cleanupClass()"""
return _coin.SoNodeKitDetail_cleanupClass()
def SoNodeKitDetail_initClass():
"""SoNodeKitDetail_initClass()"""
return _coin.SoNodeKitDetail_initClass()
class SoTextDetail(SoDetail):
"""Proxy of C++ SoTextDetail class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getTypeId(self):
"""getTypeId(SoTextDetail self) -> SoType"""
return _coin.SoTextDetail_getTypeId(self)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTextDetail_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def cleanupClass():
"""cleanupClass()"""
return _coin.SoTextDetail_cleanupClass()
cleanupClass = staticmethod(cleanupClass)
def __init__(self):
"""__init__(SoTextDetail self) -> SoTextDetail"""
this = _coin.new_SoTextDetail()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoTextDetail
__del__ = lambda self: None
def initClass():
"""initClass()"""
return _coin.SoTextDetail_initClass()
initClass = staticmethod(initClass)
def copy(self):
"""copy(SoTextDetail self) -> SoDetail"""
return _coin.SoTextDetail_copy(self)
def getStringIndex(self):
"""getStringIndex(SoTextDetail self) -> int"""
return _coin.SoTextDetail_getStringIndex(self)
def getCharacterIndex(self):
"""getCharacterIndex(SoTextDetail self) -> int"""
return _coin.SoTextDetail_getCharacterIndex(self)
def getPart(self):
"""getPart(SoTextDetail self) -> int"""
return _coin.SoTextDetail_getPart(self)
def setStringIndex(self, idx):
"""setStringIndex(SoTextDetail self, int const idx)"""
return _coin.SoTextDetail_setStringIndex(self, idx)
def setCharacterIndex(self, idx):
"""setCharacterIndex(SoTextDetail self, int const idx)"""
return _coin.SoTextDetail_setCharacterIndex(self, idx)
def setPart(self, idx):
"""setPart(SoTextDetail self, int const idx)"""
return _coin.SoTextDetail_setPart(self, idx)
SoTextDetail_swigregister = _coin.SoTextDetail_swigregister
SoTextDetail_swigregister(SoTextDetail)
def SoTextDetail_getClassTypeId():
"""SoTextDetail_getClassTypeId() -> SoType"""
return _coin.SoTextDetail_getClassTypeId()
def SoTextDetail_cleanupClass():
"""SoTextDetail_cleanupClass()"""
return _coin.SoTextDetail_cleanupClass()
def SoTextDetail_initClass():
"""SoTextDetail_initClass()"""
return _coin.SoTextDetail_initClass()
class SoSFNode(SoSField):
"""Proxy of C++ SoSFNode class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFNode self) -> SoSFNode"""
this = _coin.new_SoSFNode()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFNode
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFNode_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFNode_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFNode self) -> SoType"""
return _coin.SoSFNode_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFNode self, SoField field)"""
return _coin.SoSFNode_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFNode self, SoField field) -> SbBool"""
return _coin.SoSFNode_isSame(self, field)
def getValue(self):
"""getValue(SoSFNode self) -> SoNode"""
return _coin.SoSFNode_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFNode self, SoSFNode field) -> int"""
return _coin.SoSFNode___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFNode self, SoSFNode field) -> int"""
return _coin.SoSFNode___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFNode_initClass()
initClass = staticmethod(initClass)
def fixCopy(self, copyconnections):
"""fixCopy(SoSFNode self, SbBool copyconnections)"""
return _coin.SoSFNode_fixCopy(self, copyconnections)
def referencesCopy(self):
"""referencesCopy(SoSFNode self) -> SbBool"""
return _coin.SoSFNode_referencesCopy(self)
def setValue(self, *args):
"""
setValue(SoSFNode self, SoNode newvalue)
setValue(SoSFNode self, SoSFNode other)
"""
return _coin.SoSFNode_setValue(self, *args)
SoSFNode_swigregister = _coin.SoSFNode_swigregister
SoSFNode_swigregister(SoSFNode)
def SoSFNode_createInstance():
"""SoSFNode_createInstance() -> void *"""
return _coin.SoSFNode_createInstance()
def SoSFNode_getClassTypeId():
"""SoSFNode_getClassTypeId() -> SoType"""
return _coin.SoSFNode_getClassTypeId()
def SoSFNode_initClass():
"""SoSFNode_initClass()"""
return _coin.SoSFNode_initClass()
_coin.SO_CATALOG_NAME_NOT_FOUND_swigconstant(_coin)
SO_CATALOG_NAME_NOT_FOUND = _coin.SO_CATALOG_NAME_NOT_FOUND
class SoNodekitCatalog(object):
"""Proxy of C++ SoNodekitCatalog class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def initClass():
"""initClass()"""
return _coin.SoNodekitCatalog_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoNodekitCatalog self) -> SoNodekitCatalog"""
this = _coin.new_SoNodekitCatalog()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoNodekitCatalog
__del__ = lambda self: None
def getNumEntries(self):
"""getNumEntries(SoNodekitCatalog self) -> int"""
return _coin.SoNodekitCatalog_getNumEntries(self)
def getPartNumber(self, name):
"""getPartNumber(SoNodekitCatalog self, SbName name) -> int"""
return _coin.SoNodekitCatalog_getPartNumber(self, name)
def getName(self, part):
"""getName(SoNodekitCatalog self, int part) -> SbName"""
return _coin.SoNodekitCatalog_getName(self, part)
def getType(self, *args):
"""
getType(SoNodekitCatalog self, int part) -> SoType
getType(SoNodekitCatalog self, SbName name) -> SoType
"""
return _coin.SoNodekitCatalog_getType(self, *args)
def getDefaultType(self, *args):
"""
getDefaultType(SoNodekitCatalog self, int part) -> SoType
getDefaultType(SoNodekitCatalog self, SbName name) -> SoType
"""
return _coin.SoNodekitCatalog_getDefaultType(self, *args)
def isNullByDefault(self, *args):
"""
isNullByDefault(SoNodekitCatalog self, int part) -> SbBool
isNullByDefault(SoNodekitCatalog self, SbName name) -> SbBool
"""
return _coin.SoNodekitCatalog_isNullByDefault(self, *args)
def isLeaf(self, *args):
"""
isLeaf(SoNodekitCatalog self, int part) -> SbBool
isLeaf(SoNodekitCatalog self, SbName name) -> SbBool
"""
return _coin.SoNodekitCatalog_isLeaf(self, *args)
def getParentName(self, *args):
"""
getParentName(SoNodekitCatalog self, int part) -> SbName
getParentName(SoNodekitCatalog self, SbName name) -> SbName
"""
return _coin.SoNodekitCatalog_getParentName(self, *args)
def getParentPartNumber(self, *args):
"""
getParentPartNumber(SoNodekitCatalog self, int part) -> int
getParentPartNumber(SoNodekitCatalog self, SbName name) -> int
"""
return _coin.SoNodekitCatalog_getParentPartNumber(self, *args)
def getRightSiblingName(self, *args):
"""
getRightSiblingName(SoNodekitCatalog self, int part) -> SbName
getRightSiblingName(SoNodekitCatalog self, SbName name) -> SbName
"""
return _coin.SoNodekitCatalog_getRightSiblingName(self, *args)
def getRightSiblingPartNumber(self, *args):
"""
getRightSiblingPartNumber(SoNodekitCatalog self, int part) -> int
getRightSiblingPartNumber(SoNodekitCatalog self, SbName name) -> int
"""
return _coin.SoNodekitCatalog_getRightSiblingPartNumber(self, *args)
def isList(self, *args):
"""
isList(SoNodekitCatalog self, int part) -> SbBool
isList(SoNodekitCatalog self, SbName name) -> SbBool
"""
return _coin.SoNodekitCatalog_isList(self, *args)
def getListContainerType(self, *args):
"""
getListContainerType(SoNodekitCatalog self, int part) -> SoType
getListContainerType(SoNodekitCatalog self, SbName name) -> SoType
"""
return _coin.SoNodekitCatalog_getListContainerType(self, *args)
def getListItemTypes(self, *args):
"""
getListItemTypes(SoNodekitCatalog self, int part) -> SoTypeList
getListItemTypes(SoNodekitCatalog self, SbName name) -> SoTypeList
"""
return _coin.SoNodekitCatalog_getListItemTypes(self, *args)
def isPublic(self, *args):
"""
isPublic(SoNodekitCatalog self, int part) -> SbBool
isPublic(SoNodekitCatalog self, SbName name) -> SbBool
"""
return _coin.SoNodekitCatalog_isPublic(self, *args)
def clone(self, type):
"""clone(SoNodekitCatalog self, SoType type) -> SoNodekitCatalog"""
return _coin.SoNodekitCatalog_clone(self, type)
def addEntry(self, name, type, defaulttype, isdefaultnull, parent, rightsibling, islist, listcontainertype, listitemtype, ispublic):
"""addEntry(SoNodekitCatalog self, SbName name, SoType type, SoType defaulttype, SbBool isdefaultnull, SbName parent, SbName rightsibling, SbBool islist, SoType listcontainertype, SoType listitemtype, SbBool ispublic) -> SbBool"""
return _coin.SoNodekitCatalog_addEntry(self, name, type, defaulttype, isdefaultnull, parent, rightsibling, islist, listcontainertype, listitemtype, ispublic)
def addListItemType(self, *args):
"""
addListItemType(SoNodekitCatalog self, int part, SoType type)
addListItemType(SoNodekitCatalog self, SbName name, SoType type)
"""
return _coin.SoNodekitCatalog_addListItemType(self, *args)
def narrowTypes(self, name, newtype, newdefaulttype):
"""narrowTypes(SoNodekitCatalog self, SbName name, SoType newtype, SoType newdefaulttype)"""
return _coin.SoNodekitCatalog_narrowTypes(self, name, newtype, newdefaulttype)
def setNullByDefault(self, name, nullbydefault):
"""setNullByDefault(SoNodekitCatalog self, SbName name, SbBool nullbydefault)"""
return _coin.SoNodekitCatalog_setNullByDefault(self, name, nullbydefault)
def recursiveSearch(self, part, name, checked):
"""recursiveSearch(SoNodekitCatalog self, int part, SbName name, SoTypeList checked) -> SbBool"""
return _coin.SoNodekitCatalog_recursiveSearch(self, part, name, checked)
def printCheck(self):
"""printCheck(SoNodekitCatalog self)"""
return _coin.SoNodekitCatalog_printCheck(self)
SoNodekitCatalog_swigregister = _coin.SoNodekitCatalog_swigregister
SoNodekitCatalog_swigregister(SoNodekitCatalog)
def SoNodekitCatalog_initClass():
"""SoNodekitCatalog_initClass()"""
return _coin.SoNodekitCatalog_initClass()
class SoSFName(SoSField):
"""Proxy of C++ SoSFName class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFName self) -> SoSFName"""
this = _coin.new_SoSFName()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFName
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFName_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFName_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFName self) -> SoType"""
return _coin.SoSFName_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFName self, SoField field)"""
return _coin.SoSFName_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFName self, SoField field) -> SbBool"""
return _coin.SoSFName_isSame(self, field)
def getValue(self):
"""getValue(SoSFName self) -> SbName"""
return _coin.SoSFName_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFName self, SoSFName field) -> int"""
return _coin.SoSFName___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFName self, SoSFName field) -> int"""
return _coin.SoSFName___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFName_initClass()
initClass = staticmethod(initClass)
def setValue(self, *args):
"""
setValue(SoSFName self, SbName newvalue)
setValue(SoSFName self, char const *const name)
setValue(SoSFName self, SoSFName other)
"""
return _coin.SoSFName_setValue(self, *args)
SoSFName_swigregister = _coin.SoSFName_swigregister
SoSFName_swigregister(SoSFName)
def SoSFName_createInstance():
"""SoSFName_createInstance() -> void *"""
return _coin.SoSFName_createInstance()
def SoSFName_getClassTypeId():
"""SoSFName_getClassTypeId() -> SoType"""
return _coin.SoSFName_getClassTypeId()
def SoSFName_initClass():
"""SoSFName_initClass()"""
return _coin.SoSFName_initClass()
class SoMFName(SoMField):
"""Proxy of C++ SoMFName class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoMFName self) -> SoMFName"""
this = _coin.new_SoMFName()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoMFName
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoMFName_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoMFName_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoMFName self) -> SoType"""
return _coin.SoMFName_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoMFName self, SoField field)"""
return _coin.SoMFName_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoMFName self, SoField field) -> SbBool"""
return _coin.SoMFName_isSame(self, field)
def find(self, value, addifnotfound=0):
"""
find(SoMFName self, SbName value, SbBool addifnotfound=0) -> int
find(SoMFName self, SbName value) -> int
"""
return _coin.SoMFName_find(self, value, addifnotfound)
def set1Value(self, idx, value):
"""set1Value(SoMFName self, int const idx, SbName value)"""
return _coin.SoMFName_set1Value(self, idx, value)
def __eq__(self, field):
"""__eq__(SoMFName self, SoMFName field) -> SbBool"""
return _coin.SoMFName___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoMFName self, SoMFName field) -> SbBool"""
return _coin.SoMFName___ne__(self, field)
def startEditing(self):
"""startEditing(SoMFName self) -> SbName"""
return _coin.SoMFName_startEditing(self)
def finishEditing(self):
"""finishEditing(SoMFName self)"""
return _coin.SoMFName_finishEditing(self)
def initClass():
"""initClass()"""
return _coin.SoMFName_initClass()
initClass = staticmethod(initClass)
def setValues(*args):
if len(args) == 2:
return _coin.SoMFName_setValues(args[0], 0, len(args[1]), args[1])
elif len(args) == 3:
return _coin.SoMFName_setValues(args[0], args[1], len(args[2]), args[2])
return _coin.SoMFName_setValues(*args)
def __getitem__(self, i):
"""__getitem__(SoMFName self, int i) -> SbName"""
return _coin.SoMFName___getitem__(self, i)
def __setitem__(self, i, value):
"""__setitem__(SoMFName self, int i, SbName value)"""
return _coin.SoMFName___setitem__(self, i, value)
def setValue(self, *args):
"""
setValue(SoMFName self, SbName value)
setValue(SoMFName self, char const * str)
setValue(SoMFName self, SoMFName other)
"""
return _coin.SoMFName_setValue(self, *args)
def getValues(self, i=0):
"""
getValues(SoMFName self, int i=0) -> SbName
getValues(SoMFName self) -> SbName
"""
return _coin.SoMFName_getValues(self, i)
SoMFName_swigregister = _coin.SoMFName_swigregister
SoMFName_swigregister(SoMFName)
def SoMFName_createInstance():
"""SoMFName_createInstance() -> void *"""
return _coin.SoMFName_createInstance()
def SoMFName_getClassTypeId():
"""SoMFName_getClassTypeId() -> SoType"""
return _coin.SoMFName_getClassTypeId()
def SoMFName_initClass():
"""SoMFName_initClass()"""
return _coin.SoMFName_initClass()
class SoNodeKitListPart(SoNode):
"""Proxy of C++ SoNodeKitListPart class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoNodeKitListPart_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoNodeKitListPart self) -> SoType"""
return _coin.SoNodeKitListPart_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoNodeKitListPart_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoNodeKitListPart self) -> SoNodeKitListPart"""
this = _coin.new_SoNodeKitListPart()
try:
self.this.append(this)
except Exception:
self.this = this
def getContainerType(self):
"""getContainerType(SoNodeKitListPart self) -> SoType"""
return _coin.SoNodeKitListPart_getContainerType(self)
def setContainerType(self, newContainerType):
"""setContainerType(SoNodeKitListPart self, SoType newContainerType)"""
return _coin.SoNodeKitListPart_setContainerType(self, newContainerType)
def getChildTypes(self):
"""getChildTypes(SoNodeKitListPart self) -> SoTypeList"""
return _coin.SoNodeKitListPart_getChildTypes(self)
def addChildType(self, typeToAdd):
"""addChildType(SoNodeKitListPart self, SoType typeToAdd)"""
return _coin.SoNodeKitListPart_addChildType(self, typeToAdd)
def isTypePermitted(self, typeToCheck):
"""isTypePermitted(SoNodeKitListPart self, SoType typeToCheck) -> SbBool"""
return _coin.SoNodeKitListPart_isTypePermitted(self, typeToCheck)
def isChildPermitted(self, child):
"""isChildPermitted(SoNodeKitListPart self, SoNode child) -> SbBool"""
return _coin.SoNodeKitListPart_isChildPermitted(self, child)
def containerSet(self, fieldDataString):
"""containerSet(SoNodeKitListPart self, char const * fieldDataString)"""
return _coin.SoNodeKitListPart_containerSet(self, fieldDataString)
def lockTypes(self):
"""lockTypes(SoNodeKitListPart self)"""
return _coin.SoNodeKitListPart_lockTypes(self)
def isTypeLocked(self):
"""isTypeLocked(SoNodeKitListPart self) -> SbBool"""
return _coin.SoNodeKitListPart_isTypeLocked(self)
def addChild(self, child):
"""addChild(SoNodeKitListPart self, SoNode child)"""
return _coin.SoNodeKitListPart_addChild(self, child)
def insertChild(self, child, childIndex):
"""insertChild(SoNodeKitListPart self, SoNode child, int childIndex)"""
return _coin.SoNodeKitListPart_insertChild(self, child, childIndex)
def getChild(self, index):
"""getChild(SoNodeKitListPart self, int index) -> SoNode"""
return _coin.SoNodeKitListPart_getChild(self, index)
def findChild(self, child):
"""findChild(SoNodeKitListPart self, SoNode child) -> int"""
return _coin.SoNodeKitListPart_findChild(self, child)
def getNumChildren(self):
"""getNumChildren(SoNodeKitListPart self) -> int"""
return _coin.SoNodeKitListPart_getNumChildren(self)
def removeChild(self, *args):
"""
removeChild(SoNodeKitListPart self, int index)
removeChild(SoNodeKitListPart self, SoNode child)
"""
return _coin.SoNodeKitListPart_removeChild(self, *args)
def replaceChild(self, *args):
"""
replaceChild(SoNodeKitListPart self, int index, SoNode newChild)
replaceChild(SoNodeKitListPart self, SoNode oldChild, SoNode newChild)
"""
return _coin.SoNodeKitListPart_replaceChild(self, *args)
def affectsState(self):
"""affectsState(SoNodeKitListPart self) -> SbBool"""
return _coin.SoNodeKitListPart_affectsState(self)
def doAction(self, action):
"""doAction(SoNodeKitListPart self, SoAction action)"""
return _coin.SoNodeKitListPart_doAction(self, action)
def callback(self, action):
"""callback(SoNodeKitListPart self, SoCallbackAction action)"""
return _coin.SoNodeKitListPart_callback(self, action)
def GLRender(self, action):
"""GLRender(SoNodeKitListPart self, SoGLRenderAction action)"""
return _coin.SoNodeKitListPart_GLRender(self, action)
def getBoundingBox(self, action):
"""getBoundingBox(SoNodeKitListPart self, SoGetBoundingBoxAction action)"""
return _coin.SoNodeKitListPart_getBoundingBox(self, action)
def getMatrix(self, action):
"""getMatrix(SoNodeKitListPart self, SoGetMatrixAction action)"""
return _coin.SoNodeKitListPart_getMatrix(self, action)
def handleEvent(self, action):
"""handleEvent(SoNodeKitListPart self, SoHandleEventAction action)"""
return _coin.SoNodeKitListPart_handleEvent(self, action)
def pick(self, action):
"""pick(SoNodeKitListPart self, SoPickAction action)"""
return _coin.SoNodeKitListPart_pick(self, action)
def search(self, action):
"""search(SoNodeKitListPart self, SoSearchAction action)"""
return _coin.SoNodeKitListPart_search(self, action)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoNodeKitListPart self, SoGetPrimitiveCountAction action)"""
return _coin.SoNodeKitListPart_getPrimitiveCount(self, action)
def getChildren(self):
"""getChildren(SoNodeKitListPart self) -> SoChildList"""
return _coin.SoNodeKitListPart_getChildren(self)
SoNodeKitListPart_swigregister = _coin.SoNodeKitListPart_swigregister
SoNodeKitListPart_swigregister(SoNodeKitListPart)
def SoNodeKitListPart_getClassTypeId():
"""SoNodeKitListPart_getClassTypeId() -> SoType"""
return _coin.SoNodeKitListPart_getClassTypeId()
def SoNodeKitListPart_initClass():
"""SoNodeKitListPart_initClass()"""
return _coin.SoNodeKitListPart_initClass()
class SoNodeKitPath(SoPath):
"""Proxy of C++ SoNodeKitPath class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getLength(self):
"""getLength(SoNodeKitPath self) -> int"""
return _coin.SoNodeKitPath_getLength(self)
def getTail(self):
"""getTail(SoNodeKitPath self) -> SoNode"""
return _coin.SoNodeKitPath_getTail(self)
def getNode(self, idx):
"""getNode(SoNodeKitPath self, int const idx) -> SoNode"""
return _coin.SoNodeKitPath_getNode(self, idx)
def getNodeFromTail(self, idx):
"""getNodeFromTail(SoNodeKitPath self, int const idx) -> SoNode"""
return _coin.SoNodeKitPath_getNodeFromTail(self, idx)
def truncate(self, length):
"""truncate(SoNodeKitPath self, int const length)"""
return _coin.SoNodeKitPath_truncate(self, length)
def pop(self):
"""pop(SoNodeKitPath self)"""
return _coin.SoNodeKitPath_pop(self)
def append(self, *args):
"""
append(SoNodeKitPath self, SoBaseKit childKit)
append(SoNodeKitPath self, SoNodeKitPath fromPath)
"""
return _coin.SoNodeKitPath_append(self, *args)
def containsNode(self, node):
"""containsNode(SoNodeKitPath self, SoBaseKit node) -> SbBool"""
return _coin.SoNodeKitPath_containsNode(self, node)
def findFork(self, path):
"""findFork(SoNodeKitPath self, SoNodeKitPath path) -> int"""
return _coin.SoNodeKitPath_findFork(self, path)
def __iter__(self):
for i in range(self.getLength()):
yield self.getNode(i)
def index(self):
for i in range(self.getLength()):
yield self.getIndex(i)
def __eq__(self, u):
"""__eq__(SoNodeKitPath self, SoNodeKitPath u) -> int"""
return _coin.SoNodeKitPath___eq__(self, u)
def __nq__(self, u):
"""__nq__(SoNodeKitPath self, SoNodeKitPath u) -> int"""
return _coin.SoNodeKitPath___nq__(self, u)
SoNodeKitPath_swigregister = _coin.SoNodeKitPath_swigregister
SoNodeKitPath_swigregister(SoNodeKitPath)
class SoChildList(SoNodeList):
"""Proxy of C++ SoChildList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SoChildList self, SoNode parent) -> SoChildList
__init__(SoChildList self, SoNode parent, int const size) -> SoChildList
__init__(SoChildList self, SoNode parent, SoChildList cl) -> SoChildList
"""
this = _coin.new_SoChildList(*args)
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoChildList
__del__ = lambda self: None
def append(self, node):
"""append(SoChildList self, SoNode node)"""
return _coin.SoChildList_append(self, node)
def insert(self, ptr, addbefore):
"""insert(SoChildList self, SoNode ptr, int const addbefore)"""
return _coin.SoChildList_insert(self, ptr, addbefore)
def remove(self, index):
"""remove(SoChildList self, int const index)"""
return _coin.SoChildList_remove(self, index)
def truncate(self, length):
"""truncate(SoChildList self, int const length)"""
return _coin.SoChildList_truncate(self, length)
def copy(self, cl):
"""copy(SoChildList self, SoChildList cl)"""
return _coin.SoChildList_copy(self, cl)
def set(self, index, node):
"""set(SoChildList self, int const index, SoNode node)"""
return _coin.SoChildList_set(self, index, node)
def traverseInPath(self, action, numindices, indices):
"""traverseInPath(SoChildList self, SoAction action, int const numindices, int const * indices)"""
return _coin.SoChildList_traverseInPath(self, action, numindices, indices)
def traverse(self, *args):
"""
traverse(SoChildList self, SoAction action)
traverse(SoChildList self, SoAction action, int const index)
traverse(SoChildList self, SoAction action, SoNode node)
traverse(SoChildList self, SoAction action, int const first, int const last)
"""
return _coin.SoChildList_traverse(self, *args)
def addPathAuditor(self, path):
"""addPathAuditor(SoChildList self, SoPath path)"""
return _coin.SoChildList_addPathAuditor(self, path)
def removePathAuditor(self, path):
"""removePathAuditor(SoChildList self, SoPath path)"""
return _coin.SoChildList_removePathAuditor(self, path)
SoChildList_swigregister = _coin.SoChildList_swigregister
SoChildList_swigregister(SoChildList)
class SoBaseKit(SoNode):
"""Proxy of C++ SoBaseKit class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoBaseKit_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoBaseKit self) -> SoType"""
return _coin.SoBaseKit_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoBaseKit_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoBaseKit self) -> SoBaseKit"""
this = _coin.new_SoBaseKit()
try:
self.this.append(this)
except Exception:
self.this = this
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoBaseKit_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoBaseKit self) -> SoNodekitCatalog"""
return _coin.SoBaseKit_getNodekitCatalog(self)
def getPart(self, partname, makeifneeded):
"""getPart(SoBaseKit self, SbName partname, SbBool makeifneeded) -> SoNode"""
return _coin.SoBaseKit_getPart(self, partname, makeifneeded)
def getPartString(self, part):
"""getPartString(SoBaseKit self, SoBase part) -> SbString"""
return _coin.SoBaseKit_getPartString(self, part)
def createPathToPart(self, partname, makeifneeded, pathtoextend=None):
"""
createPathToPart(SoBaseKit self, SbName partname, SbBool makeifneeded, SoPath pathtoextend=None) -> SoNodeKitPath
createPathToPart(SoBaseKit self, SbName partname, SbBool makeifneeded) -> SoNodeKitPath
"""
return _coin.SoBaseKit_createPathToPart(self, partname, makeifneeded, pathtoextend)
def setPart(self, partname, arg3):
"""setPart(SoBaseKit self, SbName partname, SoNode arg3) -> SbBool"""
return _coin.SoBaseKit_setPart(self, partname, arg3)
def set(self, *args):
"""
set(SoBaseKit self, char const * namevaluepairliststring) -> SbBool
set(SoBaseKit self, char const * partnamestring, char const * parameterstring) -> SbBool
"""
return _coin.SoBaseKit_set(self, *args)
def doAction(self, action):
"""doAction(SoBaseKit self, SoAction action)"""
return _coin.SoBaseKit_doAction(self, action)
def callback(self, action):
"""callback(SoBaseKit self, SoCallbackAction action)"""
return _coin.SoBaseKit_callback(self, action)
def GLRender(self, action):
"""GLRender(SoBaseKit self, SoGLRenderAction action)"""
return _coin.SoBaseKit_GLRender(self, action)
def getBoundingBox(self, action):
"""getBoundingBox(SoBaseKit self, SoGetBoundingBoxAction action)"""
return _coin.SoBaseKit_getBoundingBox(self, action)
def getMatrix(self, action):
"""getMatrix(SoBaseKit self, SoGetMatrixAction action)"""
return _coin.SoBaseKit_getMatrix(self, action)
def handleEvent(self, action):
"""handleEvent(SoBaseKit self, SoHandleEventAction action)"""
return _coin.SoBaseKit_handleEvent(self, action)
def rayPick(self, action):
"""rayPick(SoBaseKit self, SoRayPickAction action)"""
return _coin.SoBaseKit_rayPick(self, action)
def search(self, action):
"""search(SoBaseKit self, SoSearchAction action)"""
return _coin.SoBaseKit_search(self, action)
def write(self, action):
"""write(SoBaseKit self, SoWriteAction action)"""
return _coin.SoBaseKit_write(self, action)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoBaseKit self, SoGetPrimitiveCountAction action)"""
return _coin.SoBaseKit_getPrimitiveCount(self, action)
def getChildren(self):
"""getChildren(SoBaseKit self) -> SoChildList"""
return _coin.SoBaseKit_getChildren(self)
def printDiagram(self):
"""printDiagram(SoBaseKit self)"""
return _coin.SoBaseKit_printDiagram(self)
def printSubDiagram(self, rootname, level):
"""printSubDiagram(SoBaseKit self, SbName rootname, int level)"""
return _coin.SoBaseKit_printSubDiagram(self, rootname, level)
def printTable(self):
"""printTable(SoBaseKit self)"""
return _coin.SoBaseKit_printTable(self)
def addWriteReference(self, out, isfromfield=0):
"""
addWriteReference(SoBaseKit self, SoOutput out, SbBool isfromfield=0)
addWriteReference(SoBaseKit self, SoOutput out)
"""
return _coin.SoBaseKit_addWriteReference(self, out, isfromfield)
def forceChildDrivenWriteRefs(self, out):
"""forceChildDrivenWriteRefs(SoBaseKit self, SoOutput out) -> SbBool"""
return _coin.SoBaseKit_forceChildDrivenWriteRefs(self, out)
def isSearchingChildren():
"""isSearchingChildren() -> SbBool"""
return _coin.SoBaseKit_isSearchingChildren()
isSearchingChildren = staticmethod(isSearchingChildren)
def setSearchingChildren(newval):
"""setSearchingChildren(SbBool const newval)"""
return _coin.SoBaseKit_setSearchingChildren(newval)
setSearchingChildren = staticmethod(setSearchingChildren)
def __getattr__(self,name):
c = _coin.SoBaseKit_getNodekitCatalog(self)
if c.getPartNumber(name) >= 0:
part = self.getPart(name,1)
return part
return SoNode.__getattr__(self, name)
def __setattr__(self,name,value):
if name == 'this':
return SoNode.__setattr__(self,name,value)
c = _coin.SoBaseKit_getNodekitCatalog(self)
if c.getPartNumber(name) >= 0:
return self.setPart(name, value)
return SoNode.__setattr__(self,name,value)
SoBaseKit_swigregister = _coin.SoBaseKit_swigregister
SoBaseKit_swigregister(SoBaseKit)
def SoBaseKit_getClassTypeId():
"""SoBaseKit_getClassTypeId() -> SoType"""
return _coin.SoBaseKit_getClassTypeId()
def SoBaseKit_initClass():
"""SoBaseKit_initClass()"""
return _coin.SoBaseKit_initClass()
def SoBaseKit_getClassNodekitCatalog():
"""SoBaseKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoBaseKit_getClassNodekitCatalog()
def SoBaseKit_isSearchingChildren():
"""SoBaseKit_isSearchingChildren() -> SbBool"""
return _coin.SoBaseKit_isSearchingChildren()
def SoBaseKit_setSearchingChildren(newval):
"""SoBaseKit_setSearchingChildren(SbBool const newval)"""
return _coin.SoBaseKit_setSearchingChildren(newval)
class SoSensor(object):
"""Proxy of C++ SoSensor class."""
thisown = _swig_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__ = _coin.delete_SoSensor
__del__ = lambda self: None
def setFunction(self, callbackfunction):
"""setFunction(SoSensor self, SoSensorCB * callbackfunction)"""
return _coin.SoSensor_setFunction(self, callbackfunction)
def getFunction(self):
"""getFunction(SoSensor self) -> SoSensorCBPtr"""
return _coin.SoSensor_getFunction(self)
def setData(self, callbackdata):
"""setData(SoSensor self, void * callbackdata)"""
return _coin.SoSensor_setData(self, callbackdata)
def getData(self):
"""getData(SoSensor self) -> void *"""
return _coin.SoSensor_getData(self)
def schedule(self):
"""schedule(SoSensor self)"""
return _coin.SoSensor_schedule(self)
def unschedule(self):
"""unschedule(SoSensor self)"""
return _coin.SoSensor_unschedule(self)
def isScheduled(self):
"""isScheduled(SoSensor self) -> SbBool"""
return _coin.SoSensor_isScheduled(self)
def trigger(self):
"""trigger(SoSensor self)"""
return _coin.SoSensor_trigger(self)
def isBefore(self, s):
"""isBefore(SoSensor self, SoSensor s) -> SbBool"""
return _coin.SoSensor_isBefore(self, s)
def setNextInQueue(self, next):
"""setNextInQueue(SoSensor self, SoSensor next)"""
return _coin.SoSensor_setNextInQueue(self, next)
def getNextInQueue(self):
"""getNextInQueue(SoSensor self) -> SoSensor"""
return _coin.SoSensor_getNextInQueue(self)
def initClass():
"""initClass()"""
return _coin.SoSensor_initClass()
initClass = staticmethod(initClass)
SoSensor_swigregister = _coin.SoSensor_swigregister
SoSensor_swigregister(SoSensor)
def SoSensor_initClass():
"""SoSensor_initClass()"""
return _coin.SoSensor_initClass()
class SoDelayQueueSensor(SoSensor):
"""Proxy of C++ SoDelayQueueSensor class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
newobj = None
if len(args) == 2:
args = (args[0], (args[0], args[1], "SoDelayQueueSensor *"))
newobj = _coin.new_SoDelayQueueSensor_scb_v(*args)
else:
newobj = _coin.new_SoDelayQueueSensor(*args)
if newobj:
self.this = newobj.this
self.thisown = 1
__swig_destroy__ = _coin.delete_SoDelayQueueSensor
__del__ = lambda self: None
def setPriority(self, pri):
"""setPriority(SoDelayQueueSensor self, uint32_t pri)"""
return _coin.SoDelayQueueSensor_setPriority(self, pri)
def getPriority(self):
"""getPriority(SoDelayQueueSensor self) -> uint32_t"""
return _coin.SoDelayQueueSensor_getPriority(self)
def getDefaultPriority():
"""getDefaultPriority() -> uint32_t"""
return _coin.SoDelayQueueSensor_getDefaultPriority()
getDefaultPriority = staticmethod(getDefaultPriority)
def schedule(self):
"""schedule(SoDelayQueueSensor self)"""
return _coin.SoDelayQueueSensor_schedule(self)
def unschedule(self):
"""unschedule(SoDelayQueueSensor self)"""
return _coin.SoDelayQueueSensor_unschedule(self)
def isScheduled(self):
"""isScheduled(SoDelayQueueSensor self) -> SbBool"""
return _coin.SoDelayQueueSensor_isScheduled(self)
def isIdleOnly(self):
"""isIdleOnly(SoDelayQueueSensor self) -> SbBool"""
return _coin.SoDelayQueueSensor_isIdleOnly(self)
def trigger(self):
"""trigger(SoDelayQueueSensor self)"""
return _coin.SoDelayQueueSensor_trigger(self)
SoDelayQueueSensor_swigregister = _coin.SoDelayQueueSensor_swigregister
SoDelayQueueSensor_swigregister(SoDelayQueueSensor)
def __init__(self, *args):
newobj = None
if len(args) == 2:
args = (args[0], (args[0], args[1], "SoDelayQueueSensor *"))
newobj = _coin.new_SoDelayQueueSensor_scb_v(*args)
else:
newobj = _coin.new_SoDelayQueueSensor(*args)
if newobj:
self.this = newobj.this
self.thisown = 1
def SoDelayQueueSensor_getDefaultPriority():
"""SoDelayQueueSensor_getDefaultPriority() -> uint32_t"""
return _coin.SoDelayQueueSensor_getDefaultPriority()
class SoDataSensor(SoDelayQueueSensor):
"""Proxy of C++ SoDataSensor class."""
thisown = _swig_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__ = _coin.delete_SoDataSensor
__del__ = lambda self: None
def setDeleteCallback(self, function, data=None):
"""
setDeleteCallback(SoDataSensor self, SoSensorCB * function, void * data=None)
setDeleteCallback(SoDataSensor self, SoSensorCB * function)
"""
return _coin.SoDataSensor_setDeleteCallback(self, function, data)
def getTriggerNode(self):
"""getTriggerNode(SoDataSensor self) -> SoNode"""
return _coin.SoDataSensor_getTriggerNode(self)
def getTriggerField(self):
"""getTriggerField(SoDataSensor self) -> SoField"""
return _coin.SoDataSensor_getTriggerField(self)
def getTriggerPath(self):
"""getTriggerPath(SoDataSensor self) -> SoPath"""
return _coin.SoDataSensor_getTriggerPath(self)
def setTriggerPathFlag(self, flag):
"""setTriggerPathFlag(SoDataSensor self, SbBool flag)"""
return _coin.SoDataSensor_setTriggerPathFlag(self, flag)
def getTriggerPathFlag(self):
"""getTriggerPathFlag(SoDataSensor self) -> SbBool"""
return _coin.SoDataSensor_getTriggerPathFlag(self)
def getTriggerOperationType(self):
"""getTriggerOperationType(SoDataSensor self) -> SoNotRec::OperationType"""
return _coin.SoDataSensor_getTriggerOperationType(self)
def getTriggerIndex(self):
"""getTriggerIndex(SoDataSensor self) -> int"""
return _coin.SoDataSensor_getTriggerIndex(self)
def getTriggerFieldNumIndices(self):
"""getTriggerFieldNumIndices(SoDataSensor self) -> int"""
return _coin.SoDataSensor_getTriggerFieldNumIndices(self)
def getTriggerGroupChild(self):
"""getTriggerGroupChild(SoDataSensor self) -> SoNode"""
return _coin.SoDataSensor_getTriggerGroupChild(self)
def getTriggerReplacedGroupChild(self):
"""getTriggerReplacedGroupChild(SoDataSensor self) -> SoNode"""
return _coin.SoDataSensor_getTriggerReplacedGroupChild(self)
def trigger(self):
"""trigger(SoDataSensor self)"""
return _coin.SoDataSensor_trigger(self)
def notify(self, l):
"""notify(SoDataSensor self, SoNotList l)"""
return _coin.SoDataSensor_notify(self, l)
def dyingReference(self):
"""dyingReference(SoDataSensor self)"""
return _coin.SoDataSensor_dyingReference(self)
SoDataSensor_swigregister = _coin.SoDataSensor_swigregister
SoDataSensor_swigregister(SoDataSensor)
class SoFieldSensor(SoDataSensor):
"""Proxy of C++ SoFieldSensor class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
newobj = None
if len(args) == 2:
args = (args[0], (args[0], args[1], "SoFieldSensor *"))
newobj = _coin.new_SoFieldSensor_scb_v(*args)
else:
newobj = _coin.new_SoFieldSensor(*args)
if newobj:
self.this = newobj.this
self.thisown = 1
__swig_destroy__ = _coin.delete_SoFieldSensor
__del__ = lambda self: None
def attach(self, field):
"""attach(SoFieldSensor self, SoField field)"""
return _coin.SoFieldSensor_attach(self, field)
def detach(self):
"""detach(SoFieldSensor self)"""
return _coin.SoFieldSensor_detach(self)
def getAttachedField(self):
"""getAttachedField(SoFieldSensor self) -> SoField"""
return _coin.SoFieldSensor_getAttachedField(self)
def trigger(self):
"""trigger(SoFieldSensor self)"""
return _coin.SoFieldSensor_trigger(self)
SoFieldSensor_swigregister = _coin.SoFieldSensor_swigregister
SoFieldSensor_swigregister(SoFieldSensor)
def __init__(self, *args):
newobj = None
if len(args) == 2:
args = (args[0], (args[0], args[1], "SoFieldSensor *"))
newobj = _coin.new_SoFieldSensor_scb_v(*args)
else:
newobj = _coin.new_SoFieldSensor(*args)
if newobj:
self.this = newobj.this
self.thisown = 1
class SoInteractionKit(SoBaseKit):
"""Proxy of C++ SoInteractionKit class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoInteractionKit_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoInteractionKit self) -> SoType"""
return _coin.SoInteractionKit_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoInteractionKit_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoInteractionKit self) -> SoNodekitCatalog"""
return _coin.SoInteractionKit_getNodekitCatalog(self)
renderCaching = _swig_property(_coin.SoInteractionKit_renderCaching_get, _coin.SoInteractionKit_renderCaching_set)
boundingBoxCaching = _swig_property(_coin.SoInteractionKit_boundingBoxCaching_get, _coin.SoInteractionKit_boundingBoxCaching_set)
renderCulling = _swig_property(_coin.SoInteractionKit_renderCulling_get, _coin.SoInteractionKit_renderCulling_set)
pickCulling = _swig_property(_coin.SoInteractionKit_pickCulling_get, _coin.SoInteractionKit_pickCulling_set)
def __init__(self):
"""__init__(SoInteractionKit self) -> SoInteractionKit"""
this = _coin.new_SoInteractionKit()
try:
self.this.append(this)
except Exception:
self.this = this
def initClass():
"""initClass()"""
return _coin.SoInteractionKit_initClass()
initClass = staticmethod(initClass)
OFF = _coin.SoInteractionKit_OFF
ON = _coin.SoInteractionKit_ON
AUTO = _coin.SoInteractionKit_AUTO
def setPartAsPath(self, partname, path):
"""setPartAsPath(SoInteractionKit self, SbName partname, SoPath path) -> SbBool"""
return _coin.SoInteractionKit_setPartAsPath(self, partname, path)
def setPartAsDefault(self, *args):
"""
setPartAsDefault(SoInteractionKit self, SbName partname, SoNode node, SbBool onlyifdefault=1) -> SbBool
setPartAsDefault(SoInteractionKit self, SbName partname, SoNode node) -> SbBool
setPartAsDefault(SoInteractionKit self, SbName partname, SbName nodename, SbBool onlyifdefault=1) -> SbBool
setPartAsDefault(SoInteractionKit self, SbName partname, SbName nodename) -> SbBool
"""
return _coin.SoInteractionKit_setPartAsDefault(self, *args)
def isPathSurrogateInMySubgraph(self, *args):
"""
isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path, SoPath *& pathToOwner, SbName surrogatename, SoPath *& surrogatepath, SbBool fillargs=1) -> SbBool
isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path, SoPath *& pathToOwner, SbName surrogatename, SoPath *& surrogatepath) -> SbBool
isPathSurrogateInMySubgraph(SoInteractionKit self, SoPath path) -> SbBool
"""
return _coin.SoInteractionKit_isPathSurrogateInMySubgraph(self, *args)
def setSwitchValue(node, newVal):
"""setSwitchValue(SoNode node, int const newVal)"""
return _coin.SoInteractionKit_setSwitchValue(node, newVal)
setSwitchValue = staticmethod(setSwitchValue)
def setPart(self, partname, arg3):
"""setPart(SoInteractionKit self, SbName partname, SoNode arg3) -> SbBool"""
return _coin.SoInteractionKit_setPart(self, partname, arg3)
SoInteractionKit_swigregister = _coin.SoInteractionKit_swigregister
SoInteractionKit_swigregister(SoInteractionKit)
def SoInteractionKit_getClassTypeId():
"""SoInteractionKit_getClassTypeId() -> SoType"""
return _coin.SoInteractionKit_getClassTypeId()
def SoInteractionKit_getClassNodekitCatalog():
"""SoInteractionKit_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoInteractionKit_getClassNodekitCatalog()
def SoInteractionKit_initClass():
"""SoInteractionKit_initClass()"""
return _coin.SoInteractionKit_initClass()
def SoInteractionKit_setSwitchValue(node, newVal):
"""SoInteractionKit_setSwitchValue(SoNode node, int const newVal)"""
return _coin.SoInteractionKit_setSwitchValue(node, newVal)
class SoCallbackList(object):
"""Proxy of C++ SoCallbackList class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoCallbackList self) -> SoCallbackList"""
this = _coin.new_SoCallbackList()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoCallbackList
__del__ = lambda self: None
def addCallback(self, f, userData=None):
"""
addCallback(SoCallbackList self, SoCallbackListCB * f, void * userData=None)
addCallback(SoCallbackList self, SoCallbackListCB * f)
"""
return _coin.SoCallbackList_addCallback(self, f, userData)
def removeCallback(self, f, userdata=None):
"""
removeCallback(SoCallbackList self, SoCallbackListCB * f, void * userdata=None)
removeCallback(SoCallbackList self, SoCallbackListCB * f)
"""
return _coin.SoCallbackList_removeCallback(self, f, userdata)
def clearCallbacks(self):
"""clearCallbacks(SoCallbackList self)"""
return _coin.SoCallbackList_clearCallbacks(self)
def getNumCallbacks(self):
"""getNumCallbacks(SoCallbackList self) -> int"""
return _coin.SoCallbackList_getNumCallbacks(self)
def invokeCallbacks(self, callbackdata):
"""invokeCallbacks(SoCallbackList self, void * callbackdata)"""
return _coin.SoCallbackList_invokeCallbacks(self, callbackdata)
SoCallbackList_swigregister = _coin.SoCallbackList_swigregister
SoCallbackList_swigregister(SoCallbackList)
class SbVec3d(object):
"""Proxy of C++ SbVec3d class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbVec3d self) -> SbVec3d
__init__(SbVec3d self, double const [3] v) -> SbVec3d
__init__(SbVec3d self, double x, double y, double z) -> SbVec3d
__init__(SbVec3d self, SbVec3f v) -> SbVec3d
__init__(SbVec3d self, SbVec3b v) -> SbVec3d
__init__(SbVec3d self, SbVec3s v) -> SbVec3d
__init__(SbVec3d self, SbVec3i32 v) -> SbVec3d
__init__(SbVec3d self, SbDPPlane p0, SbDPPlane p1, SbDPPlane p2) -> SbVec3d
"""
this = _coin.new_SbVec3d(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def setValue(self, *args):
"""
setValue(SbVec3d self, double const [3] v) -> SbVec3d
setValue(SbVec3d self, double x, double y, double z) -> SbVec3d
setValue(SbVec3d self, SbVec3d barycentric, SbVec3d v0, SbVec3d v1, SbVec3d v2) -> SbVec3d
setValue(SbVec3d self, SbVec3f v) -> SbVec3d
setValue(SbVec3d self, SbVec3b v) -> SbVec3d
setValue(SbVec3d self, SbVec3s v) -> SbVec3d
setValue(SbVec3d self, SbVec3i32 v) -> SbVec3d
"""
return _coin.SbVec3d_setValue(self, *args)
def getValue(self):
"""getValue(SbVec3d self) -> double const *"""
return _coin.SbVec3d_getValue(self)
def cross(self, v):
"""cross(SbVec3d self, SbVec3d v) -> SbVec3d"""
return _coin.SbVec3d_cross(self, v)
def dot(self, v):
"""dot(SbVec3d self, SbVec3d v) -> double"""
return _coin.SbVec3d_dot(self, v)
def equals(self, v, tolerance):
"""equals(SbVec3d self, SbVec3d v, double tolerance) -> SbBool"""
return _coin.SbVec3d_equals(self, v, tolerance)
def getClosestAxis(self):
"""getClosestAxis(SbVec3d self) -> SbVec3d"""
return _coin.SbVec3d_getClosestAxis(self)
def length(self):
"""length(SbVec3d self) -> double"""
return _coin.SbVec3d_length(self)
def sqrLength(self):
"""sqrLength(SbVec3d self) -> double"""
return _coin.SbVec3d_sqrLength(self)
def negate(self):
"""negate(SbVec3d self)"""
return _coin.SbVec3d_negate(self)
def normalize(self):
"""normalize(SbVec3d self) -> double"""
return _coin.SbVec3d_normalize(self)
def __imul__(self, d):
"""__imul__(SbVec3d self, double d) -> SbVec3d"""
return _coin.SbVec3d___imul__(self, d)
def __idiv__(self, d):
"""__idiv__(SbVec3d self, double d) -> SbVec3d"""
return _coin.SbVec3d___idiv__(self, d)
def __iadd__(self, v):
"""__iadd__(SbVec3d self, SbVec3d v) -> SbVec3d"""
return _coin.SbVec3d___iadd__(self, v)
def __isub__(self, v):
"""__isub__(SbVec3d self, SbVec3d v) -> SbVec3d"""
return _coin.SbVec3d___isub__(self, v)
def __neg__(self):
"""__neg__(SbVec3d self) -> SbVec3d"""
return _coin.SbVec3d___neg__(self)
def toString(self):
"""toString(SbVec3d self) -> SbString"""
return _coin.SbVec3d_toString(self)
def fromString(self, str):
"""fromString(SbVec3d self, SbString str) -> SbBool"""
return _coin.SbVec3d_fromString(self, str)
def output(self, fp):
"""output(SbVec3d self, FILE * fp)"""
return _coin.SbVec3d_output(self, fp)
def __add__(self, u):
"""__add__(SbVec3d self, SbVec3d u) -> SbVec3d"""
return _coin.SbVec3d___add__(self, u)
def __sub__(self, u):
"""__sub__(SbVec3d self, SbVec3d u) -> SbVec3d"""
return _coin.SbVec3d___sub__(self, u)
def __mul__(self, *args):
"""
__mul__(SbVec3d self, double const d) -> SbVec3d
__mul__(SbVec3d self, SbDPMatrix m) -> SbVec3d
"""
return _coin.SbVec3d___mul__(self, *args)
def __rmul__(self, d):
"""__rmul__(SbVec3d self, double const d) -> SbVec3d"""
return _coin.SbVec3d___rmul__(self, d)
def __div__(self, d):
"""__div__(SbVec3d self, double const d) -> SbVec3d"""
return _coin.SbVec3d___div__(self, d)
def __truediv__(self, d):
"""__truediv__(SbVec3d self, double const d) -> SbVec3d"""
return _coin.SbVec3d___truediv__(self, d)
def __eq__(self, u):
"""__eq__(SbVec3d self, SbVec3d u) -> int"""
return _coin.SbVec3d___eq__(self, u)
def __nq__(self, u):
"""__nq__(SbVec3d self, SbVec3d u) -> int"""
return _coin.SbVec3d___nq__(self, u)
def __getitem__(self, i):
"""__getitem__(SbVec3d self, int i) -> double"""
return _coin.SbVec3d___getitem__(self, i)
def __setitem__(self, i, value):
"""__setitem__(SbVec3d self, int i, double value)"""
return _coin.SbVec3d___setitem__(self, i, value)
def __iter__(self):
for i in range(3):
yield self[i]
def __len__(self):
return 3
__swig_destroy__ = _coin.delete_SbVec3d
__del__ = lambda self: None
SbVec3d_swigregister = _coin.SbVec3d_swigregister
SbVec3d_swigregister(SbVec3d)
class SbDPViewVolume(object):
"""Proxy of C++ SbDPViewVolume class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
ORTHOGRAPHIC = _coin.SbDPViewVolume_ORTHOGRAPHIC
PERSPECTIVE = _coin.SbDPViewVolume_PERSPECTIVE
def __init__(self):
"""__init__(SbDPViewVolume self) -> SbDPViewVolume"""
this = _coin.new_SbDPViewVolume()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SbDPViewVolume
__del__ = lambda self: None
def getMatrices(self, affine, proj):
"""getMatrices(SbDPViewVolume self, SbDPMatrix affine, SbDPMatrix proj)"""
return _coin.SbDPViewVolume_getMatrices(self, affine, proj)
def getMatrix(self):
"""getMatrix(SbDPViewVolume self) -> SbDPMatrix"""
return _coin.SbDPViewVolume_getMatrix(self)
def getCameraSpaceMatrix(self):
"""getCameraSpaceMatrix(SbDPViewVolume self) -> SbDPMatrix"""
return _coin.SbDPViewVolume_getCameraSpaceMatrix(self)
def projectPointToLine(self, *args):
"""
projectPointToLine(SbDPViewVolume self, SbVec2d pt, SbDPLine line)
projectPointToLine(SbDPViewVolume self, SbVec2d pt, SbVec3d line0, SbVec3d line1)
"""
return _coin.SbDPViewVolume_projectPointToLine(self, *args)
def projectToScreen(self, src, dst):
"""projectToScreen(SbDPViewVolume self, SbVec3d src, SbVec3d dst)"""
return _coin.SbDPViewVolume_projectToScreen(self, src, dst)
def getPlane(self, distFromEye):
"""getPlane(SbDPViewVolume self, double const distFromEye) -> SbPlane"""
return _coin.SbDPViewVolume_getPlane(self, distFromEye)
def getSightPoint(self, distFromEye):
"""getSightPoint(SbDPViewVolume self, double const distFromEye) -> SbVec3d"""
return _coin.SbDPViewVolume_getSightPoint(self, distFromEye)
def getPlanePoint(self, distFromEye, normPoint):
"""getPlanePoint(SbDPViewVolume self, double const distFromEye, SbVec2d normPoint) -> SbVec3d"""
return _coin.SbDPViewVolume_getPlanePoint(self, distFromEye, normPoint)
def getAlignRotation(self, rightAngleOnly=0):
"""
getAlignRotation(SbDPViewVolume self, SbBool rightAngleOnly=0) -> SbDPRotation
getAlignRotation(SbDPViewVolume self) -> SbDPRotation
"""
return _coin.SbDPViewVolume_getAlignRotation(self, rightAngleOnly)
def getWorldToScreenScale(self, worldCenter, normRadius):
"""getWorldToScreenScale(SbDPViewVolume self, SbVec3d worldCenter, double normRadius) -> double"""
return _coin.SbDPViewVolume_getWorldToScreenScale(self, worldCenter, normRadius)
def projectBox(self, box):
"""projectBox(SbDPViewVolume self, SbBox3f box) -> SbVec2d"""
return _coin.SbDPViewVolume_projectBox(self, box)
def narrow(self, *args):
"""
narrow(SbDPViewVolume self, double left, double bottom, double right, double top) -> SbDPViewVolume
narrow(SbDPViewVolume self, SbBox3f box) -> SbDPViewVolume
"""
return _coin.SbDPViewVolume_narrow(self, *args)
def ortho(self, left, right, bottom, top, nearval, farval):
"""ortho(SbDPViewVolume self, double left, double right, double bottom, double top, double nearval, double farval)"""
return _coin.SbDPViewVolume_ortho(self, left, right, bottom, top, nearval, farval)
def perspective(self, fovy, aspect, nearval, farval):
"""perspective(SbDPViewVolume self, double fovy, double aspect, double nearval, double farval)"""
return _coin.SbDPViewVolume_perspective(self, fovy, aspect, nearval, farval)
def frustum(self, left, right, bottom, top, nearval, farval):
"""frustum(SbDPViewVolume self, double left, double right, double bottom, double top, double nearval, double farval)"""
return _coin.SbDPViewVolume_frustum(self, left, right, bottom, top, nearval, farval)
def rotateCamera(self, q):
"""rotateCamera(SbDPViewVolume self, SbDPRotation q)"""
return _coin.SbDPViewVolume_rotateCamera(self, q)
def translateCamera(self, v):
"""translateCamera(SbDPViewVolume self, SbVec3d v)"""
return _coin.SbDPViewVolume_translateCamera(self, v)
def zVector(self):
"""zVector(SbDPViewVolume self) -> SbVec3d"""
return _coin.SbDPViewVolume_zVector(self)
def zNarrow(self, nearval, farval):
"""zNarrow(SbDPViewVolume self, double nearval, double farval) -> SbDPViewVolume"""
return _coin.SbDPViewVolume_zNarrow(self, nearval, farval)
def scale(self, factor):
"""scale(SbDPViewVolume self, double factor)"""
return _coin.SbDPViewVolume_scale(self, factor)
def scaleWidth(self, ratio):
"""scaleWidth(SbDPViewVolume self, double ratio)"""
return _coin.SbDPViewVolume_scaleWidth(self, ratio)
def scaleHeight(self, ratio):
"""scaleHeight(SbDPViewVolume self, double ratio)"""
return _coin.SbDPViewVolume_scaleHeight(self, ratio)
def getProjectionType(self):
"""getProjectionType(SbDPViewVolume self) -> SbDPViewVolume::ProjectionType"""
return _coin.SbDPViewVolume_getProjectionType(self)
def getProjectionPoint(self):
"""getProjectionPoint(SbDPViewVolume self) -> SbVec3d"""
return _coin.SbDPViewVolume_getProjectionPoint(self)
def getProjectionDirection(self):
"""getProjectionDirection(SbDPViewVolume self) -> SbVec3d"""
return _coin.SbDPViewVolume_getProjectionDirection(self)
def getNearDist(self):
"""getNearDist(SbDPViewVolume self) -> double"""
return _coin.SbDPViewVolume_getNearDist(self)
def getWidth(self):
"""getWidth(SbDPViewVolume self) -> double"""
return _coin.SbDPViewVolume_getWidth(self)
def getHeight(self):
"""getHeight(SbDPViewVolume self) -> double"""
return _coin.SbDPViewVolume_getHeight(self)
def getDepth(self):
"""getDepth(SbDPViewVolume self) -> double"""
return _coin.SbDPViewVolume_getDepth(self)
def output(self, fp):
"""output(SbDPViewVolume self, FILE * fp)"""
return _coin.SbDPViewVolume_output(self, fp)
def getViewVolumePlanes(self, planes):
"""getViewVolumePlanes(SbDPViewVolume self, SbPlane planes)"""
return _coin.SbDPViewVolume_getViewVolumePlanes(self, planes)
def transform(self, matrix):
"""transform(SbDPViewVolume self, SbDPMatrix matrix)"""
return _coin.SbDPViewVolume_transform(self, matrix)
def getViewUp(self):
"""getViewUp(SbDPViewVolume self) -> SbVec3d"""
return _coin.SbDPViewVolume_getViewUp(self)
def copyValues(self, vv):
"""copyValues(SbDPViewVolume self, SbViewVolume vv)"""
return _coin.SbDPViewVolume_copyValues(self, vv)
SbDPViewVolume_swigregister = _coin.SbDPViewVolume_swigregister
SbDPViewVolume_swigregister(SbDPViewVolume)
class SbViewVolume(object):
"""Proxy of C++ SbViewVolume class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
ORTHOGRAPHIC = _coin.SbViewVolume_ORTHOGRAPHIC
PERSPECTIVE = _coin.SbViewVolume_PERSPECTIVE
def __init__(self):
"""__init__(SbViewVolume self) -> SbViewVolume"""
this = _coin.new_SbViewVolume()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SbViewVolume
__del__ = lambda self: None
def getMatrices(self, affine, proj):
"""getMatrices(SbViewVolume self, SbMatrix affine, SbMatrix proj)"""
return _coin.SbViewVolume_getMatrices(self, affine, proj)
def getMatrix(self):
"""getMatrix(SbViewVolume self) -> SbMatrix"""
return _coin.SbViewVolume_getMatrix(self)
def getCameraSpaceMatrix(self):
"""getCameraSpaceMatrix(SbViewVolume self) -> SbMatrix"""
return _coin.SbViewVolume_getCameraSpaceMatrix(self)
def getPlane(self, distFromEye):
"""getPlane(SbViewVolume self, float const distFromEye) -> SbPlane"""
return _coin.SbViewVolume_getPlane(self, distFromEye)
def getSightPoint(self, distFromEye):
"""getSightPoint(SbViewVolume self, float const distFromEye) -> SbVec3f"""
return _coin.SbViewVolume_getSightPoint(self, distFromEye)
def getPlanePoint(self, distFromEye, normPoint):
"""getPlanePoint(SbViewVolume self, float const distFromEye, SbVec2f normPoint) -> SbVec3f"""
return _coin.SbViewVolume_getPlanePoint(self, distFromEye, normPoint)
def getAlignRotation(self, rightAngleOnly=0):
"""
getAlignRotation(SbViewVolume self, SbBool rightAngleOnly=0) -> SbRotation
getAlignRotation(SbViewVolume self) -> SbRotation
"""
return _coin.SbViewVolume_getAlignRotation(self, rightAngleOnly)
def getWorldToScreenScale(self, worldCenter, normRadius):
"""getWorldToScreenScale(SbViewVolume self, SbVec3f worldCenter, float normRadius) -> float"""
return _coin.SbViewVolume_getWorldToScreenScale(self, worldCenter, normRadius)
def projectBox(self, box):
"""projectBox(SbViewVolume self, SbBox3f box) -> SbVec2f"""
return _coin.SbViewVolume_projectBox(self, box)
def narrow(self, *args):
"""
narrow(SbViewVolume self, float left, float bottom, float right, float top) -> SbViewVolume
narrow(SbViewVolume self, SbBox3f box) -> SbViewVolume
"""
return _coin.SbViewVolume_narrow(self, *args)
def ortho(self, left, right, bottom, top, nearval, farval):
"""ortho(SbViewVolume self, float left, float right, float bottom, float top, float nearval, float farval)"""
return _coin.SbViewVolume_ortho(self, left, right, bottom, top, nearval, farval)
def perspective(self, fovy, aspect, nearval, farval):
"""perspective(SbViewVolume self, float fovy, float aspect, float nearval, float farval)"""
return _coin.SbViewVolume_perspective(self, fovy, aspect, nearval, farval)
def frustum(self, left, right, bottom, top, nearval, farval):
"""frustum(SbViewVolume self, float left, float right, float bottom, float top, float nearval, float farval)"""
return _coin.SbViewVolume_frustum(self, left, right, bottom, top, nearval, farval)
def rotateCamera(self, q):
"""rotateCamera(SbViewVolume self, SbRotation q)"""
return _coin.SbViewVolume_rotateCamera(self, q)
def translateCamera(self, v):
"""translateCamera(SbViewVolume self, SbVec3f v)"""
return _coin.SbViewVolume_translateCamera(self, v)
def zVector(self):
"""zVector(SbViewVolume self) -> SbVec3f"""
return _coin.SbViewVolume_zVector(self)
def zNarrow(self, nearval, farval):
"""zNarrow(SbViewVolume self, float nearval, float farval) -> SbViewVolume"""
return _coin.SbViewVolume_zNarrow(self, nearval, farval)
def scale(self, factor):
"""scale(SbViewVolume self, float factor)"""
return _coin.SbViewVolume_scale(self, factor)
def scaleWidth(self, ratio):
"""scaleWidth(SbViewVolume self, float ratio)"""
return _coin.SbViewVolume_scaleWidth(self, ratio)
def scaleHeight(self, ratio):
"""scaleHeight(SbViewVolume self, float ratio)"""
return _coin.SbViewVolume_scaleHeight(self, ratio)
def getProjectionType(self):
"""getProjectionType(SbViewVolume self) -> SbViewVolume::ProjectionType"""
return _coin.SbViewVolume_getProjectionType(self)
def getProjectionPoint(self):
"""getProjectionPoint(SbViewVolume self) -> SbVec3f"""
return _coin.SbViewVolume_getProjectionPoint(self)
def getProjectionDirection(self):
"""getProjectionDirection(SbViewVolume self) -> SbVec3f"""
return _coin.SbViewVolume_getProjectionDirection(self)
def getNearDist(self):
"""getNearDist(SbViewVolume self) -> float"""
return _coin.SbViewVolume_getNearDist(self)
def getWidth(self):
"""getWidth(SbViewVolume self) -> float"""
return _coin.SbViewVolume_getWidth(self)
def getHeight(self):
"""getHeight(SbViewVolume self) -> float"""
return _coin.SbViewVolume_getHeight(self)
def getDepth(self):
"""getDepth(SbViewVolume self) -> float"""
return _coin.SbViewVolume_getDepth(self)
def output(self, fp):
"""output(SbViewVolume self, FILE * fp)"""
return _coin.SbViewVolume_output(self, fp)
def getViewVolumePlanes(self, planes):
"""getViewVolumePlanes(SbViewVolume self, SbPlane planes)"""
return _coin.SbViewVolume_getViewVolumePlanes(self, planes)
def transform(self):
"""transform(SbViewVolume self)"""
return _coin.SbViewVolume_transform(self)
def getViewUp(self):
"""getViewUp(SbViewVolume self) -> SbVec3f"""
return _coin.SbViewVolume_getViewUp(self)
def intersect(self, *args):
"""
intersect(SbViewVolume self, SbVec3f p) -> SbBool
intersect(SbViewVolume self, SbVec3f p0, SbVec3f p1, SbVec3f closestpoint) -> SbBool
intersect(SbViewVolume self, SbBox3f box) -> SbBool
"""
return _coin.SbViewVolume_intersect(self, *args)
def intersectionBox(self, box):
"""intersectionBox(SbViewVolume self, SbBox3f box) -> SbBox3f"""
return _coin.SbViewVolume_intersectionBox(self, box)
def outsideTest(self, p, bmin, bmax):
"""outsideTest(SbViewVolume self, SbPlane p, SbVec3f bmin, SbVec3f bmax) -> SbBool"""
return _coin.SbViewVolume_outsideTest(self, p, bmin, bmax)
def getDPViewVolume(self):
"""getDPViewVolume(SbViewVolume self) -> SbDPViewVolume"""
return _coin.SbViewVolume_getDPViewVolume(self)
type = _swig_property(_coin.SbViewVolume_type_get, _coin.SbViewVolume_type_set)
projPoint = _swig_property(_coin.SbViewVolume_projPoint_get, _coin.SbViewVolume_projPoint_set)
projDir = _swig_property(_coin.SbViewVolume_projDir_get, _coin.SbViewVolume_projDir_set)
nearDist = _swig_property(_coin.SbViewVolume_nearDist_get, _coin.SbViewVolume_nearDist_set)
nearToFar = _swig_property(_coin.SbViewVolume_nearToFar_get, _coin.SbViewVolume_nearToFar_set)
llf = _swig_property(_coin.SbViewVolume_llf_get, _coin.SbViewVolume_llf_set)
lrf = _swig_property(_coin.SbViewVolume_lrf_get, _coin.SbViewVolume_lrf_set)
ulf = _swig_property(_coin.SbViewVolume_ulf_get, _coin.SbViewVolume_ulf_set)
def projectPointToLine(self, pt):
"""projectPointToLine(SbVec3f) -> (SbVec3f, SbVec3f)"""
return _coin.SbViewVolume_projectPointToLine(self, pt)
def projectToScreen(self, src):
"""projectToScreen(SbVec3f) -> SbVec3f"""
return _coin.SbViewVolume_projectToScreen(self, src)
SbViewVolume_swigregister = _coin.SbViewVolume_swigregister
SbViewVolume_swigregister(SbViewVolume)
class SoSFVec3f(SoSField):
"""Proxy of C++ SoSFVec3f class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFVec3f self) -> SoSFVec3f"""
this = _coin.new_SoSFVec3f()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFVec3f
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFVec3f_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFVec3f_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFVec3f self) -> SoType"""
return _coin.SoSFVec3f_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFVec3f self, SoField field)"""
return _coin.SoSFVec3f_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFVec3f self, SoField field) -> SbBool"""
return _coin.SoSFVec3f_isSame(self, field)
def getValue(self):
"""getValue(SoSFVec3f self) -> SbVec3f"""
return _coin.SoSFVec3f_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFVec3f self, SoSFVec3f field) -> int"""
return _coin.SoSFVec3f___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFVec3f self, SoSFVec3f field) -> int"""
return _coin.SoSFVec3f___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFVec3f_initClass()
initClass = staticmethod(initClass)
def setValue(self, *args):
"""
setValue(SoSFVec3f self, SbVec3f newvalue)
setValue(SoSFVec3f self, float x, float y, float z)
setValue(SoSFVec3f self, float const [3] xyz)
setValue(SoSFVec3f self, SoSFVec3f other)
"""
return _coin.SoSFVec3f_setValue(self, *args)
SoSFVec3f_swigregister = _coin.SoSFVec3f_swigregister
SoSFVec3f_swigregister(SoSFVec3f)
def SoSFVec3f_createInstance():
"""SoSFVec3f_createInstance() -> void *"""
return _coin.SoSFVec3f_createInstance()
def SoSFVec3f_getClassTypeId():
"""SoSFVec3f_getClassTypeId() -> SoType"""
return _coin.SoSFVec3f_getClassTypeId()
def SoSFVec3f_initClass():
"""SoSFVec3f_initClass()"""
return _coin.SoSFVec3f_initClass()
class SoScale(SoTransformation):
"""Proxy of C++ SoScale class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoScale_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoScale self) -> SoType"""
return _coin.SoScale_getTypeId(self)
def initClass():
"""initClass()"""
return _coin.SoScale_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoScale self) -> SoScale"""
this = _coin.new_SoScale()
try:
self.this.append(this)
except Exception:
self.this = this
scaleFactor = _swig_property(_coin.SoScale_scaleFactor_get, _coin.SoScale_scaleFactor_set)
def doAction(self, action):
"""doAction(SoScale self, SoAction action)"""
return _coin.SoScale_doAction(self, action)
def callback(self, action):
"""callback(SoScale self, SoCallbackAction action)"""
return _coin.SoScale_callback(self, action)
def GLRender(self, action):
"""GLRender(SoScale self, SoGLRenderAction action)"""
return _coin.SoScale_GLRender(self, action)
def getBoundingBox(self, action):
"""getBoundingBox(SoScale self, SoGetBoundingBoxAction action)"""
return _coin.SoScale_getBoundingBox(self, action)
def getMatrix(self, action):
"""getMatrix(SoScale self, SoGetMatrixAction action)"""
return _coin.SoScale_getMatrix(self, action)
def pick(self, action):
"""pick(SoScale self, SoPickAction action)"""
return _coin.SoScale_pick(self, action)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoScale self, SoGetPrimitiveCountAction action)"""
return _coin.SoScale_getPrimitiveCount(self, action)
SoScale_swigregister = _coin.SoScale_swigregister
SoScale_swigregister(SoScale)
def SoScale_getClassTypeId():
"""SoScale_getClassTypeId() -> SoType"""
return _coin.SoScale_getClassTypeId()
def SoScale_initClass():
"""SoScale_initClass()"""
return _coin.SoScale_initClass()
class SoDragger(SoInteractionKit):
"""Proxy of C++ SoDragger class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoDragger self) -> SoType"""
return _coin.SoDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoDragger self) -> SoNodekitCatalog"""
return _coin.SoDragger_getNodekitCatalog(self)
isActive = _swig_property(_coin.SoDragger_isActive_get, _coin.SoDragger_isActive_set)
FRONT = _coin.SoDragger_FRONT
BACK = _coin.SoDragger_BACK
USE_PICK = _coin.SoDragger_USE_PICK
def callback(self, action):
"""callback(SoDragger self, SoCallbackAction action)"""
return _coin.SoDragger_callback(self, action)
def GLRender(self, action):
"""GLRender(SoDragger self, SoGLRenderAction action)"""
return _coin.SoDragger_GLRender(self, action)
def getMatrix(self, action):
"""getMatrix(SoDragger self, SoGetMatrixAction action)"""
return _coin.SoDragger_getMatrix(self, action)
def rayPick(self, action):
"""rayPick(SoDragger self, SoRayPickAction action)"""
return _coin.SoDragger_rayPick(self, action)
def search(self, action):
"""search(SoDragger self, SoSearchAction action)"""
return _coin.SoDragger_search(self, action)
def write(self, action):
"""write(SoDragger self, SoWriteAction action)"""
return _coin.SoDragger_write(self, action)
def getPrimitiveCount(self, action):
"""getPrimitiveCount(SoDragger self, SoGetPrimitiveCountAction action)"""
return _coin.SoDragger_getPrimitiveCount(self, action)
def setProjectorEpsilon(self, epsilon):
"""setProjectorEpsilon(SoDragger self, float const epsilon)"""
return _coin.SoDragger_setProjectorEpsilon(self, epsilon)
def getProjectorEpsilon(self):
"""getProjectorEpsilon(SoDragger self) -> float"""
return _coin.SoDragger_getProjectorEpsilon(self)
def setMinGesture(self, pixels):
"""setMinGesture(SoDragger self, int pixels)"""
return _coin.SoDragger_setMinGesture(self, pixels)
def getMinGesture(self):
"""getMinGesture(SoDragger self) -> int"""
return _coin.SoDragger_getMinGesture(self)
def enableValueChangedCallbacks(self, newval):
"""enableValueChangedCallbacks(SoDragger self, SbBool newval) -> SbBool"""
return _coin.SoDragger_enableValueChangedCallbacks(self, newval)
def getMotionMatrix(self):
"""getMotionMatrix(SoDragger self) -> SbMatrix"""
return _coin.SoDragger_getMotionMatrix(self)
def registerChildDragger(self, child):
"""registerChildDragger(SoDragger self, SoDragger child)"""
return _coin.SoDragger_registerChildDragger(self, child)
def unregisterChildDragger(self, child):
"""unregisterChildDragger(SoDragger self, SoDragger child)"""
return _coin.SoDragger_unregisterChildDragger(self, child)
def registerChildDraggerMovingIndependently(self, child):
"""registerChildDraggerMovingIndependently(SoDragger self, SoDragger child)"""
return _coin.SoDragger_registerChildDraggerMovingIndependently(self, child)
def unregisterChildDraggerMovingIndependently(self, child):
"""unregisterChildDraggerMovingIndependently(SoDragger self, SoDragger child)"""
return _coin.SoDragger_unregisterChildDraggerMovingIndependently(self, child)
def getLocalToWorldMatrix(self):
"""getLocalToWorldMatrix(SoDragger self) -> SbMatrix"""
return _coin.SoDragger_getLocalToWorldMatrix(self)
def getWorldToLocalMatrix(self):
"""getWorldToLocalMatrix(SoDragger self) -> SbMatrix"""
return _coin.SoDragger_getWorldToLocalMatrix(self)
def getLocalStartingPoint(self):
"""getLocalStartingPoint(SoDragger self) -> SbVec3f"""
return _coin.SoDragger_getLocalStartingPoint(self)
def getWorldStartingPoint(self):
"""getWorldStartingPoint(SoDragger self) -> SbVec3f"""
return _coin.SoDragger_getWorldStartingPoint(self)
def getPartToLocalMatrix(self, partname, parttolocalmatrix, localtopartmatrix):
"""getPartToLocalMatrix(SoDragger self, SbName partname, SbMatrix parttolocalmatrix, SbMatrix localtopartmatrix)"""
return _coin.SoDragger_getPartToLocalMatrix(self, partname, parttolocalmatrix, localtopartmatrix)
def transformMatrixLocalToWorld(self, frommatrix, tomatrix):
"""transformMatrixLocalToWorld(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix)"""
return _coin.SoDragger_transformMatrixLocalToWorld(self, frommatrix, tomatrix)
def transformMatrixWorldToLocal(self, frommatrix, tomatrix):
"""transformMatrixWorldToLocal(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix)"""
return _coin.SoDragger_transformMatrixWorldToLocal(self, frommatrix, tomatrix)
def transformMatrixToLocalSpace(self, frommatrix, tomatrix, fromspacepartname):
"""transformMatrixToLocalSpace(SoDragger self, SbMatrix frommatrix, SbMatrix tomatrix, SbName fromspacepartname)"""
return _coin.SoDragger_transformMatrixToLocalSpace(self, frommatrix, tomatrix, fromspacepartname)
def setMotionMatrix(self, newmatrix):
"""setMotionMatrix(SoDragger self, SbMatrix newmatrix)"""
return _coin.SoDragger_setMotionMatrix(self, newmatrix)
def valueChanged(self):
"""valueChanged(SoDragger self)"""
return _coin.SoDragger_valueChanged(self)
def getStartMotionMatrix(self):
"""getStartMotionMatrix(SoDragger self) -> SbMatrix"""
return _coin.SoDragger_getStartMotionMatrix(self)
def saveStartParameters(self):
"""saveStartParameters(SoDragger self)"""
return _coin.SoDragger_saveStartParameters(self)
def getPickPath(self):
"""getPickPath(SoDragger self) -> SoPath"""
return _coin.SoDragger_getPickPath(self)
def getEvent(self):
"""getEvent(SoDragger self) -> SoEvent"""
return _coin.SoDragger_getEvent(self)
def createPathToThis(self):
"""createPathToThis(SoDragger self) -> SoPath"""
return _coin.SoDragger_createPathToThis(self)
def getSurrogatePartPickedOwner(self):
"""getSurrogatePartPickedOwner(SoDragger self) -> SoPath"""
return _coin.SoDragger_getSurrogatePartPickedOwner(self)
def getSurrogatePartPickedName(self):
"""getSurrogatePartPickedName(SoDragger self) -> SbName"""
return _coin.SoDragger_getSurrogatePartPickedName(self)
def getSurrogatePartPickedPath(self):
"""getSurrogatePartPickedPath(SoDragger self) -> SoPath"""
return _coin.SoDragger_getSurrogatePartPickedPath(self)
def setStartingPoint(self, *args):
"""
setStartingPoint(SoDragger self, SoPickedPoint newpoint)
setStartingPoint(SoDragger self, SbVec3f newpoint)
"""
return _coin.SoDragger_setStartingPoint(self, *args)
def getViewVolume(self):
"""getViewVolume(SoDragger self) -> SbViewVolume"""
return _coin.SoDragger_getViewVolume(self)
def setViewVolume(self, vol):
"""setViewVolume(SoDragger self, SbViewVolume vol)"""
return _coin.SoDragger_setViewVolume(self, vol)
def getViewportRegion(self):
"""getViewportRegion(SoDragger self) -> SbViewportRegion"""
return _coin.SoDragger_getViewportRegion(self)
def setViewportRegion(self, reg):
"""setViewportRegion(SoDragger self, SbViewportRegion reg)"""
return _coin.SoDragger_setViewportRegion(self, reg)
def getHandleEventAction(self):
"""getHandleEventAction(SoDragger self) -> SoHandleEventAction"""
return _coin.SoDragger_getHandleEventAction(self)
def setHandleEventAction(self, newAction):
"""setHandleEventAction(SoDragger self, SoHandleEventAction newAction)"""
return _coin.SoDragger_setHandleEventAction(self, newAction)
def setTempPathToThis(self, somethingclose):
"""setTempPathToThis(SoDragger self, SoPath somethingclose)"""
return _coin.SoDragger_setTempPathToThis(self, somethingclose)
def grabEventsSetup(self):
"""grabEventsSetup(SoDragger self)"""
return _coin.SoDragger_grabEventsSetup(self)
def grabEventsCleanup(self):
"""grabEventsCleanup(SoDragger self)"""
return _coin.SoDragger_grabEventsCleanup(self)
def workFieldsIntoTransform(self, mtx):
"""workFieldsIntoTransform(SoDragger self, SbMatrix mtx)"""
return _coin.SoDragger_workFieldsIntoTransform(self, mtx)
def setFrontOnProjector(self, newval):
"""setFrontOnProjector(SoDragger self, SoDragger::ProjectorFrontSetting newval)"""
return _coin.SoDragger_setFrontOnProjector(self, newval)
def getFrontOnProjector(self):
"""getFrontOnProjector(SoDragger self) -> SoDragger::ProjectorFrontSetting"""
return _coin.SoDragger_getFrontOnProjector(self)
def setMinScale(newminscale):
"""setMinScale(float newminscale)"""
return _coin.SoDragger_setMinScale(newminscale)
setMinScale = staticmethod(setMinScale)
def getMinScale():
"""getMinScale() -> float"""
return _coin.SoDragger_getMinScale()
getMinScale = staticmethod(getMinScale)
def workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr):
"""workValuesIntoTransform(SbMatrix mtx, SbVec3f translationptr, SbRotation rotationptr, SbVec3f scalefactorptr, SbRotation scaleorientationptr, SbVec3f centerptr)"""
return _coin.SoDragger_workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr)
workValuesIntoTransform = staticmethod(workValuesIntoTransform)
def getTransformFast(*args):
"""
getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, SbVec3f scalefactor, SbRotation scaleorientation, SbVec3f center)
getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, SbVec3f scalefactor, SbRotation scaleorientation)
"""
return _coin.SoDragger_getTransformFast(*args)
getTransformFast = staticmethod(getTransformFast)
def appendTranslation(mtx, translation, conversion=None):
"""
appendTranslation(SbMatrix mtx, SbVec3f translation, SbMatrix conversion=None) -> SbMatrix
appendTranslation(SbMatrix mtx, SbVec3f translation) -> SbMatrix
"""
return _coin.SoDragger_appendTranslation(mtx, translation, conversion)
appendTranslation = staticmethod(appendTranslation)
def appendScale(mtx, scale, scalecenter, conversion=None):
"""
appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter, SbMatrix conversion=None) -> SbMatrix
appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter) -> SbMatrix
"""
return _coin.SoDragger_appendScale(mtx, scale, scalecenter, conversion)
appendScale = staticmethod(appendScale)
def appendRotation(mtx, rot, rotcenter, conversion=None):
"""
appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter, SbMatrix conversion=None) -> SbMatrix
appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter) -> SbMatrix
"""
return _coin.SoDragger_appendRotation(mtx, rot, rotcenter, conversion)
appendRotation = staticmethod(appendRotation)
def initClass():
"""initClass()"""
return _coin.SoDragger_initClass()
initClass = staticmethod(initClass)
def initClasses():
"""initClasses()"""
return _coin.SoDragger_initClasses()
initClasses = staticmethod(initClasses)
def addStartCallback(self, *args):
"""
addStartCallback(SoDragger self, SoDraggerCB * func, void * data=None)
addStartCallback(SoDragger self, SoDraggerCB * func)
addStartCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
addStartCallback(SoDragger self, PyObject * pyfunc)
"""
return _coin.SoDragger_addStartCallback(self, *args)
def removeStartCallback(self, *args):
"""
removeStartCallback(SoDragger self, SoDraggerCB * func, void * data=None)
removeStartCallback(SoDragger self, SoDraggerCB * func)
removeStartCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
removeStartCallback(SoDragger self, PyObject * pyfunc)
"""
return _coin.SoDragger_removeStartCallback(self, *args)
def addMotionCallback(self, *args):
"""
addMotionCallback(SoDragger self, SoDraggerCB * func, void * data=None)
addMotionCallback(SoDragger self, SoDraggerCB * func)
addMotionCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
addMotionCallback(SoDragger self, PyObject * pyfunc)
"""
return _coin.SoDragger_addMotionCallback(self, *args)
def removeMotionCallback(self, *args):
"""
removeMotionCallback(SoDragger self, SoDraggerCB * func, void * data=None)
removeMotionCallback(SoDragger self, SoDraggerCB * func)
removeMotionCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
removeMotionCallback(SoDragger self, PyObject * pyfunc)
"""
return _coin.SoDragger_removeMotionCallback(self, *args)
def addFinishCallback(self, *args):
"""
addFinishCallback(SoDragger self, SoDraggerCB * func, void * data=None)
addFinishCallback(SoDragger self, SoDraggerCB * func)
addFinishCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
addFinishCallback(SoDragger self, PyObject * pyfunc)
"""
return _coin.SoDragger_addFinishCallback(self, *args)
def removeFinishCallback(self, *args):
"""
removeFinishCallback(SoDragger self, SoDraggerCB * func, void * data=None)
removeFinishCallback(SoDragger self, SoDraggerCB * func)
removeFinishCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
removeFinishCallback(SoDragger self, PyObject * pyfunc)
"""
return _coin.SoDragger_removeFinishCallback(self, *args)
def addValueChangedCallback(self, *args):
"""
addValueChangedCallback(SoDragger self, SoDraggerCB * func, void * data=None)
addValueChangedCallback(SoDragger self, SoDraggerCB * func)
addValueChangedCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
addValueChangedCallback(SoDragger self, PyObject * pyfunc)
"""
return _coin.SoDragger_addValueChangedCallback(self, *args)
def removeValueChangedCallback(self, *args):
"""
removeValueChangedCallback(SoDragger self, SoDraggerCB * func, void * data=None)
removeValueChangedCallback(SoDragger self, SoDraggerCB * func)
removeValueChangedCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
removeValueChangedCallback(SoDragger self, PyObject * pyfunc)
"""
return _coin.SoDragger_removeValueChangedCallback(self, *args)
def addOtherEventCallback(self, *args):
"""
addOtherEventCallback(SoDragger self, SoDraggerCB * func, void * data=None)
addOtherEventCallback(SoDragger self, SoDraggerCB * func)
addOtherEventCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
addOtherEventCallback(SoDragger self, PyObject * pyfunc)
"""
return _coin.SoDragger_addOtherEventCallback(self, *args)
def removeOtherEventCallback(self, *args):
"""
removeOtherEventCallback(SoDragger self, SoDraggerCB * func, void * data=None)
removeOtherEventCallback(SoDragger self, SoDraggerCB * func)
removeOtherEventCallback(SoDragger self, PyObject * pyfunc, PyObject * data=None)
removeOtherEventCallback(SoDragger self, PyObject * pyfunc)
"""
return _coin.SoDragger_removeOtherEventCallback(self, *args)
SoDragger_swigregister = _coin.SoDragger_swigregister
SoDragger_swigregister(SoDragger)
def SoDragger_getClassTypeId():
"""SoDragger_getClassTypeId() -> SoType"""
return _coin.SoDragger_getClassTypeId()
def SoDragger_getClassNodekitCatalog():
"""SoDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoDragger_getClassNodekitCatalog()
def SoDragger_setMinScale(newminscale):
"""SoDragger_setMinScale(float newminscale)"""
return _coin.SoDragger_setMinScale(newminscale)
def SoDragger_getMinScale():
"""SoDragger_getMinScale() -> float"""
return _coin.SoDragger_getMinScale()
def SoDragger_workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr):
"""SoDragger_workValuesIntoTransform(SbMatrix mtx, SbVec3f translationptr, SbRotation rotationptr, SbVec3f scalefactorptr, SbRotation scaleorientationptr, SbVec3f centerptr)"""
return _coin.SoDragger_workValuesIntoTransform(mtx, translationptr, rotationptr, scalefactorptr, scaleorientationptr, centerptr)
def SoDragger_getTransformFast(*args):
"""
getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, SbVec3f scalefactor, SbRotation scaleorientation, SbVec3f center)
SoDragger_getTransformFast(SbMatrix mtx, SbVec3f translation, SbRotation rotation, SbVec3f scalefactor, SbRotation scaleorientation)
"""
return _coin.SoDragger_getTransformFast(*args)
def SoDragger_appendTranslation(mtx, translation, conversion=None):
"""
appendTranslation(SbMatrix mtx, SbVec3f translation, SbMatrix conversion=None) -> SbMatrix
SoDragger_appendTranslation(SbMatrix mtx, SbVec3f translation) -> SbMatrix
"""
return _coin.SoDragger_appendTranslation(mtx, translation, conversion)
def SoDragger_appendScale(mtx, scale, scalecenter, conversion=None):
"""
appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter, SbMatrix conversion=None) -> SbMatrix
SoDragger_appendScale(SbMatrix mtx, SbVec3f scale, SbVec3f scalecenter) -> SbMatrix
"""
return _coin.SoDragger_appendScale(mtx, scale, scalecenter, conversion)
def SoDragger_appendRotation(mtx, rot, rotcenter, conversion=None):
"""
appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter, SbMatrix conversion=None) -> SbMatrix
SoDragger_appendRotation(SbMatrix mtx, SbRotation rot, SbVec3f rotcenter) -> SbMatrix
"""
return _coin.SoDragger_appendRotation(mtx, rot, rotcenter, conversion)
def SoDragger_initClass():
"""SoDragger_initClass()"""
return _coin.SoDragger_initClass()
def SoDragger_initClasses():
"""SoDragger_initClasses()"""
return _coin.SoDragger_initClasses()
class SoSFRotation(SoSField):
"""Proxy of C++ SoSFRotation class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFRotation self) -> SoSFRotation"""
this = _coin.new_SoSFRotation()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFRotation
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFRotation_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFRotation_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFRotation self) -> SoType"""
return _coin.SoSFRotation_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFRotation self, SoField field)"""
return _coin.SoSFRotation_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFRotation self, SoField field) -> SbBool"""
return _coin.SoSFRotation_isSame(self, field)
def __eq__(self, field):
"""__eq__(SoSFRotation self, SoSFRotation field) -> int"""
return _coin.SoSFRotation___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFRotation self, SoSFRotation field) -> int"""
return _coin.SoSFRotation___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFRotation_initClass()
initClass = staticmethod(initClass)
def getValue(self, *args):
"""
getValue(SoSFRotation self) -> SbRotation
getValue(SoSFRotation self, float & angle)
"""
return _coin.SoSFRotation_getValue(self, *args)
def setValue(self, *args):
"""
setValue(SoSFRotation self, SbRotation newvalue)
setValue(SoSFRotation self, float const q0, float const q1, float const q2, float const q3)
setValue(SoSFRotation self, float const [4] q)
setValue(SoSFRotation self, SbVec3f axis, float const angle)
setValue(SoSFRotation self, SoSFRotation other)
"""
return _coin.SoSFRotation_setValue(self, *args)
SoSFRotation_swigregister = _coin.SoSFRotation_swigregister
SoSFRotation_swigregister(SoSFRotation)
def SoSFRotation_createInstance():
"""SoSFRotation_createInstance() -> void *"""
return _coin.SoSFRotation_createInstance()
def SoSFRotation_getClassTypeId():
"""SoSFRotation_getClassTypeId() -> SoType"""
return _coin.SoSFRotation_getClassTypeId()
def SoSFRotation_initClass():
"""SoSFRotation_initClass()"""
return _coin.SoSFRotation_initClass()
class SoCenterballDragger(SoDragger):
"""Proxy of C++ SoCenterballDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoCenterballDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoCenterballDragger self) -> SoType"""
return _coin.SoCenterballDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoCenterballDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoCenterballDragger self) -> SoNodekitCatalog"""
return _coin.SoCenterballDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoCenterballDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoCenterballDragger self) -> SoCenterballDragger"""
this = _coin.new_SoCenterballDragger()
try:
self.this.append(this)
except Exception:
self.this = this
def saveStartParameters(self):
"""saveStartParameters(SoCenterballDragger self)"""
return _coin.SoCenterballDragger_saveStartParameters(self)
rotation = _swig_property(_coin.SoCenterballDragger_rotation_get, _coin.SoCenterballDragger_rotation_set)
center = _swig_property(_coin.SoCenterballDragger_center_get, _coin.SoCenterballDragger_center_set)
SoCenterballDragger_swigregister = _coin.SoCenterballDragger_swigregister
SoCenterballDragger_swigregister(SoCenterballDragger)
def SoCenterballDragger_getClassTypeId():
"""SoCenterballDragger_getClassTypeId() -> SoType"""
return _coin.SoCenterballDragger_getClassTypeId()
def SoCenterballDragger_getClassNodekitCatalog():
"""SoCenterballDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoCenterballDragger_getClassNodekitCatalog()
def SoCenterballDragger_initClass():
"""SoCenterballDragger_initClass()"""
return _coin.SoCenterballDragger_initClass()
class SoDirectionalLightDragger(SoDragger):
"""Proxy of C++ SoDirectionalLightDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoDirectionalLightDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoDirectionalLightDragger self) -> SoType"""
return _coin.SoDirectionalLightDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoDirectionalLightDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoDirectionalLightDragger self) -> SoNodekitCatalog"""
return _coin.SoDirectionalLightDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoDirectionalLightDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoDirectionalLightDragger self) -> SoDirectionalLightDragger"""
this = _coin.new_SoDirectionalLightDragger()
try:
self.this.append(this)
except Exception:
self.this = this
rotation = _swig_property(_coin.SoDirectionalLightDragger_rotation_get, _coin.SoDirectionalLightDragger_rotation_set)
translation = _swig_property(_coin.SoDirectionalLightDragger_translation_get, _coin.SoDirectionalLightDragger_translation_set)
SoDirectionalLightDragger_swigregister = _coin.SoDirectionalLightDragger_swigregister
SoDirectionalLightDragger_swigregister(SoDirectionalLightDragger)
def SoDirectionalLightDragger_getClassTypeId():
"""SoDirectionalLightDragger_getClassTypeId() -> SoType"""
return _coin.SoDirectionalLightDragger_getClassTypeId()
def SoDirectionalLightDragger_getClassNodekitCatalog():
"""SoDirectionalLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoDirectionalLightDragger_getClassNodekitCatalog()
def SoDirectionalLightDragger_initClass():
"""SoDirectionalLightDragger_initClass()"""
return _coin.SoDirectionalLightDragger_initClass()
class SoDragPointDragger(SoDragger):
"""Proxy of C++ SoDragPointDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoDragPointDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoDragPointDragger self) -> SoType"""
return _coin.SoDragPointDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoDragPointDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoDragPointDragger self) -> SoNodekitCatalog"""
return _coin.SoDragPointDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoDragPointDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoDragPointDragger self) -> SoDragPointDragger"""
this = _coin.new_SoDragPointDragger()
try:
self.this.append(this)
except Exception:
self.this = this
translation = _swig_property(_coin.SoDragPointDragger_translation_get, _coin.SoDragPointDragger_translation_set)
def setJumpLimit(self, limit):
"""setJumpLimit(SoDragPointDragger self, float const limit)"""
return _coin.SoDragPointDragger_setJumpLimit(self, limit)
def getJumpLimit(self):
"""getJumpLimit(SoDragPointDragger self) -> float"""
return _coin.SoDragPointDragger_getJumpLimit(self)
def showNextDraggerSet(self):
"""showNextDraggerSet(SoDragPointDragger self)"""
return _coin.SoDragPointDragger_showNextDraggerSet(self)
SoDragPointDragger_swigregister = _coin.SoDragPointDragger_swigregister
SoDragPointDragger_swigregister(SoDragPointDragger)
def SoDragPointDragger_getClassTypeId():
"""SoDragPointDragger_getClassTypeId() -> SoType"""
return _coin.SoDragPointDragger_getClassTypeId()
def SoDragPointDragger_getClassNodekitCatalog():
"""SoDragPointDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoDragPointDragger_getClassNodekitCatalog()
def SoDragPointDragger_initClass():
"""SoDragPointDragger_initClass()"""
return _coin.SoDragPointDragger_initClass()
class SoHandleBoxDragger(SoDragger):
"""Proxy of C++ SoHandleBoxDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoHandleBoxDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoHandleBoxDragger self) -> SoType"""
return _coin.SoHandleBoxDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoHandleBoxDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoHandleBoxDragger self) -> SoNodekitCatalog"""
return _coin.SoHandleBoxDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoHandleBoxDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoHandleBoxDragger self) -> SoHandleBoxDragger"""
this = _coin.new_SoHandleBoxDragger()
try:
self.this.append(this)
except Exception:
self.this = this
scaleFactor = _swig_property(_coin.SoHandleBoxDragger_scaleFactor_get, _coin.SoHandleBoxDragger_scaleFactor_set)
translation = _swig_property(_coin.SoHandleBoxDragger_translation_get, _coin.SoHandleBoxDragger_translation_set)
SoHandleBoxDragger_swigregister = _coin.SoHandleBoxDragger_swigregister
SoHandleBoxDragger_swigregister(SoHandleBoxDragger)
def SoHandleBoxDragger_getClassTypeId():
"""SoHandleBoxDragger_getClassTypeId() -> SoType"""
return _coin.SoHandleBoxDragger_getClassTypeId()
def SoHandleBoxDragger_getClassNodekitCatalog():
"""SoHandleBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoHandleBoxDragger_getClassNodekitCatalog()
def SoHandleBoxDragger_initClass():
"""SoHandleBoxDragger_initClass()"""
return _coin.SoHandleBoxDragger_initClass()
class SoJackDragger(SoDragger):
"""Proxy of C++ SoJackDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoJackDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoJackDragger self) -> SoType"""
return _coin.SoJackDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoJackDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoJackDragger self) -> SoNodekitCatalog"""
return _coin.SoJackDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoJackDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoJackDragger self) -> SoJackDragger"""
this = _coin.new_SoJackDragger()
try:
self.this.append(this)
except Exception:
self.this = this
rotation = _swig_property(_coin.SoJackDragger_rotation_get, _coin.SoJackDragger_rotation_set)
translation = _swig_property(_coin.SoJackDragger_translation_get, _coin.SoJackDragger_translation_set)
scaleFactor = _swig_property(_coin.SoJackDragger_scaleFactor_get, _coin.SoJackDragger_scaleFactor_set)
SoJackDragger_swigregister = _coin.SoJackDragger_swigregister
SoJackDragger_swigregister(SoJackDragger)
def SoJackDragger_getClassTypeId():
"""SoJackDragger_getClassTypeId() -> SoType"""
return _coin.SoJackDragger_getClassTypeId()
def SoJackDragger_getClassNodekitCatalog():
"""SoJackDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoJackDragger_getClassNodekitCatalog()
def SoJackDragger_initClass():
"""SoJackDragger_initClass()"""
return _coin.SoJackDragger_initClass()
class SoPointLightDragger(SoDragger):
"""Proxy of C++ SoPointLightDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoPointLightDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoPointLightDragger self) -> SoType"""
return _coin.SoPointLightDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoPointLightDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoPointLightDragger self) -> SoNodekitCatalog"""
return _coin.SoPointLightDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoPointLightDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoPointLightDragger self) -> SoPointLightDragger"""
this = _coin.new_SoPointLightDragger()
try:
self.this.append(this)
except Exception:
self.this = this
translation = _swig_property(_coin.SoPointLightDragger_translation_get, _coin.SoPointLightDragger_translation_set)
SoPointLightDragger_swigregister = _coin.SoPointLightDragger_swigregister
SoPointLightDragger_swigregister(SoPointLightDragger)
def SoPointLightDragger_getClassTypeId():
"""SoPointLightDragger_getClassTypeId() -> SoType"""
return _coin.SoPointLightDragger_getClassTypeId()
def SoPointLightDragger_getClassNodekitCatalog():
"""SoPointLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoPointLightDragger_getClassNodekitCatalog()
def SoPointLightDragger_initClass():
"""SoPointLightDragger_initClass()"""
return _coin.SoPointLightDragger_initClass()
class SoRotateCylindricalDragger(SoDragger):
"""Proxy of C++ SoRotateCylindricalDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoRotateCylindricalDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoRotateCylindricalDragger self) -> SoType"""
return _coin.SoRotateCylindricalDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoRotateCylindricalDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoRotateCylindricalDragger self) -> SoNodekitCatalog"""
return _coin.SoRotateCylindricalDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoRotateCylindricalDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoRotateCylindricalDragger self) -> SoRotateCylindricalDragger"""
this = _coin.new_SoRotateCylindricalDragger()
try:
self.this.append(this)
except Exception:
self.this = this
rotation = _swig_property(_coin.SoRotateCylindricalDragger_rotation_get, _coin.SoRotateCylindricalDragger_rotation_set)
def setProjector(self, p):
"""setProjector(SoRotateCylindricalDragger self, SbCylinderProjector p)"""
return _coin.SoRotateCylindricalDragger_setProjector(self, p)
def getProjector(self):
"""getProjector(SoRotateCylindricalDragger self) -> SbCylinderProjector"""
return _coin.SoRotateCylindricalDragger_getProjector(self)
SoRotateCylindricalDragger_swigregister = _coin.SoRotateCylindricalDragger_swigregister
SoRotateCylindricalDragger_swigregister(SoRotateCylindricalDragger)
def SoRotateCylindricalDragger_getClassTypeId():
"""SoRotateCylindricalDragger_getClassTypeId() -> SoType"""
return _coin.SoRotateCylindricalDragger_getClassTypeId()
def SoRotateCylindricalDragger_getClassNodekitCatalog():
"""SoRotateCylindricalDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoRotateCylindricalDragger_getClassNodekitCatalog()
def SoRotateCylindricalDragger_initClass():
"""SoRotateCylindricalDragger_initClass()"""
return _coin.SoRotateCylindricalDragger_initClass()
class SoRotateDiscDragger(SoDragger):
"""Proxy of C++ SoRotateDiscDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoRotateDiscDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoRotateDiscDragger self) -> SoType"""
return _coin.SoRotateDiscDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoRotateDiscDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoRotateDiscDragger self) -> SoNodekitCatalog"""
return _coin.SoRotateDiscDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoRotateDiscDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoRotateDiscDragger self) -> SoRotateDiscDragger"""
this = _coin.new_SoRotateDiscDragger()
try:
self.this.append(this)
except Exception:
self.this = this
rotation = _swig_property(_coin.SoRotateDiscDragger_rotation_get, _coin.SoRotateDiscDragger_rotation_set)
SoRotateDiscDragger_swigregister = _coin.SoRotateDiscDragger_swigregister
SoRotateDiscDragger_swigregister(SoRotateDiscDragger)
def SoRotateDiscDragger_getClassTypeId():
"""SoRotateDiscDragger_getClassTypeId() -> SoType"""
return _coin.SoRotateDiscDragger_getClassTypeId()
def SoRotateDiscDragger_getClassNodekitCatalog():
"""SoRotateDiscDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoRotateDiscDragger_getClassNodekitCatalog()
def SoRotateDiscDragger_initClass():
"""SoRotateDiscDragger_initClass()"""
return _coin.SoRotateDiscDragger_initClass()
class SoRotateSphericalDragger(SoDragger):
"""Proxy of C++ SoRotateSphericalDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoRotateSphericalDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoRotateSphericalDragger self) -> SoType"""
return _coin.SoRotateSphericalDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoRotateSphericalDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoRotateSphericalDragger self) -> SoNodekitCatalog"""
return _coin.SoRotateSphericalDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoRotateSphericalDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoRotateSphericalDragger self) -> SoRotateSphericalDragger"""
this = _coin.new_SoRotateSphericalDragger()
try:
self.this.append(this)
except Exception:
self.this = this
rotation = _swig_property(_coin.SoRotateSphericalDragger_rotation_get, _coin.SoRotateSphericalDragger_rotation_set)
def setProjector(self, p):
"""setProjector(SoRotateSphericalDragger self, SbSphereProjector p)"""
return _coin.SoRotateSphericalDragger_setProjector(self, p)
def getProjector(self):
"""getProjector(SoRotateSphericalDragger self) -> SbSphereProjector"""
return _coin.SoRotateSphericalDragger_getProjector(self)
SoRotateSphericalDragger_swigregister = _coin.SoRotateSphericalDragger_swigregister
SoRotateSphericalDragger_swigregister(SoRotateSphericalDragger)
def SoRotateSphericalDragger_getClassTypeId():
"""SoRotateSphericalDragger_getClassTypeId() -> SoType"""
return _coin.SoRotateSphericalDragger_getClassTypeId()
def SoRotateSphericalDragger_getClassNodekitCatalog():
"""SoRotateSphericalDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoRotateSphericalDragger_getClassNodekitCatalog()
def SoRotateSphericalDragger_initClass():
"""SoRotateSphericalDragger_initClass()"""
return _coin.SoRotateSphericalDragger_initClass()
class SoScale1Dragger(SoDragger):
"""Proxy of C++ SoScale1Dragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoScale1Dragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoScale1Dragger self) -> SoType"""
return _coin.SoScale1Dragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoScale1Dragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoScale1Dragger self) -> SoNodekitCatalog"""
return _coin.SoScale1Dragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoScale1Dragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoScale1Dragger self) -> SoScale1Dragger"""
this = _coin.new_SoScale1Dragger()
try:
self.this.append(this)
except Exception:
self.this = this
scaleFactor = _swig_property(_coin.SoScale1Dragger_scaleFactor_get, _coin.SoScale1Dragger_scaleFactor_set)
SoScale1Dragger_swigregister = _coin.SoScale1Dragger_swigregister
SoScale1Dragger_swigregister(SoScale1Dragger)
def SoScale1Dragger_getClassTypeId():
"""SoScale1Dragger_getClassTypeId() -> SoType"""
return _coin.SoScale1Dragger_getClassTypeId()
def SoScale1Dragger_getClassNodekitCatalog():
"""SoScale1Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoScale1Dragger_getClassNodekitCatalog()
def SoScale1Dragger_initClass():
"""SoScale1Dragger_initClass()"""
return _coin.SoScale1Dragger_initClass()
class SoScale2Dragger(SoDragger):
"""Proxy of C++ SoScale2Dragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoScale2Dragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoScale2Dragger self) -> SoType"""
return _coin.SoScale2Dragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoScale2Dragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoScale2Dragger self) -> SoNodekitCatalog"""
return _coin.SoScale2Dragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoScale2Dragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoScale2Dragger self) -> SoScale2Dragger"""
this = _coin.new_SoScale2Dragger()
try:
self.this.append(this)
except Exception:
self.this = this
scaleFactor = _swig_property(_coin.SoScale2Dragger_scaleFactor_get, _coin.SoScale2Dragger_scaleFactor_set)
SoScale2Dragger_swigregister = _coin.SoScale2Dragger_swigregister
SoScale2Dragger_swigregister(SoScale2Dragger)
def SoScale2Dragger_getClassTypeId():
"""SoScale2Dragger_getClassTypeId() -> SoType"""
return _coin.SoScale2Dragger_getClassTypeId()
def SoScale2Dragger_getClassNodekitCatalog():
"""SoScale2Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoScale2Dragger_getClassNodekitCatalog()
def SoScale2Dragger_initClass():
"""SoScale2Dragger_initClass()"""
return _coin.SoScale2Dragger_initClass()
class SoScale2UniformDragger(SoDragger):
"""Proxy of C++ SoScale2UniformDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoScale2UniformDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoScale2UniformDragger self) -> SoType"""
return _coin.SoScale2UniformDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoScale2UniformDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoScale2UniformDragger self) -> SoNodekitCatalog"""
return _coin.SoScale2UniformDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoScale2UniformDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoScale2UniformDragger self) -> SoScale2UniformDragger"""
this = _coin.new_SoScale2UniformDragger()
try:
self.this.append(this)
except Exception:
self.this = this
scaleFactor = _swig_property(_coin.SoScale2UniformDragger_scaleFactor_get, _coin.SoScale2UniformDragger_scaleFactor_set)
SoScale2UniformDragger_swigregister = _coin.SoScale2UniformDragger_swigregister
SoScale2UniformDragger_swigregister(SoScale2UniformDragger)
def SoScale2UniformDragger_getClassTypeId():
"""SoScale2UniformDragger_getClassTypeId() -> SoType"""
return _coin.SoScale2UniformDragger_getClassTypeId()
def SoScale2UniformDragger_getClassNodekitCatalog():
"""SoScale2UniformDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoScale2UniformDragger_getClassNodekitCatalog()
def SoScale2UniformDragger_initClass():
"""SoScale2UniformDragger_initClass()"""
return _coin.SoScale2UniformDragger_initClass()
class SoScaleUniformDragger(SoDragger):
"""Proxy of C++ SoScaleUniformDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoScaleUniformDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoScaleUniformDragger self) -> SoType"""
return _coin.SoScaleUniformDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoScaleUniformDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoScaleUniformDragger self) -> SoNodekitCatalog"""
return _coin.SoScaleUniformDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoScaleUniformDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoScaleUniformDragger self) -> SoScaleUniformDragger"""
this = _coin.new_SoScaleUniformDragger()
try:
self.this.append(this)
except Exception:
self.this = this
scaleFactor = _swig_property(_coin.SoScaleUniformDragger_scaleFactor_get, _coin.SoScaleUniformDragger_scaleFactor_set)
SoScaleUniformDragger_swigregister = _coin.SoScaleUniformDragger_swigregister
SoScaleUniformDragger_swigregister(SoScaleUniformDragger)
def SoScaleUniformDragger_getClassTypeId():
"""SoScaleUniformDragger_getClassTypeId() -> SoType"""
return _coin.SoScaleUniformDragger_getClassTypeId()
def SoScaleUniformDragger_getClassNodekitCatalog():
"""SoScaleUniformDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoScaleUniformDragger_getClassNodekitCatalog()
def SoScaleUniformDragger_initClass():
"""SoScaleUniformDragger_initClass()"""
return _coin.SoScaleUniformDragger_initClass()
class SoSpotLightDragger(SoDragger):
"""Proxy of C++ SoSpotLightDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSpotLightDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSpotLightDragger self) -> SoType"""
return _coin.SoSpotLightDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoSpotLightDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoSpotLightDragger self) -> SoNodekitCatalog"""
return _coin.SoSpotLightDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoSpotLightDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoSpotLightDragger self) -> SoSpotLightDragger"""
this = _coin.new_SoSpotLightDragger()
try:
self.this.append(this)
except Exception:
self.this = this
rotation = _swig_property(_coin.SoSpotLightDragger_rotation_get, _coin.SoSpotLightDragger_rotation_set)
translation = _swig_property(_coin.SoSpotLightDragger_translation_get, _coin.SoSpotLightDragger_translation_set)
angle = _swig_property(_coin.SoSpotLightDragger_angle_get, _coin.SoSpotLightDragger_angle_set)
SoSpotLightDragger_swigregister = _coin.SoSpotLightDragger_swigregister
SoSpotLightDragger_swigregister(SoSpotLightDragger)
def SoSpotLightDragger_getClassTypeId():
"""SoSpotLightDragger_getClassTypeId() -> SoType"""
return _coin.SoSpotLightDragger_getClassTypeId()
def SoSpotLightDragger_getClassNodekitCatalog():
"""SoSpotLightDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoSpotLightDragger_getClassNodekitCatalog()
def SoSpotLightDragger_initClass():
"""SoSpotLightDragger_initClass()"""
return _coin.SoSpotLightDragger_initClass()
class SoTabBoxDragger(SoDragger):
"""Proxy of C++ SoTabBoxDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTabBoxDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTabBoxDragger self) -> SoType"""
return _coin.SoTabBoxDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTabBoxDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoTabBoxDragger self) -> SoNodekitCatalog"""
return _coin.SoTabBoxDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoTabBoxDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoTabBoxDragger self) -> SoTabBoxDragger"""
this = _coin.new_SoTabBoxDragger()
try:
self.this.append(this)
except Exception:
self.this = this
translation = _swig_property(_coin.SoTabBoxDragger_translation_get, _coin.SoTabBoxDragger_translation_set)
scaleFactor = _swig_property(_coin.SoTabBoxDragger_scaleFactor_get, _coin.SoTabBoxDragger_scaleFactor_set)
def adjustScaleTabSize(self):
"""adjustScaleTabSize(SoTabBoxDragger self)"""
return _coin.SoTabBoxDragger_adjustScaleTabSize(self)
SoTabBoxDragger_swigregister = _coin.SoTabBoxDragger_swigregister
SoTabBoxDragger_swigregister(SoTabBoxDragger)
def SoTabBoxDragger_getClassTypeId():
"""SoTabBoxDragger_getClassTypeId() -> SoType"""
return _coin.SoTabBoxDragger_getClassTypeId()
def SoTabBoxDragger_getClassNodekitCatalog():
"""SoTabBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTabBoxDragger_getClassNodekitCatalog()
def SoTabBoxDragger_initClass():
"""SoTabBoxDragger_initClass()"""
return _coin.SoTabBoxDragger_initClass()
class SoTabPlaneDragger(SoDragger):
"""Proxy of C++ SoTabPlaneDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTabPlaneDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTabPlaneDragger self) -> SoType"""
return _coin.SoTabPlaneDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTabPlaneDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoTabPlaneDragger self) -> SoNodekitCatalog"""
return _coin.SoTabPlaneDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoTabPlaneDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoTabPlaneDragger self) -> SoTabPlaneDragger"""
this = _coin.new_SoTabPlaneDragger()
try:
self.this.append(this)
except Exception:
self.this = this
translation = _swig_property(_coin.SoTabPlaneDragger_translation_get, _coin.SoTabPlaneDragger_translation_set)
scaleFactor = _swig_property(_coin.SoTabPlaneDragger_scaleFactor_get, _coin.SoTabPlaneDragger_scaleFactor_set)
def adjustScaleTabSize(self):
"""adjustScaleTabSize(SoTabPlaneDragger self)"""
return _coin.SoTabPlaneDragger_adjustScaleTabSize(self)
SoTabPlaneDragger_swigregister = _coin.SoTabPlaneDragger_swigregister
SoTabPlaneDragger_swigregister(SoTabPlaneDragger)
def SoTabPlaneDragger_getClassTypeId():
"""SoTabPlaneDragger_getClassTypeId() -> SoType"""
return _coin.SoTabPlaneDragger_getClassTypeId()
def SoTabPlaneDragger_getClassNodekitCatalog():
"""SoTabPlaneDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTabPlaneDragger_getClassNodekitCatalog()
def SoTabPlaneDragger_initClass():
"""SoTabPlaneDragger_initClass()"""
return _coin.SoTabPlaneDragger_initClass()
class SoTrackballDragger(SoDragger):
"""Proxy of C++ SoTrackballDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTrackballDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTrackballDragger self) -> SoType"""
return _coin.SoTrackballDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTrackballDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoTrackballDragger self) -> SoNodekitCatalog"""
return _coin.SoTrackballDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoTrackballDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoTrackballDragger self) -> SoTrackballDragger"""
this = _coin.new_SoTrackballDragger()
try:
self.this.append(this)
except Exception:
self.this = this
rotation = _swig_property(_coin.SoTrackballDragger_rotation_get, _coin.SoTrackballDragger_rotation_set)
scaleFactor = _swig_property(_coin.SoTrackballDragger_scaleFactor_get, _coin.SoTrackballDragger_scaleFactor_set)
def isAnimationEnabled(self):
"""isAnimationEnabled(SoTrackballDragger self) -> SbBool"""
return _coin.SoTrackballDragger_isAnimationEnabled(self)
def setAnimationEnabled(self, newval):
"""setAnimationEnabled(SoTrackballDragger self, SbBool newval)"""
return _coin.SoTrackballDragger_setAnimationEnabled(self, newval)
SoTrackballDragger_swigregister = _coin.SoTrackballDragger_swigregister
SoTrackballDragger_swigregister(SoTrackballDragger)
def SoTrackballDragger_getClassTypeId():
"""SoTrackballDragger_getClassTypeId() -> SoType"""
return _coin.SoTrackballDragger_getClassTypeId()
def SoTrackballDragger_getClassNodekitCatalog():
"""SoTrackballDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTrackballDragger_getClassNodekitCatalog()
def SoTrackballDragger_initClass():
"""SoTrackballDragger_initClass()"""
return _coin.SoTrackballDragger_initClass()
class SoTransformBoxDragger(SoDragger):
"""Proxy of C++ SoTransformBoxDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTransformBoxDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTransformBoxDragger self) -> SoType"""
return _coin.SoTransformBoxDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTransformBoxDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoTransformBoxDragger self) -> SoNodekitCatalog"""
return _coin.SoTransformBoxDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoTransformBoxDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoTransformBoxDragger self) -> SoTransformBoxDragger"""
this = _coin.new_SoTransformBoxDragger()
try:
self.this.append(this)
except Exception:
self.this = this
rotation = _swig_property(_coin.SoTransformBoxDragger_rotation_get, _coin.SoTransformBoxDragger_rotation_set)
translation = _swig_property(_coin.SoTransformBoxDragger_translation_get, _coin.SoTransformBoxDragger_translation_set)
scaleFactor = _swig_property(_coin.SoTransformBoxDragger_scaleFactor_get, _coin.SoTransformBoxDragger_scaleFactor_set)
SoTransformBoxDragger_swigregister = _coin.SoTransformBoxDragger_swigregister
SoTransformBoxDragger_swigregister(SoTransformBoxDragger)
def SoTransformBoxDragger_getClassTypeId():
"""SoTransformBoxDragger_getClassTypeId() -> SoType"""
return _coin.SoTransformBoxDragger_getClassTypeId()
def SoTransformBoxDragger_getClassNodekitCatalog():
"""SoTransformBoxDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTransformBoxDragger_getClassNodekitCatalog()
def SoTransformBoxDragger_initClass():
"""SoTransformBoxDragger_initClass()"""
return _coin.SoTransformBoxDragger_initClass()
class SoTransformerDragger(SoDragger):
"""Proxy of C++ SoTransformerDragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTransformerDragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTransformerDragger self) -> SoType"""
return _coin.SoTransformerDragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTransformerDragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoTransformerDragger self) -> SoNodekitCatalog"""
return _coin.SoTransformerDragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoTransformerDragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoTransformerDragger self) -> SoTransformerDragger"""
this = _coin.new_SoTransformerDragger()
try:
self.this.append(this)
except Exception:
self.this = this
rotation = _swig_property(_coin.SoTransformerDragger_rotation_get, _coin.SoTransformerDragger_rotation_set)
translation = _swig_property(_coin.SoTransformerDragger_translation_get, _coin.SoTransformerDragger_translation_set)
scaleFactor = _swig_property(_coin.SoTransformerDragger_scaleFactor_get, _coin.SoTransformerDragger_scaleFactor_set)
minDiscRotDot = _swig_property(_coin.SoTransformerDragger_minDiscRotDot_get, _coin.SoTransformerDragger_minDiscRotDot_set)
INACTIVE = _coin.SoTransformerDragger_INACTIVE
RIT_X_ROTATE = _coin.SoTransformerDragger_RIT_X_ROTATE
TOP_Y_ROTATE = _coin.SoTransformerDragger_TOP_Y_ROTATE
FNT_Z_ROTATE = _coin.SoTransformerDragger_FNT_Z_ROTATE
LFT_X_ROTATE = _coin.SoTransformerDragger_LFT_X_ROTATE
BOT_Y_ROTATE = _coin.SoTransformerDragger_BOT_Y_ROTATE
BAK_Z_ROTATE = _coin.SoTransformerDragger_BAK_Z_ROTATE
PX_PY_PZ_3D_SCALE = _coin.SoTransformerDragger_PX_PY_PZ_3D_SCALE
PX_PY_NZ_3D_SCALE = _coin.SoTransformerDragger_PX_PY_NZ_3D_SCALE
PX_NY_PZ_3D_SCALE = _coin.SoTransformerDragger_PX_NY_PZ_3D_SCALE
PX_NY_NZ_3D_SCALE = _coin.SoTransformerDragger_PX_NY_NZ_3D_SCALE
NX_PY_PZ_3D_SCALE = _coin.SoTransformerDragger_NX_PY_PZ_3D_SCALE
NX_PY_NZ_3D_SCALE = _coin.SoTransformerDragger_NX_PY_NZ_3D_SCALE
NX_NY_PZ_3D_SCALE = _coin.SoTransformerDragger_NX_NY_PZ_3D_SCALE
NX_NY_NZ_3D_SCALE = _coin.SoTransformerDragger_NX_NY_NZ_3D_SCALE
RIT_TRANSLATE = _coin.SoTransformerDragger_RIT_TRANSLATE
TOP_TRANSLATE = _coin.SoTransformerDragger_TOP_TRANSLATE
FNT_TRANSLATE = _coin.SoTransformerDragger_FNT_TRANSLATE
LFT_TRANSLATE = _coin.SoTransformerDragger_LFT_TRANSLATE
BOT_TRANSLATE = _coin.SoTransformerDragger_BOT_TRANSLATE
BAK_TRANSLATE = _coin.SoTransformerDragger_BAK_TRANSLATE
def getCurrentState(self):
"""getCurrentState(SoTransformerDragger self) -> SoTransformerDragger::State"""
return _coin.SoTransformerDragger_getCurrentState(self)
def unsquishKnobs(self):
"""unsquishKnobs(SoTransformerDragger self)"""
return _coin.SoTransformerDragger_unsquishKnobs(self)
def isLocateHighlighting(self):
"""isLocateHighlighting(SoTransformerDragger self) -> SbBool"""
return _coin.SoTransformerDragger_isLocateHighlighting(self)
def setLocateHighlighting(self, onoff):
"""setLocateHighlighting(SoTransformerDragger self, SbBool onoff)"""
return _coin.SoTransformerDragger_setLocateHighlighting(self, onoff)
def setColinearThreshold(newval):
"""setColinearThreshold(int newval)"""
return _coin.SoTransformerDragger_setColinearThreshold(newval)
setColinearThreshold = staticmethod(setColinearThreshold)
def getColinearThreshold():
"""getColinearThreshold() -> int"""
return _coin.SoTransformerDragger_getColinearThreshold()
getColinearThreshold = staticmethod(getColinearThreshold)
def getBoxPointInWorldSpace(self, pointonunitbox):
"""getBoxPointInWorldSpace(SoTransformerDragger self, SbVec3f pointonunitbox) -> SbVec3f"""
return _coin.SoTransformerDragger_getBoxPointInWorldSpace(self, pointonunitbox)
def getBoxDirInWorldSpace(self, dironunitbox):
"""getBoxDirInWorldSpace(SoTransformerDragger self, SbVec3f dironunitbox) -> SbVec3f"""
return _coin.SoTransformerDragger_getBoxDirInWorldSpace(self, dironunitbox)
def getWorldPointInBoxSpace(self, pointinworldspace):
"""getWorldPointInBoxSpace(SoTransformerDragger self, SbVec3f pointinworldspace) -> SbVec3f"""
return _coin.SoTransformerDragger_getWorldPointInBoxSpace(self, pointinworldspace)
def getWorldPointInPixelSpace(self, thepoint):
"""getWorldPointInPixelSpace(SoTransformerDragger self, SbVec3f thepoint) -> SbVec2f"""
return _coin.SoTransformerDragger_getWorldPointInPixelSpace(self, thepoint)
def getInteractiveCenterInBoxSpace(self):
"""getInteractiveCenterInBoxSpace(SoTransformerDragger self) -> SbVec3f"""
return _coin.SoTransformerDragger_getInteractiveCenterInBoxSpace(self)
SoTransformerDragger_swigregister = _coin.SoTransformerDragger_swigregister
SoTransformerDragger_swigregister(SoTransformerDragger)
def SoTransformerDragger_getClassTypeId():
"""SoTransformerDragger_getClassTypeId() -> SoType"""
return _coin.SoTransformerDragger_getClassTypeId()
def SoTransformerDragger_getClassNodekitCatalog():
"""SoTransformerDragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTransformerDragger_getClassNodekitCatalog()
def SoTransformerDragger_initClass():
"""SoTransformerDragger_initClass()"""
return _coin.SoTransformerDragger_initClass()
def SoTransformerDragger_setColinearThreshold(newval):
"""SoTransformerDragger_setColinearThreshold(int newval)"""
return _coin.SoTransformerDragger_setColinearThreshold(newval)
def SoTransformerDragger_getColinearThreshold():
"""SoTransformerDragger_getColinearThreshold() -> int"""
return _coin.SoTransformerDragger_getColinearThreshold()
class SoTranslate1Dragger(SoDragger):
"""Proxy of C++ SoTranslate1Dragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTranslate1Dragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTranslate1Dragger self) -> SoType"""
return _coin.SoTranslate1Dragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTranslate1Dragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoTranslate1Dragger self) -> SoNodekitCatalog"""
return _coin.SoTranslate1Dragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoTranslate1Dragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoTranslate1Dragger self) -> SoTranslate1Dragger"""
this = _coin.new_SoTranslate1Dragger()
try:
self.this.append(this)
except Exception:
self.this = this
translation = _swig_property(_coin.SoTranslate1Dragger_translation_get, _coin.SoTranslate1Dragger_translation_set)
minTranslation = _swig_property(_coin.SoTranslate1Dragger_minTranslation_get, _coin.SoTranslate1Dragger_minTranslation_set)
maxTranslation = _swig_property(_coin.SoTranslate1Dragger_maxTranslation_get, _coin.SoTranslate1Dragger_maxTranslation_set)
SoTranslate1Dragger_swigregister = _coin.SoTranslate1Dragger_swigregister
SoTranslate1Dragger_swigregister(SoTranslate1Dragger)
def SoTranslate1Dragger_getClassTypeId():
"""SoTranslate1Dragger_getClassTypeId() -> SoType"""
return _coin.SoTranslate1Dragger_getClassTypeId()
def SoTranslate1Dragger_getClassNodekitCatalog():
"""SoTranslate1Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTranslate1Dragger_getClassNodekitCatalog()
def SoTranslate1Dragger_initClass():
"""SoTranslate1Dragger_initClass()"""
return _coin.SoTranslate1Dragger_initClass()
class SoSFVec2f(SoSField):
"""Proxy of C++ SoSFVec2f class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(SoSFVec2f self) -> SoSFVec2f"""
this = _coin.new_SoSFVec2f()
try:
self.this.append(this)
except Exception:
self.this = this
__swig_destroy__ = _coin.delete_SoSFVec2f
__del__ = lambda self: None
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSFVec2f_createInstance()
createInstance = staticmethod(createInstance)
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSFVec2f_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoSFVec2f self) -> SoType"""
return _coin.SoSFVec2f_getTypeId(self)
def copyFrom(self, field):
"""copyFrom(SoSFVec2f self, SoField field)"""
return _coin.SoSFVec2f_copyFrom(self, field)
def isSame(self, field):
"""isSame(SoSFVec2f self, SoField field) -> SbBool"""
return _coin.SoSFVec2f_isSame(self, field)
def getValue(self):
"""getValue(SoSFVec2f self) -> SbVec2f"""
return _coin.SoSFVec2f_getValue(self)
def __eq__(self, field):
"""__eq__(SoSFVec2f self, SoSFVec2f field) -> int"""
return _coin.SoSFVec2f___eq__(self, field)
def __ne__(self, field):
"""__ne__(SoSFVec2f self, SoSFVec2f field) -> int"""
return _coin.SoSFVec2f___ne__(self, field)
def initClass():
"""initClass()"""
return _coin.SoSFVec2f_initClass()
initClass = staticmethod(initClass)
def setValue(self, *args):
"""
setValue(SoSFVec2f self, SbVec2f newvalue)
setValue(SoSFVec2f self, float x, float y)
setValue(SoSFVec2f self, float const [2] xy)
setValue(SoSFVec2f self, SoSFVec2f other)
"""
return _coin.SoSFVec2f_setValue(self, *args)
SoSFVec2f_swigregister = _coin.SoSFVec2f_swigregister
SoSFVec2f_swigregister(SoSFVec2f)
def SoSFVec2f_createInstance():
"""SoSFVec2f_createInstance() -> void *"""
return _coin.SoSFVec2f_createInstance()
def SoSFVec2f_getClassTypeId():
"""SoSFVec2f_getClassTypeId() -> SoType"""
return _coin.SoSFVec2f_getClassTypeId()
def SoSFVec2f_initClass():
"""SoSFVec2f_initClass()"""
return _coin.SoSFVec2f_initClass()
class SoTranslate2Dragger(SoDragger):
"""Proxy of C++ SoTranslate2Dragger class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTranslate2Dragger_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getTypeId(self):
"""getTypeId(SoTranslate2Dragger self) -> SoType"""
return _coin.SoTranslate2Dragger_getTypeId(self)
def getClassNodekitCatalog():
"""getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTranslate2Dragger_getClassNodekitCatalog()
getClassNodekitCatalog = staticmethod(getClassNodekitCatalog)
def getNodekitCatalog(self):
"""getNodekitCatalog(SoTranslate2Dragger self) -> SoNodekitCatalog"""
return _coin.SoTranslate2Dragger_getNodekitCatalog(self)
def initClass():
"""initClass()"""
return _coin.SoTranslate2Dragger_initClass()
initClass = staticmethod(initClass)
def __init__(self):
"""__init__(SoTranslate2Dragger self) -> SoTranslate2Dragger"""
this = _coin.new_SoTranslate2Dragger()
try:
self.this.append(this)
except Exception:
self.this = this
translation = _swig_property(_coin.SoTranslate2Dragger_translation_get, _coin.SoTranslate2Dragger_translation_set)
minTranslation = _swig_property(_coin.SoTranslate2Dragger_minTranslation_get, _coin.SoTranslate2Dragger_minTranslation_set)
maxTranslation = _swig_property(_coin.SoTranslate2Dragger_maxTranslation_get, _coin.SoTranslate2Dragger_maxTranslation_set)
SoTranslate2Dragger_swigregister = _coin.SoTranslate2Dragger_swigregister
SoTranslate2Dragger_swigregister(SoTranslate2Dragger)
def SoTranslate2Dragger_getClassTypeId():
"""SoTranslate2Dragger_getClassTypeId() -> SoType"""
return _coin.SoTranslate2Dragger_getClassTypeId()
def SoTranslate2Dragger_getClassNodekitCatalog():
"""SoTranslate2Dragger_getClassNodekitCatalog() -> SoNodekitCatalog"""
return _coin.SoTranslate2Dragger_getClassNodekitCatalog()
def SoTranslate2Dragger_initClass():
"""SoTranslate2Dragger_initClass()"""
return _coin.SoTranslate2Dragger_initClass()
class SoAccumulatedElement(SoElement):
"""Proxy of C++ SoAccumulatedElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoAccumulatedElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoAccumulatedElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def initClass():
"""initClass()"""
return _coin.SoAccumulatedElement_initClass()
initClass = staticmethod(initClass)
def matches(self, element):
"""matches(SoAccumulatedElement self, SoElement element) -> SbBool"""
return _coin.SoAccumulatedElement_matches(self, element)
SoAccumulatedElement_swigregister = _coin.SoAccumulatedElement_swigregister
SoAccumulatedElement_swigregister(SoAccumulatedElement)
def SoAccumulatedElement_getClassTypeId():
"""SoAccumulatedElement_getClassTypeId() -> SoType"""
return _coin.SoAccumulatedElement_getClassTypeId()
def SoAccumulatedElement_getClassStackIndex():
"""SoAccumulatedElement_getClassStackIndex() -> int"""
return _coin.SoAccumulatedElement_getClassStackIndex()
def SoAccumulatedElement_initClass():
"""SoAccumulatedElement_initClass()"""
return _coin.SoAccumulatedElement_initClass()
class SoAmbientColorElement(SoReplacedElement):
"""Proxy of C++ SoAmbientColorElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoAmbientColorElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoAmbientColorElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoAmbientColorElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoAmbientColorElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoAmbientColorElement self, SoState state)"""
return _coin.SoAmbientColorElement_init(self, state)
def set(state, node, numcolors, colors):
"""set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
return _coin.SoAmbientColorElement_set(state, node, numcolors, colors)
set = staticmethod(set)
def getInstance(state):
"""getInstance(SoState state) -> SoAmbientColorElement"""
return _coin.SoAmbientColorElement_getInstance(state)
getInstance = staticmethod(getInstance)
def getNum(self):
"""getNum(SoAmbientColorElement self) -> int32_t"""
return _coin.SoAmbientColorElement_getNum(self)
def get(self, index):
"""get(SoAmbientColorElement self, int const index) -> SbColor"""
return _coin.SoAmbientColorElement_get(self, index)
def getArrayPtr(self):
"""getArrayPtr(SoAmbientColorElement self) -> SbColor"""
return _coin.SoAmbientColorElement_getArrayPtr(self)
SoAmbientColorElement_swigregister = _coin.SoAmbientColorElement_swigregister
SoAmbientColorElement_swigregister(SoAmbientColorElement)
def SoAmbientColorElement_getClassTypeId():
"""SoAmbientColorElement_getClassTypeId() -> SoType"""
return _coin.SoAmbientColorElement_getClassTypeId()
def SoAmbientColorElement_getClassStackIndex():
"""SoAmbientColorElement_getClassStackIndex() -> int"""
return _coin.SoAmbientColorElement_getClassStackIndex()
def SoAmbientColorElement_createInstance():
"""SoAmbientColorElement_createInstance() -> void *"""
return _coin.SoAmbientColorElement_createInstance()
def SoAmbientColorElement_initClass():
"""SoAmbientColorElement_initClass()"""
return _coin.SoAmbientColorElement_initClass()
def SoAmbientColorElement_set(state, node, numcolors, colors):
"""SoAmbientColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
return _coin.SoAmbientColorElement_set(state, node, numcolors, colors)
def SoAmbientColorElement_getInstance(state):
"""SoAmbientColorElement_getInstance(SoState state) -> SoAmbientColorElement"""
return _coin.SoAmbientColorElement_getInstance(state)
class SoAnnoText3CharOrientElement(SoInt32Element):
"""Proxy of C++ SoAnnoText3CharOrientElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoAnnoText3CharOrientElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoAnnoText3CharOrientElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoAnnoText3CharOrientElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoAnnoText3CharOrientElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoAnnoText3CharOrientElement self, SoState state)"""
return _coin.SoAnnoText3CharOrientElement_init(self, state)
def set(state, isOriented):
"""set(SoState state, SbBool isOriented)"""
return _coin.SoAnnoText3CharOrientElement_set(state, isOriented)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SbBool"""
return _coin.SoAnnoText3CharOrientElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SbBool"""
return _coin.SoAnnoText3CharOrientElement_getDefault()
getDefault = staticmethod(getDefault)
SoAnnoText3CharOrientElement_swigregister = _coin.SoAnnoText3CharOrientElement_swigregister
SoAnnoText3CharOrientElement_swigregister(SoAnnoText3CharOrientElement)
def SoAnnoText3CharOrientElement_getClassTypeId():
"""SoAnnoText3CharOrientElement_getClassTypeId() -> SoType"""
return _coin.SoAnnoText3CharOrientElement_getClassTypeId()
def SoAnnoText3CharOrientElement_getClassStackIndex():
"""SoAnnoText3CharOrientElement_getClassStackIndex() -> int"""
return _coin.SoAnnoText3CharOrientElement_getClassStackIndex()
def SoAnnoText3CharOrientElement_createInstance():
"""SoAnnoText3CharOrientElement_createInstance() -> void *"""
return _coin.SoAnnoText3CharOrientElement_createInstance()
def SoAnnoText3CharOrientElement_initClass():
"""SoAnnoText3CharOrientElement_initClass()"""
return _coin.SoAnnoText3CharOrientElement_initClass()
def SoAnnoText3CharOrientElement_set(state, isOriented):
"""SoAnnoText3CharOrientElement_set(SoState state, SbBool isOriented)"""
return _coin.SoAnnoText3CharOrientElement_set(state, isOriented)
def SoAnnoText3CharOrientElement_get(state):
"""SoAnnoText3CharOrientElement_get(SoState state) -> SbBool"""
return _coin.SoAnnoText3CharOrientElement_get(state)
def SoAnnoText3CharOrientElement_getDefault():
"""SoAnnoText3CharOrientElement_getDefault() -> SbBool"""
return _coin.SoAnnoText3CharOrientElement_getDefault()
class SoAnnoText3FontSizeHintElement(SoInt32Element):
"""Proxy of C++ SoAnnoText3FontSizeHintElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoAnnoText3FontSizeHintElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoAnnoText3FontSizeHintElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoAnnoText3FontSizeHintElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoAnnoText3FontSizeHintElement_initClass()
initClass = staticmethod(initClass)
ANNOTATION = _coin.SoAnnoText3FontSizeHintElement_ANNOTATION
FIT_TEXT_VECTOR = _coin.SoAnnoText3FontSizeHintElement_FIT_TEXT_VECTOR
def init(self, state):
"""init(SoAnnoText3FontSizeHintElement self, SoState state)"""
return _coin.SoAnnoText3FontSizeHintElement_init(self, state)
def get(state):
"""get(SoState state) -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
return _coin.SoAnnoText3FontSizeHintElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
return _coin.SoAnnoText3FontSizeHintElement_getDefault()
getDefault = staticmethod(getDefault)
def set(*args):
"""
set(SoState state, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
set(SoState state, SoNode node, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
"""
return _coin.SoAnnoText3FontSizeHintElement_set(*args)
set = staticmethod(set)
SoAnnoText3FontSizeHintElement_swigregister = _coin.SoAnnoText3FontSizeHintElement_swigregister
SoAnnoText3FontSizeHintElement_swigregister(SoAnnoText3FontSizeHintElement)
def SoAnnoText3FontSizeHintElement_getClassTypeId():
"""SoAnnoText3FontSizeHintElement_getClassTypeId() -> SoType"""
return _coin.SoAnnoText3FontSizeHintElement_getClassTypeId()
def SoAnnoText3FontSizeHintElement_getClassStackIndex():
"""SoAnnoText3FontSizeHintElement_getClassStackIndex() -> int"""
return _coin.SoAnnoText3FontSizeHintElement_getClassStackIndex()
def SoAnnoText3FontSizeHintElement_createInstance():
"""SoAnnoText3FontSizeHintElement_createInstance() -> void *"""
return _coin.SoAnnoText3FontSizeHintElement_createInstance()
def SoAnnoText3FontSizeHintElement_initClass():
"""SoAnnoText3FontSizeHintElement_initClass()"""
return _coin.SoAnnoText3FontSizeHintElement_initClass()
def SoAnnoText3FontSizeHintElement_get(state):
"""SoAnnoText3FontSizeHintElement_get(SoState state) -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
return _coin.SoAnnoText3FontSizeHintElement_get(state)
def SoAnnoText3FontSizeHintElement_getDefault():
"""SoAnnoText3FontSizeHintElement_getDefault() -> SoAnnoText3FontSizeHintElement::FontSizeHint"""
return _coin.SoAnnoText3FontSizeHintElement_getDefault()
def SoAnnoText3FontSizeHintElement_set(*args):
"""
set(SoState state, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
SoAnnoText3FontSizeHintElement_set(SoState state, SoNode node, SoAnnoText3FontSizeHintElement::FontSizeHint const hint)
"""
return _coin.SoAnnoText3FontSizeHintElement_set(*args)
class SoAnnoText3RenderPrintElement(SoInt32Element):
"""Proxy of C++ SoAnnoText3RenderPrintElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoAnnoText3RenderPrintElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoAnnoText3RenderPrintElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoAnnoText3RenderPrintElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoAnnoText3RenderPrintElement_initClass()
initClass = staticmethod(initClass)
RENDER3D_PRINT_VECTOR = _coin.SoAnnoText3RenderPrintElement_RENDER3D_PRINT_VECTOR
RENDER3D_PRINT_RASTER = _coin.SoAnnoText3RenderPrintElement_RENDER3D_PRINT_RASTER
RENDER2D_PRINT_RASTER = _coin.SoAnnoText3RenderPrintElement_RENDER2D_PRINT_RASTER
def init(self, state):
"""init(SoAnnoText3RenderPrintElement self, SoState state)"""
return _coin.SoAnnoText3RenderPrintElement_init(self, state)
def get(state):
"""get(SoState state) -> SoAnnoText3RenderPrintElement::RenderPrintType"""
return _coin.SoAnnoText3RenderPrintElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SoAnnoText3RenderPrintElement::RenderPrintType"""
return _coin.SoAnnoText3RenderPrintElement_getDefault()
getDefault = staticmethod(getDefault)
def set(*args):
"""
set(SoState state, SoAnnoText3RenderPrintElement::RenderPrintType const hint)
set(SoState state, SoNode node, SoAnnoText3RenderPrintElement::RenderPrintType const type)
"""
return _coin.SoAnnoText3RenderPrintElement_set(*args)
set = staticmethod(set)
SoAnnoText3RenderPrintElement_swigregister = _coin.SoAnnoText3RenderPrintElement_swigregister
SoAnnoText3RenderPrintElement_swigregister(SoAnnoText3RenderPrintElement)
def SoAnnoText3RenderPrintElement_getClassTypeId():
"""SoAnnoText3RenderPrintElement_getClassTypeId() -> SoType"""
return _coin.SoAnnoText3RenderPrintElement_getClassTypeId()
def SoAnnoText3RenderPrintElement_getClassStackIndex():
"""SoAnnoText3RenderPrintElement_getClassStackIndex() -> int"""
return _coin.SoAnnoText3RenderPrintElement_getClassStackIndex()
def SoAnnoText3RenderPrintElement_createInstance():
"""SoAnnoText3RenderPrintElement_createInstance() -> void *"""
return _coin.SoAnnoText3RenderPrintElement_createInstance()
def SoAnnoText3RenderPrintElement_initClass():
"""SoAnnoText3RenderPrintElement_initClass()"""
return _coin.SoAnnoText3RenderPrintElement_initClass()
def SoAnnoText3RenderPrintElement_get(state):
"""SoAnnoText3RenderPrintElement_get(SoState state) -> SoAnnoText3RenderPrintElement::RenderPrintType"""
return _coin.SoAnnoText3RenderPrintElement_get(state)
def SoAnnoText3RenderPrintElement_getDefault():
"""SoAnnoText3RenderPrintElement_getDefault() -> SoAnnoText3RenderPrintElement::RenderPrintType"""
return _coin.SoAnnoText3RenderPrintElement_getDefault()
def SoAnnoText3RenderPrintElement_set(*args):
"""
set(SoState state, SoAnnoText3RenderPrintElement::RenderPrintType const hint)
SoAnnoText3RenderPrintElement_set(SoState state, SoNode node, SoAnnoText3RenderPrintElement::RenderPrintType const type)
"""
return _coin.SoAnnoText3RenderPrintElement_set(*args)
class SoModelMatrixElement(SoAccumulatedElement):
"""Proxy of C++ SoModelMatrixElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoModelMatrixElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoModelMatrixElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoModelMatrixElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoModelMatrixElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoModelMatrixElement self, SoState state)"""
return _coin.SoModelMatrixElement_init(self, state)
def push(self, state):
"""push(SoModelMatrixElement self, SoState state)"""
return _coin.SoModelMatrixElement_push(self, state)
def matches(self, element):
"""matches(SoModelMatrixElement self, SoElement element) -> SbBool"""
return _coin.SoModelMatrixElement_matches(self, element)
def makeIdentity(state, node):
"""makeIdentity(SoState state, SoNode node)"""
return _coin.SoModelMatrixElement_makeIdentity(state, node)
makeIdentity = staticmethod(makeIdentity)
def set(state, node):
"""set(SoState state, SoNode node)"""
return _coin.SoModelMatrixElement_set(state, node)
set = staticmethod(set)
def setCullMatrix(state, node):
"""setCullMatrix(SoState state, SoNode node)"""
return _coin.SoModelMatrixElement_setCullMatrix(state, node)
setCullMatrix = staticmethod(setCullMatrix)
def mult(state, node):
"""mult(SoState state, SoNode node)"""
return _coin.SoModelMatrixElement_mult(state, node)
mult = staticmethod(mult)
def translateBy(state, node, translation):
"""translateBy(SoState state, SoNode node, SbVec3f translation)"""
return _coin.SoModelMatrixElement_translateBy(state, node, translation)
translateBy = staticmethod(translateBy)
def rotateBy(state, node, rotation):
"""rotateBy(SoState state, SoNode node, SbRotation rotation)"""
return _coin.SoModelMatrixElement_rotateBy(state, node, rotation)
rotateBy = staticmethod(rotateBy)
def scaleBy(state, node, scaleFactor):
"""scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
return _coin.SoModelMatrixElement_scaleBy(state, node, scaleFactor)
scaleBy = staticmethod(scaleBy)
def pushMatrix(state):
"""pushMatrix(SoState state) -> SbMatrix"""
return _coin.SoModelMatrixElement_pushMatrix(state)
pushMatrix = staticmethod(pushMatrix)
def popMatrix(state):
"""popMatrix(SoState state)"""
return _coin.SoModelMatrixElement_popMatrix(state)
popMatrix = staticmethod(popMatrix)
def getCombinedCullMatrix(state):
"""getCombinedCullMatrix(SoState state) -> SbMatrix"""
return _coin.SoModelMatrixElement_getCombinedCullMatrix(state)
getCombinedCullMatrix = staticmethod(getCombinedCullMatrix)
def get(*args):
"""
get(SoState state) -> SbMatrix
get(SoState state, SbBool & isIdentity) -> SbMatrix
"""
return _coin.SoModelMatrixElement_get(*args)
get = staticmethod(get)
def getModelMatrix(self):
"""getModelMatrix(SoModelMatrixElement self) -> SbMatrix"""
return _coin.SoModelMatrixElement_getModelMatrix(self)
SoModelMatrixElement_swigregister = _coin.SoModelMatrixElement_swigregister
SoModelMatrixElement_swigregister(SoModelMatrixElement)
def SoModelMatrixElement_getClassTypeId():
"""SoModelMatrixElement_getClassTypeId() -> SoType"""
return _coin.SoModelMatrixElement_getClassTypeId()
def SoModelMatrixElement_getClassStackIndex():
"""SoModelMatrixElement_getClassStackIndex() -> int"""
return _coin.SoModelMatrixElement_getClassStackIndex()
def SoModelMatrixElement_createInstance():
"""SoModelMatrixElement_createInstance() -> void *"""
return _coin.SoModelMatrixElement_createInstance()
def SoModelMatrixElement_initClass():
"""SoModelMatrixElement_initClass()"""
return _coin.SoModelMatrixElement_initClass()
def SoModelMatrixElement_makeIdentity(state, node):
"""SoModelMatrixElement_makeIdentity(SoState state, SoNode node)"""
return _coin.SoModelMatrixElement_makeIdentity(state, node)
def SoModelMatrixElement_set(state, node):
"""SoModelMatrixElement_set(SoState state, SoNode node)"""
return _coin.SoModelMatrixElement_set(state, node)
def SoModelMatrixElement_setCullMatrix(state, node):
"""SoModelMatrixElement_setCullMatrix(SoState state, SoNode node)"""
return _coin.SoModelMatrixElement_setCullMatrix(state, node)
def SoModelMatrixElement_mult(state, node):
"""SoModelMatrixElement_mult(SoState state, SoNode node)"""
return _coin.SoModelMatrixElement_mult(state, node)
def SoModelMatrixElement_translateBy(state, node, translation):
"""SoModelMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
return _coin.SoModelMatrixElement_translateBy(state, node, translation)
def SoModelMatrixElement_rotateBy(state, node, rotation):
"""SoModelMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
return _coin.SoModelMatrixElement_rotateBy(state, node, rotation)
def SoModelMatrixElement_scaleBy(state, node, scaleFactor):
"""SoModelMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
return _coin.SoModelMatrixElement_scaleBy(state, node, scaleFactor)
def SoModelMatrixElement_pushMatrix(state):
"""SoModelMatrixElement_pushMatrix(SoState state) -> SbMatrix"""
return _coin.SoModelMatrixElement_pushMatrix(state)
def SoModelMatrixElement_popMatrix(state):
"""SoModelMatrixElement_popMatrix(SoState state)"""
return _coin.SoModelMatrixElement_popMatrix(state)
def SoModelMatrixElement_getCombinedCullMatrix(state):
"""SoModelMatrixElement_getCombinedCullMatrix(SoState state) -> SbMatrix"""
return _coin.SoModelMatrixElement_getCombinedCullMatrix(state)
def SoModelMatrixElement_get(*args):
"""
get(SoState state) -> SbMatrix
SoModelMatrixElement_get(SoState state, SbBool & isIdentity) -> SbMatrix
"""
return _coin.SoModelMatrixElement_get(*args)
class SoBBoxModelMatrixElement(SoModelMatrixElement):
"""Proxy of C++ SoBBoxModelMatrixElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoBBoxModelMatrixElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoBBoxModelMatrixElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoBBoxModelMatrixElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoBBoxModelMatrixElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoBBoxModelMatrixElement self, SoState state)"""
return _coin.SoBBoxModelMatrixElement_init(self, state)
def push(self, state):
"""push(SoBBoxModelMatrixElement self, SoState state)"""
return _coin.SoBBoxModelMatrixElement_push(self, state)
def reset(state, node):
"""reset(SoState state, SoNode node)"""
return _coin.SoBBoxModelMatrixElement_reset(state, node)
reset = staticmethod(reset)
def pushMatrix(state, localmatrix):
"""pushMatrix(SoState state, SbMatrix localmatrix)"""
return _coin.SoBBoxModelMatrixElement_pushMatrix(state, localmatrix)
pushMatrix = staticmethod(pushMatrix)
def popMatrix(state, localmatrix):
"""popMatrix(SoState state, SbMatrix localmatrix)"""
return _coin.SoBBoxModelMatrixElement_popMatrix(state, localmatrix)
popMatrix = staticmethod(popMatrix)
SoBBoxModelMatrixElement_swigregister = _coin.SoBBoxModelMatrixElement_swigregister
SoBBoxModelMatrixElement_swigregister(SoBBoxModelMatrixElement)
def SoBBoxModelMatrixElement_getClassTypeId():
"""SoBBoxModelMatrixElement_getClassTypeId() -> SoType"""
return _coin.SoBBoxModelMatrixElement_getClassTypeId()
def SoBBoxModelMatrixElement_getClassStackIndex():
"""SoBBoxModelMatrixElement_getClassStackIndex() -> int"""
return _coin.SoBBoxModelMatrixElement_getClassStackIndex()
def SoBBoxModelMatrixElement_createInstance():
"""SoBBoxModelMatrixElement_createInstance() -> void *"""
return _coin.SoBBoxModelMatrixElement_createInstance()
def SoBBoxModelMatrixElement_initClass():
"""SoBBoxModelMatrixElement_initClass()"""
return _coin.SoBBoxModelMatrixElement_initClass()
def SoBBoxModelMatrixElement_reset(state, node):
"""SoBBoxModelMatrixElement_reset(SoState state, SoNode node)"""
return _coin.SoBBoxModelMatrixElement_reset(state, node)
def SoBBoxModelMatrixElement_pushMatrix(state, localmatrix):
"""SoBBoxModelMatrixElement_pushMatrix(SoState state, SbMatrix localmatrix)"""
return _coin.SoBBoxModelMatrixElement_pushMatrix(state, localmatrix)
def SoBBoxModelMatrixElement_popMatrix(state, localmatrix):
"""SoBBoxModelMatrixElement_popMatrix(SoState state, SbMatrix localmatrix)"""
return _coin.SoBBoxModelMatrixElement_popMatrix(state, localmatrix)
class SoBumpMapCoordinateElement(SoReplacedElement):
"""Proxy of C++ SoBumpMapCoordinateElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoBumpMapCoordinateElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoBumpMapCoordinateElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoBumpMapCoordinateElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoBumpMapCoordinateElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoBumpMapCoordinateElement self, SoState state)"""
return _coin.SoBumpMapCoordinateElement_init(self, state)
def set(state, node, numcoords, coords):
"""set(SoState state, SoNode node, int32_t const numcoords, SbVec2f coords)"""
return _coin.SoBumpMapCoordinateElement_set(state, node, numcoords, coords)
set = staticmethod(set)
def getInstance(state):
"""getInstance(SoState state) -> SoBumpMapCoordinateElement"""
return _coin.SoBumpMapCoordinateElement_getInstance(state)
getInstance = staticmethod(getInstance)
def getNum(self):
"""getNum(SoBumpMapCoordinateElement self) -> int32_t"""
return _coin.SoBumpMapCoordinateElement_getNum(self)
def get(self, index):
"""get(SoBumpMapCoordinateElement self, int const index) -> SbVec2f"""
return _coin.SoBumpMapCoordinateElement_get(self, index)
def getArrayPtr(self):
"""getArrayPtr(SoBumpMapCoordinateElement self) -> SbVec2f"""
return _coin.SoBumpMapCoordinateElement_getArrayPtr(self)
SoBumpMapCoordinateElement_swigregister = _coin.SoBumpMapCoordinateElement_swigregister
SoBumpMapCoordinateElement_swigregister(SoBumpMapCoordinateElement)
def SoBumpMapCoordinateElement_getClassTypeId():
"""SoBumpMapCoordinateElement_getClassTypeId() -> SoType"""
return _coin.SoBumpMapCoordinateElement_getClassTypeId()
def SoBumpMapCoordinateElement_getClassStackIndex():
"""SoBumpMapCoordinateElement_getClassStackIndex() -> int"""
return _coin.SoBumpMapCoordinateElement_getClassStackIndex()
def SoBumpMapCoordinateElement_createInstance():
"""SoBumpMapCoordinateElement_createInstance() -> void *"""
return _coin.SoBumpMapCoordinateElement_createInstance()
def SoBumpMapCoordinateElement_initClass():
"""SoBumpMapCoordinateElement_initClass()"""
return _coin.SoBumpMapCoordinateElement_initClass()
def SoBumpMapCoordinateElement_set(state, node, numcoords, coords):
"""SoBumpMapCoordinateElement_set(SoState state, SoNode node, int32_t const numcoords, SbVec2f coords)"""
return _coin.SoBumpMapCoordinateElement_set(state, node, numcoords, coords)
def SoBumpMapCoordinateElement_getInstance(state):
"""SoBumpMapCoordinateElement_getInstance(SoState state) -> SoBumpMapCoordinateElement"""
return _coin.SoBumpMapCoordinateElement_getInstance(state)
class SoBumpMapElement(SoReplacedElement):
"""Proxy of C++ SoBumpMapElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoBumpMapElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoBumpMapElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoBumpMapElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoBumpMapElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoBumpMapElement self, SoState state)"""
return _coin.SoBumpMapElement_init(self, state)
def set(state, node, image):
"""set(SoState state, SoNode node, SoGLImage image)"""
return _coin.SoBumpMapElement_set(state, node, image)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SoGLImage"""
return _coin.SoBumpMapElement_get(state)
get = staticmethod(get)
SoBumpMapElement_swigregister = _coin.SoBumpMapElement_swigregister
SoBumpMapElement_swigregister(SoBumpMapElement)
def SoBumpMapElement_getClassTypeId():
"""SoBumpMapElement_getClassTypeId() -> SoType"""
return _coin.SoBumpMapElement_getClassTypeId()
def SoBumpMapElement_getClassStackIndex():
"""SoBumpMapElement_getClassStackIndex() -> int"""
return _coin.SoBumpMapElement_getClassStackIndex()
def SoBumpMapElement_createInstance():
"""SoBumpMapElement_createInstance() -> void *"""
return _coin.SoBumpMapElement_createInstance()
def SoBumpMapElement_initClass():
"""SoBumpMapElement_initClass()"""
return _coin.SoBumpMapElement_initClass()
def SoBumpMapElement_set(state, node, image):
"""SoBumpMapElement_set(SoState state, SoNode node, SoGLImage image)"""
return _coin.SoBumpMapElement_set(state, node, image)
def SoBumpMapElement_get(state):
"""SoBumpMapElement_get(SoState state) -> SoGLImage"""
return _coin.SoBumpMapElement_get(state)
class SoBumpMapMatrixElement(SoAccumulatedElement):
"""Proxy of C++ SoBumpMapMatrixElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoBumpMapMatrixElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoBumpMapMatrixElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoBumpMapMatrixElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoBumpMapMatrixElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoBumpMapMatrixElement self, SoState state)"""
return _coin.SoBumpMapMatrixElement_init(self, state)
def push(self, state):
"""push(SoBumpMapMatrixElement self, SoState state)"""
return _coin.SoBumpMapMatrixElement_push(self, state)
def makeIdentity(state, node):
"""makeIdentity(SoState state, SoNode node)"""
return _coin.SoBumpMapMatrixElement_makeIdentity(state, node)
makeIdentity = staticmethod(makeIdentity)
def set(state, node):
"""set(SoState state, SoNode node)"""
return _coin.SoBumpMapMatrixElement_set(state, node)
set = staticmethod(set)
def mult(state, node):
"""mult(SoState state, SoNode node)"""
return _coin.SoBumpMapMatrixElement_mult(state, node)
mult = staticmethod(mult)
def translateBy(state, node, translation):
"""translateBy(SoState state, SoNode node, SbVec3f translation)"""
return _coin.SoBumpMapMatrixElement_translateBy(state, node, translation)
translateBy = staticmethod(translateBy)
def rotateBy(state, node, rotation):
"""rotateBy(SoState state, SoNode node, SbRotation rotation)"""
return _coin.SoBumpMapMatrixElement_rotateBy(state, node, rotation)
rotateBy = staticmethod(rotateBy)
def scaleBy(state, node, scaleFactor):
"""scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
return _coin.SoBumpMapMatrixElement_scaleBy(state, node, scaleFactor)
scaleBy = staticmethod(scaleBy)
def get(state):
"""get(SoState state) -> SbMatrix"""
return _coin.SoBumpMapMatrixElement_get(state)
get = staticmethod(get)
SoBumpMapMatrixElement_swigregister = _coin.SoBumpMapMatrixElement_swigregister
SoBumpMapMatrixElement_swigregister(SoBumpMapMatrixElement)
def SoBumpMapMatrixElement_getClassTypeId():
"""SoBumpMapMatrixElement_getClassTypeId() -> SoType"""
return _coin.SoBumpMapMatrixElement_getClassTypeId()
def SoBumpMapMatrixElement_getClassStackIndex():
"""SoBumpMapMatrixElement_getClassStackIndex() -> int"""
return _coin.SoBumpMapMatrixElement_getClassStackIndex()
def SoBumpMapMatrixElement_createInstance():
"""SoBumpMapMatrixElement_createInstance() -> void *"""
return _coin.SoBumpMapMatrixElement_createInstance()
def SoBumpMapMatrixElement_initClass():
"""SoBumpMapMatrixElement_initClass()"""
return _coin.SoBumpMapMatrixElement_initClass()
def SoBumpMapMatrixElement_makeIdentity(state, node):
"""SoBumpMapMatrixElement_makeIdentity(SoState state, SoNode node)"""
return _coin.SoBumpMapMatrixElement_makeIdentity(state, node)
def SoBumpMapMatrixElement_set(state, node):
"""SoBumpMapMatrixElement_set(SoState state, SoNode node)"""
return _coin.SoBumpMapMatrixElement_set(state, node)
def SoBumpMapMatrixElement_mult(state, node):
"""SoBumpMapMatrixElement_mult(SoState state, SoNode node)"""
return _coin.SoBumpMapMatrixElement_mult(state, node)
def SoBumpMapMatrixElement_translateBy(state, node, translation):
"""SoBumpMapMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
return _coin.SoBumpMapMatrixElement_translateBy(state, node, translation)
def SoBumpMapMatrixElement_rotateBy(state, node, rotation):
"""SoBumpMapMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
return _coin.SoBumpMapMatrixElement_rotateBy(state, node, rotation)
def SoBumpMapMatrixElement_scaleBy(state, node, scaleFactor):
"""SoBumpMapMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
return _coin.SoBumpMapMatrixElement_scaleBy(state, node, scaleFactor)
def SoBumpMapMatrixElement_get(state):
"""SoBumpMapMatrixElement_get(SoState state) -> SbMatrix"""
return _coin.SoBumpMapMatrixElement_get(state)
class SoCacheElement(SoElement):
"""Proxy of C++ SoCacheElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoCacheElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoCacheElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoCacheElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoCacheElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoCacheElement self, SoState state)"""
return _coin.SoCacheElement_init(self, state)
def push(self, state):
"""push(SoCacheElement self, SoState state)"""
return _coin.SoCacheElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoCacheElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoCacheElement_pop(self, state, prevTopElement)
def set(state, cache):
"""set(SoState state, SoCache cache)"""
return _coin.SoCacheElement_set(state, cache)
set = staticmethod(set)
def getCache(self):
"""getCache(SoCacheElement self) -> SoCache"""
return _coin.SoCacheElement_getCache(self)
def anyOpen(state):
"""anyOpen(SoState state) -> SbBool"""
return _coin.SoCacheElement_anyOpen(state)
anyOpen = staticmethod(anyOpen)
def invalidate(state):
"""invalidate(SoState state)"""
return _coin.SoCacheElement_invalidate(state)
invalidate = staticmethod(invalidate)
def matches(self, element):
"""matches(SoCacheElement self, SoElement element) -> SbBool"""
return _coin.SoCacheElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoCacheElement self) -> SoElement"""
return _coin.SoCacheElement_copyMatchInfo(self)
def getNextCacheElement(self):
"""getNextCacheElement(SoCacheElement self) -> SoCacheElement"""
return _coin.SoCacheElement_getNextCacheElement(self)
def addElement(state, element):
"""addElement(SoState state, SoElement element)"""
return _coin.SoCacheElement_addElement(state, element)
addElement = staticmethod(addElement)
def addCacheDependency(state, cache):
"""addCacheDependency(SoState state, SoCache cache)"""
return _coin.SoCacheElement_addCacheDependency(state, cache)
addCacheDependency = staticmethod(addCacheDependency)
def setInvalid(newvalue):
"""setInvalid(SbBool const newvalue) -> SbBool"""
return _coin.SoCacheElement_setInvalid(newvalue)
setInvalid = staticmethod(setInvalid)
def getCurrentCache(state):
"""getCurrentCache(SoState state) -> SoCache"""
return _coin.SoCacheElement_getCurrentCache(state)
getCurrentCache = staticmethod(getCurrentCache)
SoCacheElement_swigregister = _coin.SoCacheElement_swigregister
SoCacheElement_swigregister(SoCacheElement)
def SoCacheElement_getClassTypeId():
"""SoCacheElement_getClassTypeId() -> SoType"""
return _coin.SoCacheElement_getClassTypeId()
def SoCacheElement_getClassStackIndex():
"""SoCacheElement_getClassStackIndex() -> int"""
return _coin.SoCacheElement_getClassStackIndex()
def SoCacheElement_createInstance():
"""SoCacheElement_createInstance() -> void *"""
return _coin.SoCacheElement_createInstance()
def SoCacheElement_initClass():
"""SoCacheElement_initClass()"""
return _coin.SoCacheElement_initClass()
def SoCacheElement_set(state, cache):
"""SoCacheElement_set(SoState state, SoCache cache)"""
return _coin.SoCacheElement_set(state, cache)
def SoCacheElement_anyOpen(state):
"""SoCacheElement_anyOpen(SoState state) -> SbBool"""
return _coin.SoCacheElement_anyOpen(state)
def SoCacheElement_invalidate(state):
"""SoCacheElement_invalidate(SoState state)"""
return _coin.SoCacheElement_invalidate(state)
def SoCacheElement_addElement(state, element):
"""SoCacheElement_addElement(SoState state, SoElement element)"""
return _coin.SoCacheElement_addElement(state, element)
def SoCacheElement_addCacheDependency(state, cache):
"""SoCacheElement_addCacheDependency(SoState state, SoCache cache)"""
return _coin.SoCacheElement_addCacheDependency(state, cache)
def SoCacheElement_setInvalid(newvalue):
"""SoCacheElement_setInvalid(SbBool const newvalue) -> SbBool"""
return _coin.SoCacheElement_setInvalid(newvalue)
def SoCacheElement_getCurrentCache(state):
"""SoCacheElement_getCurrentCache(SoState state) -> SoCache"""
return _coin.SoCacheElement_getCurrentCache(state)
class SbPlane(object):
"""Proxy of C++ SbPlane class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(SbPlane self) -> SbPlane
__init__(SbPlane self, SbVec3f normal, float const D) -> SbPlane
__init__(SbPlane self, SbVec3f p0, SbVec3f p1, SbVec3f p2) -> SbPlane
__init__(SbPlane self, SbVec3f normal, SbVec3f point) -> SbPlane
"""
this = _coin.new_SbPlane(*args)
try:
self.this.append(this)
except Exception:
self.this = this
def offset(self, d):
"""offset(SbPlane self, float const d)"""
return _coin.SbPlane_offset(self, d)
def transform(self):
"""transform(SbPlane self)"""
return _coin.SbPlane_transform(self)
def isInHalfSpace(self, point):
"""isInHalfSpace(SbPlane self, SbVec3f point) -> SbBool"""
return _coin.SbPlane_isInHalfSpace(self, point)
def getDistance(self, point):
"""getDistance(SbPlane self, SbVec3f point) -> float"""
return _coin.SbPlane_getDistance(self, point)
def getNormal(self):
"""getNormal(SbPlane self) -> SbVec3f"""
return _coin.SbPlane_getNormal(self)
def getDistanceFromOrigin(self):
"""getDistanceFromOrigin(SbPlane self) -> float"""
return _coin.SbPlane_getDistanceFromOrigin(self)
def output(self, file):
"""output(SbPlane self, FILE * file)"""
return _coin.SbPlane_output(self, file)
def __eq__(self, u):
"""__eq__(SbPlane self, SbPlane u) -> int"""
return _coin.SbPlane___eq__(self, u)
def __ne__(self, u):
"""__ne__(SbPlane self, SbPlane u) -> int"""
return _coin.SbPlane___ne__(self, u)
def intersect(self, *args):
"""
intersect(SbPlane) -> SbLine
intersect(SbPlane) -> SbLine
"""
return _coin.SbPlane_intersect(self, *args)
__swig_destroy__ = _coin.delete_SbPlane
__del__ = lambda self: None
SbPlane_swigregister = _coin.SbPlane_swigregister
SbPlane_swigregister(SbPlane)
class SoClipPlaneElement(SoAccumulatedElement):
"""Proxy of C++ SoClipPlaneElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoClipPlaneElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoClipPlaneElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoClipPlaneElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoClipPlaneElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoClipPlaneElement self, SoState state)"""
return _coin.SoClipPlaneElement_init(self, state)
def push(self, state):
"""push(SoClipPlaneElement self, SoState state)"""
return _coin.SoClipPlaneElement_push(self, state)
def add(state, node, plane):
"""add(SoState state, SoNode node, SbPlane plane)"""
return _coin.SoClipPlaneElement_add(state, node, plane)
add = staticmethod(add)
def getInstance(state):
"""getInstance(SoState state) -> SoClipPlaneElement"""
return _coin.SoClipPlaneElement_getInstance(state)
getInstance = staticmethod(getInstance)
def getNum(self):
"""getNum(SoClipPlaneElement self) -> int"""
return _coin.SoClipPlaneElement_getNum(self)
def get(self, index, inworldspace=1):
"""
get(SoClipPlaneElement self, int const index, SbBool const inworldspace=1) -> SbPlane
get(SoClipPlaneElement self, int const index) -> SbPlane
"""
return _coin.SoClipPlaneElement_get(self, index, inworldspace)
SoClipPlaneElement_swigregister = _coin.SoClipPlaneElement_swigregister
SoClipPlaneElement_swigregister(SoClipPlaneElement)
def SoClipPlaneElement_getClassTypeId():
"""SoClipPlaneElement_getClassTypeId() -> SoType"""
return _coin.SoClipPlaneElement_getClassTypeId()
def SoClipPlaneElement_getClassStackIndex():
"""SoClipPlaneElement_getClassStackIndex() -> int"""
return _coin.SoClipPlaneElement_getClassStackIndex()
def SoClipPlaneElement_createInstance():
"""SoClipPlaneElement_createInstance() -> void *"""
return _coin.SoClipPlaneElement_createInstance()
def SoClipPlaneElement_initClass():
"""SoClipPlaneElement_initClass()"""
return _coin.SoClipPlaneElement_initClass()
def SoClipPlaneElement_add(state, node, plane):
"""SoClipPlaneElement_add(SoState state, SoNode node, SbPlane plane)"""
return _coin.SoClipPlaneElement_add(state, node, plane)
def SoClipPlaneElement_getInstance(state):
"""SoClipPlaneElement_getInstance(SoState state) -> SoClipPlaneElement"""
return _coin.SoClipPlaneElement_getInstance(state)
class SoFloatElement(SoElement):
"""Proxy of C++ SoFloatElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoFloatElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoFloatElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def initClass():
"""initClass()"""
return _coin.SoFloatElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoFloatElement self, SoState state)"""
return _coin.SoFloatElement_init(self, state)
def matches(self, element):
"""matches(SoFloatElement self, SoElement element) -> SbBool"""
return _coin.SoFloatElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoFloatElement self) -> SoElement"""
return _coin.SoFloatElement_copyMatchInfo(self)
def output(self, file):
"""output(SoFloatElement self, FILE * file)"""
return _coin.SoFloatElement_output(self, file)
def set(*args):
"""
set(int const stackIndex, SoState state, SoNode node, float const value)
set(int const stackIndex, SoState state, float const value)
"""
return _coin.SoFloatElement_set(*args)
set = staticmethod(set)
def get(stackIndex, state):
"""get(int const stackIndex, SoState state) -> float"""
return _coin.SoFloatElement_get(stackIndex, state)
get = staticmethod(get)
def setElt(self, value):
"""setElt(SoFloatElement self, float value)"""
return _coin.SoFloatElement_setElt(self, value)
SoFloatElement_swigregister = _coin.SoFloatElement_swigregister
SoFloatElement_swigregister(SoFloatElement)
def SoFloatElement_getClassTypeId():
"""SoFloatElement_getClassTypeId() -> SoType"""
return _coin.SoFloatElement_getClassTypeId()
def SoFloatElement_getClassStackIndex():
"""SoFloatElement_getClassStackIndex() -> int"""
return _coin.SoFloatElement_getClassStackIndex()
def SoFloatElement_initClass():
"""SoFloatElement_initClass()"""
return _coin.SoFloatElement_initClass()
def SoFloatElement_set(*args):
"""
set(int const stackIndex, SoState state, SoNode node, float const value)
SoFloatElement_set(int const stackIndex, SoState state, float const value)
"""
return _coin.SoFloatElement_set(*args)
def SoFloatElement_get(stackIndex, state):
"""SoFloatElement_get(int const stackIndex, SoState state) -> float"""
return _coin.SoFloatElement_get(stackIndex, state)
class SoComplexityElement(SoFloatElement):
"""Proxy of C++ SoComplexityElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoComplexityElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoComplexityElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoComplexityElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoComplexityElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoComplexityElement self, SoState state)"""
return _coin.SoComplexityElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, float const complexity)
set(SoState state, float const complexity)
"""
return _coin.SoComplexityElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> float"""
return _coin.SoComplexityElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> float"""
return _coin.SoComplexityElement_getDefault()
getDefault = staticmethod(getDefault)
SoComplexityElement_swigregister = _coin.SoComplexityElement_swigregister
SoComplexityElement_swigregister(SoComplexityElement)
def SoComplexityElement_getClassTypeId():
"""SoComplexityElement_getClassTypeId() -> SoType"""
return _coin.SoComplexityElement_getClassTypeId()
def SoComplexityElement_getClassStackIndex():
"""SoComplexityElement_getClassStackIndex() -> int"""
return _coin.SoComplexityElement_getClassStackIndex()
def SoComplexityElement_createInstance():
"""SoComplexityElement_createInstance() -> void *"""
return _coin.SoComplexityElement_createInstance()
def SoComplexityElement_initClass():
"""SoComplexityElement_initClass()"""
return _coin.SoComplexityElement_initClass()
def SoComplexityElement_set(*args):
"""
set(SoState state, SoNode node, float const complexity)
SoComplexityElement_set(SoState state, float const complexity)
"""
return _coin.SoComplexityElement_set(*args)
def SoComplexityElement_get(state):
"""SoComplexityElement_get(SoState state) -> float"""
return _coin.SoComplexityElement_get(state)
def SoComplexityElement_getDefault():
"""SoComplexityElement_getDefault() -> float"""
return _coin.SoComplexityElement_getDefault()
class SoCoordinateElement(SoReplacedElement):
"""Proxy of C++ SoCoordinateElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoCoordinateElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoCoordinateElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoCoordinateElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoCoordinateElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoCoordinateElement self, SoState state)"""
return _coin.SoCoordinateElement_init(self, state)
def set3(state, node, numCoords, coords):
"""set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
return _coin.SoCoordinateElement_set3(state, node, numCoords, coords)
set3 = staticmethod(set3)
def set4(state, node, numCoords, coords):
"""set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"""
return _coin.SoCoordinateElement_set4(state, node, numCoords, coords)
set4 = staticmethod(set4)
def getInstance(state):
"""getInstance(SoState state) -> SoCoordinateElement"""
return _coin.SoCoordinateElement_getInstance(state)
getInstance = staticmethod(getInstance)
def getNum(self):
"""getNum(SoCoordinateElement self) -> int32_t"""
return _coin.SoCoordinateElement_getNum(self)
def is3D(self):
"""is3D(SoCoordinateElement self) -> SbBool"""
return _coin.SoCoordinateElement_is3D(self)
def get3(self, index):
"""get3(SoCoordinateElement self, int const index) -> SbVec3f"""
return _coin.SoCoordinateElement_get3(self, index)
def get4(self, index):
"""get4(SoCoordinateElement self, int const index) -> SbVec4f"""
return _coin.SoCoordinateElement_get4(self, index)
def getArrayPtr3(self):
"""getArrayPtr3(SoCoordinateElement self) -> SbVec3f"""
return _coin.SoCoordinateElement_getArrayPtr3(self)
def getArrayPtr4(self):
"""getArrayPtr4(SoCoordinateElement self) -> SbVec4f"""
return _coin.SoCoordinateElement_getArrayPtr4(self)
def getDefault3():
"""getDefault3() -> SbVec3f"""
return _coin.SoCoordinateElement_getDefault3()
getDefault3 = staticmethod(getDefault3)
def getDefault4():
"""getDefault4() -> SbVec4f"""
return _coin.SoCoordinateElement_getDefault4()
getDefault4 = staticmethod(getDefault4)
def output(self, file):
"""output(SoCoordinateElement self, FILE * file)"""
return _coin.SoCoordinateElement_output(self, file)
SoCoordinateElement_swigregister = _coin.SoCoordinateElement_swigregister
SoCoordinateElement_swigregister(SoCoordinateElement)
def SoCoordinateElement_getClassTypeId():
"""SoCoordinateElement_getClassTypeId() -> SoType"""
return _coin.SoCoordinateElement_getClassTypeId()
def SoCoordinateElement_getClassStackIndex():
"""SoCoordinateElement_getClassStackIndex() -> int"""
return _coin.SoCoordinateElement_getClassStackIndex()
def SoCoordinateElement_createInstance():
"""SoCoordinateElement_createInstance() -> void *"""
return _coin.SoCoordinateElement_createInstance()
def SoCoordinateElement_initClass():
"""SoCoordinateElement_initClass()"""
return _coin.SoCoordinateElement_initClass()
def SoCoordinateElement_set3(state, node, numCoords, coords):
"""SoCoordinateElement_set3(SoState state, SoNode node, int32_t const numCoords, SbVec3f coords)"""
return _coin.SoCoordinateElement_set3(state, node, numCoords, coords)
def SoCoordinateElement_set4(state, node, numCoords, coords):
"""SoCoordinateElement_set4(SoState state, SoNode node, int32_t const numCoords, SbVec4f coords)"""
return _coin.SoCoordinateElement_set4(state, node, numCoords, coords)
def SoCoordinateElement_getInstance(state):
"""SoCoordinateElement_getInstance(SoState state) -> SoCoordinateElement"""
return _coin.SoCoordinateElement_getInstance(state)
def SoCoordinateElement_getDefault3():
"""SoCoordinateElement_getDefault3() -> SbVec3f"""
return _coin.SoCoordinateElement_getDefault3()
def SoCoordinateElement_getDefault4():
"""SoCoordinateElement_getDefault4() -> SbVec4f"""
return _coin.SoCoordinateElement_getDefault4()
class SoCreaseAngleElement(SoFloatElement):
"""Proxy of C++ SoCreaseAngleElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoCreaseAngleElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoCreaseAngleElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoCreaseAngleElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoCreaseAngleElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoCreaseAngleElement self, SoState state)"""
return _coin.SoCreaseAngleElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, float const complexity)
set(SoState state, float const complexity)
"""
return _coin.SoCreaseAngleElement_set(*args)
set = staticmethod(set)
def get(*args):
"""
get(SoState state) -> float
get(SoState state, SbBool const isvrml1) -> float
"""
return _coin.SoCreaseAngleElement_get(*args)
get = staticmethod(get)
def getDefault(*args):
"""
getDefault() -> float
getDefault(SbBool const isvrml1) -> float
"""
return _coin.SoCreaseAngleElement_getDefault(*args)
getDefault = staticmethod(getDefault)
SoCreaseAngleElement_swigregister = _coin.SoCreaseAngleElement_swigregister
SoCreaseAngleElement_swigregister(SoCreaseAngleElement)
def SoCreaseAngleElement_getClassTypeId():
"""SoCreaseAngleElement_getClassTypeId() -> SoType"""
return _coin.SoCreaseAngleElement_getClassTypeId()
def SoCreaseAngleElement_getClassStackIndex():
"""SoCreaseAngleElement_getClassStackIndex() -> int"""
return _coin.SoCreaseAngleElement_getClassStackIndex()
def SoCreaseAngleElement_createInstance():
"""SoCreaseAngleElement_createInstance() -> void *"""
return _coin.SoCreaseAngleElement_createInstance()
def SoCreaseAngleElement_initClass():
"""SoCreaseAngleElement_initClass()"""
return _coin.SoCreaseAngleElement_initClass()
def SoCreaseAngleElement_set(*args):
"""
set(SoState state, SoNode node, float const complexity)
SoCreaseAngleElement_set(SoState state, float const complexity)
"""
return _coin.SoCreaseAngleElement_set(*args)
def SoCreaseAngleElement_get(*args):
"""
get(SoState state) -> float
SoCreaseAngleElement_get(SoState state, SbBool const isvrml1) -> float
"""
return _coin.SoCreaseAngleElement_get(*args)
def SoCreaseAngleElement_getDefault(*args):
"""
getDefault() -> float
SoCreaseAngleElement_getDefault(SbBool const isvrml1) -> float
"""
return _coin.SoCreaseAngleElement_getDefault(*args)
class SoCullElement(SoElement):
"""Proxy of C++ SoCullElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoCullElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoCullElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoCullElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoCullElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoCullElement self, SoState state)"""
return _coin.SoCullElement_init(self, state)
def push(self, state):
"""push(SoCullElement self, SoState state)"""
return _coin.SoCullElement_push(self, state)
def setViewVolume(state, vv):
"""setViewVolume(SoState state, SbViewVolume vv)"""
return _coin.SoCullElement_setViewVolume(state, vv)
setViewVolume = staticmethod(setViewVolume)
def addPlane(state, newplane):
"""addPlane(SoState state, SbPlane newplane)"""
return _coin.SoCullElement_addPlane(state, newplane)
addPlane = staticmethod(addPlane)
def cullBox(state, box, transform=1):
"""
cullBox(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool
cullBox(SoState state, SbBox3f box) -> SbBool
"""
return _coin.SoCullElement_cullBox(state, box, transform)
cullBox = staticmethod(cullBox)
def cullTest(state, box, transform=1):
"""
cullTest(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool
cullTest(SoState state, SbBox3f box) -> SbBool
"""
return _coin.SoCullElement_cullTest(state, box, transform)
cullTest = staticmethod(cullTest)
def completelyInside(state):
"""completelyInside(SoState state) -> SbBool"""
return _coin.SoCullElement_completelyInside(state)
completelyInside = staticmethod(completelyInside)
def matches(self, elt):
"""matches(SoCullElement self, SoElement elt) -> SbBool"""
return _coin.SoCullElement_matches(self, elt)
def copyMatchInfo(self):
"""copyMatchInfo(SoCullElement self) -> SoElement"""
return _coin.SoCullElement_copyMatchInfo(self)
SoCullElement_swigregister = _coin.SoCullElement_swigregister
SoCullElement_swigregister(SoCullElement)
def SoCullElement_getClassTypeId():
"""SoCullElement_getClassTypeId() -> SoType"""
return _coin.SoCullElement_getClassTypeId()
def SoCullElement_getClassStackIndex():
"""SoCullElement_getClassStackIndex() -> int"""
return _coin.SoCullElement_getClassStackIndex()
def SoCullElement_createInstance():
"""SoCullElement_createInstance() -> void *"""
return _coin.SoCullElement_createInstance()
def SoCullElement_initClass():
"""SoCullElement_initClass()"""
return _coin.SoCullElement_initClass()
def SoCullElement_setViewVolume(state, vv):
"""SoCullElement_setViewVolume(SoState state, SbViewVolume vv)"""
return _coin.SoCullElement_setViewVolume(state, vv)
def SoCullElement_addPlane(state, newplane):
"""SoCullElement_addPlane(SoState state, SbPlane newplane)"""
return _coin.SoCullElement_addPlane(state, newplane)
def SoCullElement_cullBox(state, box, transform=1):
"""
cullBox(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool
SoCullElement_cullBox(SoState state, SbBox3f box) -> SbBool
"""
return _coin.SoCullElement_cullBox(state, box, transform)
def SoCullElement_cullTest(state, box, transform=1):
"""
cullTest(SoState state, SbBox3f box, SbBool const transform=1) -> SbBool
SoCullElement_cullTest(SoState state, SbBox3f box) -> SbBool
"""
return _coin.SoCullElement_cullTest(state, box, transform)
def SoCullElement_completelyInside(state):
"""SoCullElement_completelyInside(SoState state) -> SbBool"""
return _coin.SoCullElement_completelyInside(state)
class SoDecimationPercentageElement(SoFloatElement):
"""Proxy of C++ SoDecimationPercentageElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoDecimationPercentageElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoDecimationPercentageElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoDecimationPercentageElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoDecimationPercentageElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoDecimationPercentageElement self, SoState state)"""
return _coin.SoDecimationPercentageElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, float const complexity)
set(SoState state, float const complexity)
"""
return _coin.SoDecimationPercentageElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> float"""
return _coin.SoDecimationPercentageElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> float"""
return _coin.SoDecimationPercentageElement_getDefault()
getDefault = staticmethod(getDefault)
SoDecimationPercentageElement_swigregister = _coin.SoDecimationPercentageElement_swigregister
SoDecimationPercentageElement_swigregister(SoDecimationPercentageElement)
def SoDecimationPercentageElement_getClassTypeId():
"""SoDecimationPercentageElement_getClassTypeId() -> SoType"""
return _coin.SoDecimationPercentageElement_getClassTypeId()
def SoDecimationPercentageElement_getClassStackIndex():
"""SoDecimationPercentageElement_getClassStackIndex() -> int"""
return _coin.SoDecimationPercentageElement_getClassStackIndex()
def SoDecimationPercentageElement_createInstance():
"""SoDecimationPercentageElement_createInstance() -> void *"""
return _coin.SoDecimationPercentageElement_createInstance()
def SoDecimationPercentageElement_initClass():
"""SoDecimationPercentageElement_initClass()"""
return _coin.SoDecimationPercentageElement_initClass()
def SoDecimationPercentageElement_set(*args):
"""
set(SoState state, SoNode node, float const complexity)
SoDecimationPercentageElement_set(SoState state, float const complexity)
"""
return _coin.SoDecimationPercentageElement_set(*args)
def SoDecimationPercentageElement_get(state):
"""SoDecimationPercentageElement_get(SoState state) -> float"""
return _coin.SoDecimationPercentageElement_get(state)
def SoDecimationPercentageElement_getDefault():
"""SoDecimationPercentageElement_getDefault() -> float"""
return _coin.SoDecimationPercentageElement_getDefault()
class SoDiffuseColorElement(SoReplacedElement):
"""Proxy of C++ SoDiffuseColorElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoDiffuseColorElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoDiffuseColorElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoDiffuseColorElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoDiffuseColorElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoDiffuseColorElement self, SoState state)"""
return _coin.SoDiffuseColorElement_init(self, state)
def set(state, node, numcolors, colors):
"""set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
return _coin.SoDiffuseColorElement_set(state, node, numcolors, colors)
set = staticmethod(set)
def getInstance(state):
"""getInstance(SoState state) -> SoDiffuseColorElement"""
return _coin.SoDiffuseColorElement_getInstance(state)
getInstance = staticmethod(getInstance)
def getNum(self):
"""getNum(SoDiffuseColorElement self) -> int32_t"""
return _coin.SoDiffuseColorElement_getNum(self)
def get(self, index):
"""get(SoDiffuseColorElement self, int const index) -> SbColor"""
return _coin.SoDiffuseColorElement_get(self, index)
def isPacked(self):
"""isPacked(SoDiffuseColorElement self) -> SbBool"""
return _coin.SoDiffuseColorElement_isPacked(self)
def hasPackedTransparency(self):
"""hasPackedTransparency(SoDiffuseColorElement self) -> SbBool"""
return _coin.SoDiffuseColorElement_hasPackedTransparency(self)
def getColorArrayPtr(self):
"""getColorArrayPtr(SoDiffuseColorElement self) -> SbColor"""
return _coin.SoDiffuseColorElement_getColorArrayPtr(self)
def getPackedArrayPtr(self):
"""getPackedArrayPtr(SoDiffuseColorElement self) -> uint32_t const *"""
return _coin.SoDiffuseColorElement_getPackedArrayPtr(self)
SoDiffuseColorElement_swigregister = _coin.SoDiffuseColorElement_swigregister
SoDiffuseColorElement_swigregister(SoDiffuseColorElement)
def SoDiffuseColorElement_getClassTypeId():
"""SoDiffuseColorElement_getClassTypeId() -> SoType"""
return _coin.SoDiffuseColorElement_getClassTypeId()
def SoDiffuseColorElement_getClassStackIndex():
"""SoDiffuseColorElement_getClassStackIndex() -> int"""
return _coin.SoDiffuseColorElement_getClassStackIndex()
def SoDiffuseColorElement_createInstance():
"""SoDiffuseColorElement_createInstance() -> void *"""
return _coin.SoDiffuseColorElement_createInstance()
def SoDiffuseColorElement_initClass():
"""SoDiffuseColorElement_initClass()"""
return _coin.SoDiffuseColorElement_initClass()
def SoDiffuseColorElement_set(state, node, numcolors, colors):
"""SoDiffuseColorElement_set(SoState state, SoNode node, int32_t const numcolors, SbColor colors)"""
return _coin.SoDiffuseColorElement_set(state, node, numcolors, colors)
def SoDiffuseColorElement_getInstance(state):
"""SoDiffuseColorElement_getInstance(SoState state) -> SoDiffuseColorElement"""
return _coin.SoDiffuseColorElement_getInstance(state)
class SoGLClipPlaneElement(SoClipPlaneElement):
"""Proxy of C++ SoGLClipPlaneElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLClipPlaneElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLClipPlaneElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLClipPlaneElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLClipPlaneElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLClipPlaneElement self, SoState state)"""
return _coin.SoGLClipPlaneElement_init(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLClipPlaneElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLClipPlaneElement_pop(self, state, prevTopElement)
def getMaxGLPlanes():
"""getMaxGLPlanes() -> int"""
return _coin.SoGLClipPlaneElement_getMaxGLPlanes()
getMaxGLPlanes = staticmethod(getMaxGLPlanes)
SoGLClipPlaneElement_swigregister = _coin.SoGLClipPlaneElement_swigregister
SoGLClipPlaneElement_swigregister(SoGLClipPlaneElement)
def SoGLClipPlaneElement_getClassTypeId():
"""SoGLClipPlaneElement_getClassTypeId() -> SoType"""
return _coin.SoGLClipPlaneElement_getClassTypeId()
def SoGLClipPlaneElement_getClassStackIndex():
"""SoGLClipPlaneElement_getClassStackIndex() -> int"""
return _coin.SoGLClipPlaneElement_getClassStackIndex()
def SoGLClipPlaneElement_createInstance():
"""SoGLClipPlaneElement_createInstance() -> void *"""
return _coin.SoGLClipPlaneElement_createInstance()
def SoGLClipPlaneElement_initClass():
"""SoGLClipPlaneElement_initClass()"""
return _coin.SoGLClipPlaneElement_initClass()
def SoGLClipPlaneElement_getMaxGLPlanes():
"""SoGLClipPlaneElement_getMaxGLPlanes() -> int"""
return _coin.SoGLClipPlaneElement_getMaxGLPlanes()
class SoLightElement(SoAccumulatedElement):
"""Proxy of C++ SoLightElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoLightElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoLightElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoLightElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoLightElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoLightElement self, SoState state)"""
return _coin.SoLightElement_init(self, state)
def push(self, state):
"""push(SoLightElement self, SoState state)"""
return _coin.SoLightElement_push(self, state)
def add(state, light):
"""add(SoState state, SoLight light)"""
return _coin.SoLightElement_add(state, light)
add = staticmethod(add)
def getLights(state):
"""getLights(SoState state) -> SoNodeList"""
return _coin.SoLightElement_getLights(state)
getLights = staticmethod(getLights)
def getMatrix(state, index):
"""getMatrix(SoState state, int const index) -> SbMatrix"""
return _coin.SoLightElement_getMatrix(state, index)
getMatrix = staticmethod(getMatrix)
SoLightElement_swigregister = _coin.SoLightElement_swigregister
SoLightElement_swigregister(SoLightElement)
def SoLightElement_getClassTypeId():
"""SoLightElement_getClassTypeId() -> SoType"""
return _coin.SoLightElement_getClassTypeId()
def SoLightElement_getClassStackIndex():
"""SoLightElement_getClassStackIndex() -> int"""
return _coin.SoLightElement_getClassStackIndex()
def SoLightElement_createInstance():
"""SoLightElement_createInstance() -> void *"""
return _coin.SoLightElement_createInstance()
def SoLightElement_initClass():
"""SoLightElement_initClass()"""
return _coin.SoLightElement_initClass()
def SoLightElement_add(state, light):
"""SoLightElement_add(SoState state, SoLight light)"""
return _coin.SoLightElement_add(state, light)
def SoLightElement_getLights(state):
"""SoLightElement_getLights(SoState state) -> SoNodeList"""
return _coin.SoLightElement_getLights(state)
def SoLightElement_getMatrix(state, index):
"""SoLightElement_getMatrix(SoState state, int const index) -> SbMatrix"""
return _coin.SoLightElement_getMatrix(state, index)
class SoGLModelMatrixElement(SoModelMatrixElement):
"""Proxy of C++ SoGLModelMatrixElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLModelMatrixElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLModelMatrixElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLModelMatrixElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLModelMatrixElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLModelMatrixElement self, SoState state)"""
return _coin.SoGLModelMatrixElement_init(self, state)
def push(self, state):
"""push(SoGLModelMatrixElement self, SoState state)"""
return _coin.SoGLModelMatrixElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLModelMatrixElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLModelMatrixElement_pop(self, state, prevTopElement)
SoGLModelMatrixElement_swigregister = _coin.SoGLModelMatrixElement_swigregister
SoGLModelMatrixElement_swigregister(SoGLModelMatrixElement)
def SoGLModelMatrixElement_getClassTypeId():
"""SoGLModelMatrixElement_getClassTypeId() -> SoType"""
return _coin.SoGLModelMatrixElement_getClassTypeId()
def SoGLModelMatrixElement_getClassStackIndex():
"""SoGLModelMatrixElement_getClassStackIndex() -> int"""
return _coin.SoGLModelMatrixElement_getClassStackIndex()
def SoGLModelMatrixElement_createInstance():
"""SoGLModelMatrixElement_createInstance() -> void *"""
return _coin.SoGLModelMatrixElement_createInstance()
def SoGLModelMatrixElement_initClass():
"""SoGLModelMatrixElement_initClass()"""
return _coin.SoGLModelMatrixElement_initClass()
class SoProfileElement(SoAccumulatedElement):
"""Proxy of C++ SoProfileElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoProfileElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoProfileElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoProfileElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoProfileElement_initClass()
initClass = staticmethod(initClass)
START_FIRST = _coin.SoProfileElement_START_FIRST
START_NEW = _coin.SoProfileElement_START_NEW
ADD_TO_CURRENT = _coin.SoProfileElement_ADD_TO_CURRENT
def init(self, state):
"""init(SoProfileElement self, SoState state)"""
return _coin.SoProfileElement_init(self, state)
def push(self, state):
"""push(SoProfileElement self, SoState state)"""
return _coin.SoProfileElement_push(self, state)
def add(state, profile):
"""add(SoState state, SoProfile profile)"""
return _coin.SoProfileElement_add(state, profile)
add = staticmethod(add)
def get(state):
"""get(SoState state) -> SoNodeList"""
return _coin.SoProfileElement_get(state)
get = staticmethod(get)
SoProfileElement_swigregister = _coin.SoProfileElement_swigregister
SoProfileElement_swigregister(SoProfileElement)
def SoProfileElement_getClassTypeId():
"""SoProfileElement_getClassTypeId() -> SoType"""
return _coin.SoProfileElement_getClassTypeId()
def SoProfileElement_getClassStackIndex():
"""SoProfileElement_getClassStackIndex() -> int"""
return _coin.SoProfileElement_getClassStackIndex()
def SoProfileElement_createInstance():
"""SoProfileElement_createInstance() -> void *"""
return _coin.SoProfileElement_createInstance()
def SoProfileElement_initClass():
"""SoProfileElement_initClass()"""
return _coin.SoProfileElement_initClass()
def SoProfileElement_add(state, profile):
"""SoProfileElement_add(SoState state, SoProfile profile)"""
return _coin.SoProfileElement_add(state, profile)
def SoProfileElement_get(state):
"""SoProfileElement_get(SoState state) -> SoNodeList"""
return _coin.SoProfileElement_get(state)
class SoMultiTextureMatrixElement(SoAccumulatedElement):
"""Proxy of C++ SoMultiTextureMatrixElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoMultiTextureMatrixElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoMultiTextureMatrixElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoMultiTextureMatrixElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoMultiTextureMatrixElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoMultiTextureMatrixElement self, SoState state)"""
return _coin.SoMultiTextureMatrixElement_init(self, state)
def push(self, state):
"""push(SoMultiTextureMatrixElement self, SoState state)"""
return _coin.SoMultiTextureMatrixElement_push(self, state)
def get(state, unit=0):
"""
get(SoState state, int const unit=0) -> SbMatrix
get(SoState state) -> SbMatrix
"""
return _coin.SoMultiTextureMatrixElement_get(state, unit)
get = staticmethod(get)
def makeIdentity(state, node, unit=0):
"""
makeIdentity(SoState state, SoNode node, int const unit=0)
makeIdentity(SoState state, SoNode node)
"""
return _coin.SoMultiTextureMatrixElement_makeIdentity(state, node, unit)
makeIdentity = staticmethod(makeIdentity)
def set(*args):
"""
set(SoState state, SoNode node, int const unit)
set(SoState state, SoNode node)
"""
return _coin.SoMultiTextureMatrixElement_set(*args)
set = staticmethod(set)
def mult(*args):
"""
mult(SoState state, SoNode node, int const unit)
mult(SoState state, SoNode node)
"""
return _coin.SoMultiTextureMatrixElement_mult(*args)
mult = staticmethod(mult)
def translateBy(state, node, translation):
"""translateBy(SoState state, SoNode node, SbVec3f translation)"""
return _coin.SoMultiTextureMatrixElement_translateBy(state, node, translation)
translateBy = staticmethod(translateBy)
def rotateBy(state, node, rotation):
"""rotateBy(SoState state, SoNode node, SbRotation rotation)"""
return _coin.SoMultiTextureMatrixElement_rotateBy(state, node, rotation)
rotateBy = staticmethod(rotateBy)
def scaleBy(state, node, scaleFactor):
"""scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
return _coin.SoMultiTextureMatrixElement_scaleBy(state, node, scaleFactor)
scaleBy = staticmethod(scaleBy)
SoMultiTextureMatrixElement_swigregister = _coin.SoMultiTextureMatrixElement_swigregister
SoMultiTextureMatrixElement_swigregister(SoMultiTextureMatrixElement)
def SoMultiTextureMatrixElement_getClassTypeId():
"""SoMultiTextureMatrixElement_getClassTypeId() -> SoType"""
return _coin.SoMultiTextureMatrixElement_getClassTypeId()
def SoMultiTextureMatrixElement_getClassStackIndex():
"""SoMultiTextureMatrixElement_getClassStackIndex() -> int"""
return _coin.SoMultiTextureMatrixElement_getClassStackIndex()
def SoMultiTextureMatrixElement_createInstance():
"""SoMultiTextureMatrixElement_createInstance() -> void *"""
return _coin.SoMultiTextureMatrixElement_createInstance()
def SoMultiTextureMatrixElement_initClass():
"""SoMultiTextureMatrixElement_initClass()"""
return _coin.SoMultiTextureMatrixElement_initClass()
def SoMultiTextureMatrixElement_get(state, unit=0):
"""
get(SoState state, int const unit=0) -> SbMatrix
SoMultiTextureMatrixElement_get(SoState state) -> SbMatrix
"""
return _coin.SoMultiTextureMatrixElement_get(state, unit)
def SoMultiTextureMatrixElement_makeIdentity(state, node, unit=0):
"""
makeIdentity(SoState state, SoNode node, int const unit=0)
SoMultiTextureMatrixElement_makeIdentity(SoState state, SoNode node)
"""
return _coin.SoMultiTextureMatrixElement_makeIdentity(state, node, unit)
def SoMultiTextureMatrixElement_set(*args):
"""
set(SoState state, SoNode node, int const unit)
SoMultiTextureMatrixElement_set(SoState state, SoNode node)
"""
return _coin.SoMultiTextureMatrixElement_set(*args)
def SoMultiTextureMatrixElement_mult(*args):
"""
mult(SoState state, SoNode node, int const unit)
SoMultiTextureMatrixElement_mult(SoState state, SoNode node)
"""
return _coin.SoMultiTextureMatrixElement_mult(*args)
def SoMultiTextureMatrixElement_translateBy(state, node, translation):
"""SoMultiTextureMatrixElement_translateBy(SoState state, SoNode node, SbVec3f translation)"""
return _coin.SoMultiTextureMatrixElement_translateBy(state, node, translation)
def SoMultiTextureMatrixElement_rotateBy(state, node, rotation):
"""SoMultiTextureMatrixElement_rotateBy(SoState state, SoNode node, SbRotation rotation)"""
return _coin.SoMultiTextureMatrixElement_rotateBy(state, node, rotation)
def SoMultiTextureMatrixElement_scaleBy(state, node, scaleFactor):
"""SoMultiTextureMatrixElement_scaleBy(SoState state, SoNode node, SbVec3f scaleFactor)"""
return _coin.SoMultiTextureMatrixElement_scaleBy(state, node, scaleFactor)
class SoGLMultiTextureMatrixElement(SoMultiTextureMatrixElement):
"""Proxy of C++ SoGLMultiTextureMatrixElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLMultiTextureMatrixElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLMultiTextureMatrixElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLMultiTextureMatrixElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLMultiTextureMatrixElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLMultiTextureMatrixElement self, SoState state)"""
return _coin.SoGLMultiTextureMatrixElement_init(self, state)
def push(self, state):
"""push(SoGLMultiTextureMatrixElement self, SoState state)"""
return _coin.SoGLMultiTextureMatrixElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLMultiTextureMatrixElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLMultiTextureMatrixElement_pop(self, state, prevTopElement)
def multElt(self, unit):
"""multElt(SoGLMultiTextureMatrixElement self, int const unit)"""
return _coin.SoGLMultiTextureMatrixElement_multElt(self, unit)
def setElt(self, unit):
"""setElt(SoGLMultiTextureMatrixElement self, int const unit)"""
return _coin.SoGLMultiTextureMatrixElement_setElt(self, unit)
SoGLMultiTextureMatrixElement_swigregister = _coin.SoGLMultiTextureMatrixElement_swigregister
SoGLMultiTextureMatrixElement_swigregister(SoGLMultiTextureMatrixElement)
def SoGLMultiTextureMatrixElement_getClassTypeId():
"""SoGLMultiTextureMatrixElement_getClassTypeId() -> SoType"""
return _coin.SoGLMultiTextureMatrixElement_getClassTypeId()
def SoGLMultiTextureMatrixElement_getClassStackIndex():
"""SoGLMultiTextureMatrixElement_getClassStackIndex() -> int"""
return _coin.SoGLMultiTextureMatrixElement_getClassStackIndex()
def SoGLMultiTextureMatrixElement_createInstance():
"""SoGLMultiTextureMatrixElement_createInstance() -> void *"""
return _coin.SoGLMultiTextureMatrixElement_createInstance()
def SoGLMultiTextureMatrixElement_initClass():
"""SoGLMultiTextureMatrixElement_initClass()"""
return _coin.SoGLMultiTextureMatrixElement_initClass()
class SoGLDrawStyleElement(SoDrawStyleElement):
"""Proxy of C++ SoGLDrawStyleElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLDrawStyleElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLDrawStyleElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLDrawStyleElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLDrawStyleElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLDrawStyleElement self, SoState state)"""
return _coin.SoGLDrawStyleElement_init(self, state)
def push(self, state):
"""push(SoGLDrawStyleElement self, SoState state)"""
return _coin.SoGLDrawStyleElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLDrawStyleElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLDrawStyleElement_pop(self, state, prevTopElement)
SoGLDrawStyleElement_swigregister = _coin.SoGLDrawStyleElement_swigregister
SoGLDrawStyleElement_swigregister(SoGLDrawStyleElement)
def SoGLDrawStyleElement_getClassTypeId():
"""SoGLDrawStyleElement_getClassTypeId() -> SoType"""
return _coin.SoGLDrawStyleElement_getClassTypeId()
def SoGLDrawStyleElement_getClassStackIndex():
"""SoGLDrawStyleElement_getClassStackIndex() -> int"""
return _coin.SoGLDrawStyleElement_getClassStackIndex()
def SoGLDrawStyleElement_createInstance():
"""SoGLDrawStyleElement_createInstance() -> void *"""
return _coin.SoGLDrawStyleElement_createInstance()
def SoGLDrawStyleElement_initClass():
"""SoGLDrawStyleElement_initClass()"""
return _coin.SoGLDrawStyleElement_initClass()
class SoGLLightIdElement(SoInt32Element):
"""Proxy of C++ SoGLLightIdElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLLightIdElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLLightIdElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLLightIdElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLLightIdElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLLightIdElement self, SoState state)"""
return _coin.SoGLLightIdElement_init(self, state)
def push(self, state):
"""push(SoGLLightIdElement self, SoState state)"""
return _coin.SoGLLightIdElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLLightIdElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLLightIdElement_pop(self, state, prevTopElement)
def increment(*args):
"""
increment(SoState state, SoNode node) -> int32_t
increment(SoState state) -> int32_t
"""
return _coin.SoGLLightIdElement_increment(*args)
increment = staticmethod(increment)
def get(state):
"""get(SoState state) -> int32_t"""
return _coin.SoGLLightIdElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> int32_t"""
return _coin.SoGLLightIdElement_getDefault()
getDefault = staticmethod(getDefault)
def getMaxGLSources():
"""getMaxGLSources() -> int32_t"""
return _coin.SoGLLightIdElement_getMaxGLSources()
getMaxGLSources = staticmethod(getMaxGLSources)
SoGLLightIdElement_swigregister = _coin.SoGLLightIdElement_swigregister
SoGLLightIdElement_swigregister(SoGLLightIdElement)
def SoGLLightIdElement_getClassTypeId():
"""SoGLLightIdElement_getClassTypeId() -> SoType"""
return _coin.SoGLLightIdElement_getClassTypeId()
def SoGLLightIdElement_getClassStackIndex():
"""SoGLLightIdElement_getClassStackIndex() -> int"""
return _coin.SoGLLightIdElement_getClassStackIndex()
def SoGLLightIdElement_createInstance():
"""SoGLLightIdElement_createInstance() -> void *"""
return _coin.SoGLLightIdElement_createInstance()
def SoGLLightIdElement_initClass():
"""SoGLLightIdElement_initClass()"""
return _coin.SoGLLightIdElement_initClass()
def SoGLLightIdElement_increment(*args):
"""
increment(SoState state, SoNode node) -> int32_t
SoGLLightIdElement_increment(SoState state) -> int32_t
"""
return _coin.SoGLLightIdElement_increment(*args)
def SoGLLightIdElement_get(state):
"""SoGLLightIdElement_get(SoState state) -> int32_t"""
return _coin.SoGLLightIdElement_get(state)
def SoGLLightIdElement_getDefault():
"""SoGLLightIdElement_getDefault() -> int32_t"""
return _coin.SoGLLightIdElement_getDefault()
def SoGLLightIdElement_getMaxGLSources():
"""SoGLLightIdElement_getMaxGLSources() -> int32_t"""
return _coin.SoGLLightIdElement_getMaxGLSources()
class SoMultiTextureEnabledElement(SoElement):
"""Proxy of C++ SoMultiTextureEnabledElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoMultiTextureEnabledElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoMultiTextureEnabledElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoMultiTextureEnabledElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoMultiTextureEnabledElement_initClass()
initClass = staticmethod(initClass)
DISABLED = _coin.SoMultiTextureEnabledElement_DISABLED
TEXTURE2D = _coin.SoMultiTextureEnabledElement_TEXTURE2D
RECTANGLE = _coin.SoMultiTextureEnabledElement_RECTANGLE
CUBEMAP = _coin.SoMultiTextureEnabledElement_CUBEMAP
TEXTURE3D = _coin.SoMultiTextureEnabledElement_TEXTURE3D
def init(self, state):
"""init(SoMultiTextureEnabledElement self, SoState state)"""
return _coin.SoMultiTextureEnabledElement_init(self, state)
def get(state, unit=0):
"""
get(SoState state, int const unit=0) -> SbBool
get(SoState state) -> SbBool
"""
return _coin.SoMultiTextureEnabledElement_get(state, unit)
get = staticmethod(get)
def setElt(self, unit, mode):
"""setElt(SoMultiTextureEnabledElement self, int const unit, int const mode)"""
return _coin.SoMultiTextureEnabledElement_setElt(self, unit, mode)
def push(self, state):
"""push(SoMultiTextureEnabledElement self, SoState state)"""
return _coin.SoMultiTextureEnabledElement_push(self, state)
def matches(self, elem):
"""matches(SoMultiTextureEnabledElement self, SoElement elem) -> SbBool"""
return _coin.SoMultiTextureEnabledElement_matches(self, elem)
def copyMatchInfo(self):
"""copyMatchInfo(SoMultiTextureEnabledElement self) -> SoElement"""
return _coin.SoMultiTextureEnabledElement_copyMatchInfo(self)
def getEnabledUnits(state, lastenabled):
"""getEnabledUnits(SoState state, int & lastenabled) -> SbBool const *"""
return _coin.SoMultiTextureEnabledElement_getEnabledUnits(state, lastenabled)
getEnabledUnits = staticmethod(getEnabledUnits)
def getActiveUnits(state, lastenabled):
"""getActiveUnits(SoState state, int & lastenabled) -> SoMultiTextureEnabledElement::Mode const *"""
return _coin.SoMultiTextureEnabledElement_getActiveUnits(state, lastenabled)
getActiveUnits = staticmethod(getActiveUnits)
def enableRectangle(state, node, unit=0):
"""
enableRectangle(SoState state, SoNode node, int const unit=0)
enableRectangle(SoState state, SoNode node)
"""
return _coin.SoMultiTextureEnabledElement_enableRectangle(state, node, unit)
enableRectangle = staticmethod(enableRectangle)
def enableCubeMap(state, node, unit=0):
"""
enableCubeMap(SoState state, SoNode node, int const unit=0)
enableCubeMap(SoState state, SoNode node)
"""
return _coin.SoMultiTextureEnabledElement_enableCubeMap(state, node, unit)
enableCubeMap = staticmethod(enableCubeMap)
def enableTexture3(state, node, unit=0):
"""
enableTexture3(SoState state, SoNode node, int const unit=0)
enableTexture3(SoState state, SoNode node)
"""
return _coin.SoMultiTextureEnabledElement_enableTexture3(state, node, unit)
enableTexture3 = staticmethod(enableTexture3)
def getMode(state, unit=0):
"""
getMode(SoState state, int const unit=0) -> SoMultiTextureEnabledElement::Mode
getMode(SoState state) -> SoMultiTextureEnabledElement::Mode
"""
return _coin.SoMultiTextureEnabledElement_getMode(state, unit)
getMode = staticmethod(getMode)
def disableAll(state):
"""disableAll(SoState state)"""
return _coin.SoMultiTextureEnabledElement_disableAll(state)
disableAll = staticmethod(disableAll)
def set(*args):
"""
set(SoState state, SoNode node, int const unit, SbBool const enabled)
set(SoState state, SbBool const enabled)
set(SoState state, SoNode node, SbBool const enabled)
"""
return _coin.SoMultiTextureEnabledElement_set(*args)
set = staticmethod(set)
SoMultiTextureEnabledElement_swigregister = _coin.SoMultiTextureEnabledElement_swigregister
SoMultiTextureEnabledElement_swigregister(SoMultiTextureEnabledElement)
def SoMultiTextureEnabledElement_getClassTypeId():
"""SoMultiTextureEnabledElement_getClassTypeId() -> SoType"""
return _coin.SoMultiTextureEnabledElement_getClassTypeId()
def SoMultiTextureEnabledElement_getClassStackIndex():
"""SoMultiTextureEnabledElement_getClassStackIndex() -> int"""
return _coin.SoMultiTextureEnabledElement_getClassStackIndex()
def SoMultiTextureEnabledElement_createInstance():
"""SoMultiTextureEnabledElement_createInstance() -> void *"""
return _coin.SoMultiTextureEnabledElement_createInstance()
def SoMultiTextureEnabledElement_initClass():
"""SoMultiTextureEnabledElement_initClass()"""
return _coin.SoMultiTextureEnabledElement_initClass()
def SoMultiTextureEnabledElement_get(state, unit=0):
"""
get(SoState state, int const unit=0) -> SbBool
SoMultiTextureEnabledElement_get(SoState state) -> SbBool
"""
return _coin.SoMultiTextureEnabledElement_get(state, unit)
def SoMultiTextureEnabledElement_getEnabledUnits(state, lastenabled):
"""SoMultiTextureEnabledElement_getEnabledUnits(SoState state, int & lastenabled) -> SbBool const *"""
return _coin.SoMultiTextureEnabledElement_getEnabledUnits(state, lastenabled)
def SoMultiTextureEnabledElement_getActiveUnits(state, lastenabled):
"""SoMultiTextureEnabledElement_getActiveUnits(SoState state, int & lastenabled) -> SoMultiTextureEnabledElement::Mode const *"""
return _coin.SoMultiTextureEnabledElement_getActiveUnits(state, lastenabled)
def SoMultiTextureEnabledElement_enableRectangle(state, node, unit=0):
"""
enableRectangle(SoState state, SoNode node, int const unit=0)
SoMultiTextureEnabledElement_enableRectangle(SoState state, SoNode node)
"""
return _coin.SoMultiTextureEnabledElement_enableRectangle(state, node, unit)
def SoMultiTextureEnabledElement_enableCubeMap(state, node, unit=0):
"""
enableCubeMap(SoState state, SoNode node, int const unit=0)
SoMultiTextureEnabledElement_enableCubeMap(SoState state, SoNode node)
"""
return _coin.SoMultiTextureEnabledElement_enableCubeMap(state, node, unit)
def SoMultiTextureEnabledElement_enableTexture3(state, node, unit=0):
"""
enableTexture3(SoState state, SoNode node, int const unit=0)
SoMultiTextureEnabledElement_enableTexture3(SoState state, SoNode node)
"""
return _coin.SoMultiTextureEnabledElement_enableTexture3(state, node, unit)
def SoMultiTextureEnabledElement_getMode(state, unit=0):
"""
getMode(SoState state, int const unit=0) -> SoMultiTextureEnabledElement::Mode
SoMultiTextureEnabledElement_getMode(SoState state) -> SoMultiTextureEnabledElement::Mode
"""
return _coin.SoMultiTextureEnabledElement_getMode(state, unit)
def SoMultiTextureEnabledElement_disableAll(state):
"""SoMultiTextureEnabledElement_disableAll(SoState state)"""
return _coin.SoMultiTextureEnabledElement_disableAll(state)
def SoMultiTextureEnabledElement_set(*args):
"""
set(SoState state, SoNode node, int const unit, SbBool const enabled)
set(SoState state, SbBool const enabled)
SoMultiTextureEnabledElement_set(SoState state, SoNode node, SbBool const enabled)
"""
return _coin.SoMultiTextureEnabledElement_set(*args)
class SoGLMultiTextureEnabledElement(SoMultiTextureEnabledElement):
"""Proxy of C++ SoGLMultiTextureEnabledElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLMultiTextureEnabledElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLMultiTextureEnabledElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLMultiTextureEnabledElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLMultiTextureEnabledElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLMultiTextureEnabledElement self, SoState state)"""
return _coin.SoGLMultiTextureEnabledElement_init(self, state)
def push(self, state):
"""push(SoGLMultiTextureEnabledElement self, SoState state)"""
return _coin.SoGLMultiTextureEnabledElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLMultiTextureEnabledElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLMultiTextureEnabledElement_pop(self, state, prevTopElement)
def setElt(self, unit, mode):
"""setElt(SoGLMultiTextureEnabledElement self, int const unit, int const mode)"""
return _coin.SoGLMultiTextureEnabledElement_setElt(self, unit, mode)
SoGLMultiTextureEnabledElement_swigregister = _coin.SoGLMultiTextureEnabledElement_swigregister
SoGLMultiTextureEnabledElement_swigregister(SoGLMultiTextureEnabledElement)
def SoGLMultiTextureEnabledElement_getClassTypeId():
"""SoGLMultiTextureEnabledElement_getClassTypeId() -> SoType"""
return _coin.SoGLMultiTextureEnabledElement_getClassTypeId()
def SoGLMultiTextureEnabledElement_getClassStackIndex():
"""SoGLMultiTextureEnabledElement_getClassStackIndex() -> int"""
return _coin.SoGLMultiTextureEnabledElement_getClassStackIndex()
def SoGLMultiTextureEnabledElement_createInstance():
"""SoGLMultiTextureEnabledElement_createInstance() -> void *"""
return _coin.SoGLMultiTextureEnabledElement_createInstance()
def SoGLMultiTextureEnabledElement_initClass():
"""SoGLMultiTextureEnabledElement_initClass()"""
return _coin.SoGLMultiTextureEnabledElement_initClass()
class SoLinePatternElement(SoInt32Element):
"""Proxy of C++ SoLinePatternElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoLinePatternElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoLinePatternElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoLinePatternElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoLinePatternElement_initClass()
initClass = staticmethod(initClass)
CONTINUOUS = _coin.SoLinePatternElement_CONTINUOUS
def init(self, state):
"""init(SoLinePatternElement self, SoState state)"""
return _coin.SoLinePatternElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, int32_t const pattern)
set(SoState state, int32_t const pattern)
"""
return _coin.SoLinePatternElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> int32_t"""
return _coin.SoLinePatternElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> int32_t"""
return _coin.SoLinePatternElement_getDefault()
getDefault = staticmethod(getDefault)
SoLinePatternElement_swigregister = _coin.SoLinePatternElement_swigregister
SoLinePatternElement_swigregister(SoLinePatternElement)
def SoLinePatternElement_getClassTypeId():
"""SoLinePatternElement_getClassTypeId() -> SoType"""
return _coin.SoLinePatternElement_getClassTypeId()
def SoLinePatternElement_getClassStackIndex():
"""SoLinePatternElement_getClassStackIndex() -> int"""
return _coin.SoLinePatternElement_getClassStackIndex()
def SoLinePatternElement_createInstance():
"""SoLinePatternElement_createInstance() -> void *"""
return _coin.SoLinePatternElement_createInstance()
def SoLinePatternElement_initClass():
"""SoLinePatternElement_initClass()"""
return _coin.SoLinePatternElement_initClass()
def SoLinePatternElement_set(*args):
"""
set(SoState state, SoNode node, int32_t const pattern)
SoLinePatternElement_set(SoState state, int32_t const pattern)
"""
return _coin.SoLinePatternElement_set(*args)
def SoLinePatternElement_get(state):
"""SoLinePatternElement_get(SoState state) -> int32_t"""
return _coin.SoLinePatternElement_get(state)
def SoLinePatternElement_getDefault():
"""SoLinePatternElement_getDefault() -> int32_t"""
return _coin.SoLinePatternElement_getDefault()
class SoGLLinePatternElement(SoLinePatternElement):
"""Proxy of C++ SoGLLinePatternElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLLinePatternElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLLinePatternElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLLinePatternElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLLinePatternElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLLinePatternElement self, SoState state)"""
return _coin.SoGLLinePatternElement_init(self, state)
def push(self, state):
"""push(SoGLLinePatternElement self, SoState state)"""
return _coin.SoGLLinePatternElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLLinePatternElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLLinePatternElement_pop(self, state, prevTopElement)
SoGLLinePatternElement_swigregister = _coin.SoGLLinePatternElement_swigregister
SoGLLinePatternElement_swigregister(SoGLLinePatternElement)
def SoGLLinePatternElement_getClassTypeId():
"""SoGLLinePatternElement_getClassTypeId() -> SoType"""
return _coin.SoGLLinePatternElement_getClassTypeId()
def SoGLLinePatternElement_getClassStackIndex():
"""SoGLLinePatternElement_getClassStackIndex() -> int"""
return _coin.SoGLLinePatternElement_getClassStackIndex()
def SoGLLinePatternElement_createInstance():
"""SoGLLinePatternElement_createInstance() -> void *"""
return _coin.SoGLLinePatternElement_createInstance()
def SoGLLinePatternElement_initClass():
"""SoGLLinePatternElement_initClass()"""
return _coin.SoGLLinePatternElement_initClass()
class SoSwitchElement(SoInt32Element):
"""Proxy of C++ SoSwitchElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoSwitchElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoSwitchElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoSwitchElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoSwitchElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoSwitchElement self, SoState state)"""
return _coin.SoSwitchElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, int32_t const index)
set(SoState state, int32_t const index)
"""
return _coin.SoSwitchElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> int32_t"""
return _coin.SoSwitchElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> int32_t"""
return _coin.SoSwitchElement_getDefault()
getDefault = staticmethod(getDefault)
SoSwitchElement_swigregister = _coin.SoSwitchElement_swigregister
SoSwitchElement_swigregister(SoSwitchElement)
def SoSwitchElement_getClassTypeId():
"""SoSwitchElement_getClassTypeId() -> SoType"""
return _coin.SoSwitchElement_getClassTypeId()
def SoSwitchElement_getClassStackIndex():
"""SoSwitchElement_getClassStackIndex() -> int"""
return _coin.SoSwitchElement_getClassStackIndex()
def SoSwitchElement_createInstance():
"""SoSwitchElement_createInstance() -> void *"""
return _coin.SoSwitchElement_createInstance()
def SoSwitchElement_initClass():
"""SoSwitchElement_initClass()"""
return _coin.SoSwitchElement_initClass()
def SoSwitchElement_set(*args):
"""
set(SoState state, SoNode node, int32_t const index)
SoSwitchElement_set(SoState state, int32_t const index)
"""
return _coin.SoSwitchElement_set(*args)
def SoSwitchElement_get(state):
"""SoSwitchElement_get(SoState state) -> int32_t"""
return _coin.SoSwitchElement_get(state)
def SoSwitchElement_getDefault():
"""SoSwitchElement_getDefault() -> int32_t"""
return _coin.SoSwitchElement_getDefault()
class SoTextOutlineEnabledElement(SoInt32Element):
"""Proxy of C++ SoTextOutlineEnabledElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTextOutlineEnabledElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoTextOutlineEnabledElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoTextOutlineEnabledElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoTextOutlineEnabledElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoTextOutlineEnabledElement self, SoState state)"""
return _coin.SoTextOutlineEnabledElement_init(self, state)
def push(self, state):
"""push(SoTextOutlineEnabledElement self, SoState state)"""
return _coin.SoTextOutlineEnabledElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoTextOutlineEnabledElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoTextOutlineEnabledElement_pop(self, state, prevTopElement)
def set(*args):
"""
set(SoState state, SoNode node, SbBool const enabled)
set(SoState state, SbBool const enabled)
"""
return _coin.SoTextOutlineEnabledElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SbBool"""
return _coin.SoTextOutlineEnabledElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SbBool"""
return _coin.SoTextOutlineEnabledElement_getDefault()
getDefault = staticmethod(getDefault)
SoTextOutlineEnabledElement_swigregister = _coin.SoTextOutlineEnabledElement_swigregister
SoTextOutlineEnabledElement_swigregister(SoTextOutlineEnabledElement)
def SoTextOutlineEnabledElement_getClassTypeId():
"""SoTextOutlineEnabledElement_getClassTypeId() -> SoType"""
return _coin.SoTextOutlineEnabledElement_getClassTypeId()
def SoTextOutlineEnabledElement_getClassStackIndex():
"""SoTextOutlineEnabledElement_getClassStackIndex() -> int"""
return _coin.SoTextOutlineEnabledElement_getClassStackIndex()
def SoTextOutlineEnabledElement_createInstance():
"""SoTextOutlineEnabledElement_createInstance() -> void *"""
return _coin.SoTextOutlineEnabledElement_createInstance()
def SoTextOutlineEnabledElement_initClass():
"""SoTextOutlineEnabledElement_initClass()"""
return _coin.SoTextOutlineEnabledElement_initClass()
def SoTextOutlineEnabledElement_set(*args):
"""
set(SoState state, SoNode node, SbBool const enabled)
SoTextOutlineEnabledElement_set(SoState state, SbBool const enabled)
"""
return _coin.SoTextOutlineEnabledElement_set(*args)
def SoTextOutlineEnabledElement_get(state):
"""SoTextOutlineEnabledElement_get(SoState state) -> SbBool"""
return _coin.SoTextOutlineEnabledElement_get(state)
def SoTextOutlineEnabledElement_getDefault():
"""SoTextOutlineEnabledElement_getDefault() -> SbBool"""
return _coin.SoTextOutlineEnabledElement_getDefault()
class SoUnitsElement(SoInt32Element):
"""Proxy of C++ SoUnitsElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoUnitsElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoUnitsElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoUnitsElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoUnitsElement_initClass()
initClass = staticmethod(initClass)
METERS = _coin.SoUnitsElement_METERS
CENTIMETERS = _coin.SoUnitsElement_CENTIMETERS
MILLIMETERS = _coin.SoUnitsElement_MILLIMETERS
MICROMETERS = _coin.SoUnitsElement_MICROMETERS
MICRONS = _coin.SoUnitsElement_MICRONS
NANOMETERS = _coin.SoUnitsElement_NANOMETERS
ANGSTROMS = _coin.SoUnitsElement_ANGSTROMS
KILOMETERS = _coin.SoUnitsElement_KILOMETERS
FEET = _coin.SoUnitsElement_FEET
INCHES = _coin.SoUnitsElement_INCHES
POINTS = _coin.SoUnitsElement_POINTS
YARDS = _coin.SoUnitsElement_YARDS
MILES = _coin.SoUnitsElement_MILES
NAUTICAL_MILES = _coin.SoUnitsElement_NAUTICAL_MILES
def init(self, state):
"""init(SoUnitsElement self, SoState state)"""
return _coin.SoUnitsElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, SoUnitsElement::Units const units)
set(SoState state, SoUnitsElement::Units const units)
"""
return _coin.SoUnitsElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SoUnitsElement::Units"""
return _coin.SoUnitsElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> SoUnitsElement::Units"""
return _coin.SoUnitsElement_getDefault()
getDefault = staticmethod(getDefault)
SoUnitsElement_swigregister = _coin.SoUnitsElement_swigregister
SoUnitsElement_swigregister(SoUnitsElement)
def SoUnitsElement_getClassTypeId():
"""SoUnitsElement_getClassTypeId() -> SoType"""
return _coin.SoUnitsElement_getClassTypeId()
def SoUnitsElement_getClassStackIndex():
"""SoUnitsElement_getClassStackIndex() -> int"""
return _coin.SoUnitsElement_getClassStackIndex()
def SoUnitsElement_createInstance():
"""SoUnitsElement_createInstance() -> void *"""
return _coin.SoUnitsElement_createInstance()
def SoUnitsElement_initClass():
"""SoUnitsElement_initClass()"""
return _coin.SoUnitsElement_initClass()
def SoUnitsElement_set(*args):
"""
set(SoState state, SoNode node, SoUnitsElement::Units const units)
SoUnitsElement_set(SoState state, SoUnitsElement::Units const units)
"""
return _coin.SoUnitsElement_set(*args)
def SoUnitsElement_get(state):
"""SoUnitsElement_get(SoState state) -> SoUnitsElement::Units"""
return _coin.SoUnitsElement_get(state)
def SoUnitsElement_getDefault():
"""SoUnitsElement_getDefault() -> SoUnitsElement::Units"""
return _coin.SoUnitsElement_getDefault()
class SoFocalDistanceElement(SoFloatElement):
"""Proxy of C++ SoFocalDistanceElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoFocalDistanceElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoFocalDistanceElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoFocalDistanceElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoFocalDistanceElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoFocalDistanceElement self, SoState state)"""
return _coin.SoFocalDistanceElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, float const distance)
set(SoState state, float const distance)
"""
return _coin.SoFocalDistanceElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> float"""
return _coin.SoFocalDistanceElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> float"""
return _coin.SoFocalDistanceElement_getDefault()
getDefault = staticmethod(getDefault)
SoFocalDistanceElement_swigregister = _coin.SoFocalDistanceElement_swigregister
SoFocalDistanceElement_swigregister(SoFocalDistanceElement)
def SoFocalDistanceElement_getClassTypeId():
"""SoFocalDistanceElement_getClassTypeId() -> SoType"""
return _coin.SoFocalDistanceElement_getClassTypeId()
def SoFocalDistanceElement_getClassStackIndex():
"""SoFocalDistanceElement_getClassStackIndex() -> int"""
return _coin.SoFocalDistanceElement_getClassStackIndex()
def SoFocalDistanceElement_createInstance():
"""SoFocalDistanceElement_createInstance() -> void *"""
return _coin.SoFocalDistanceElement_createInstance()
def SoFocalDistanceElement_initClass():
"""SoFocalDistanceElement_initClass()"""
return _coin.SoFocalDistanceElement_initClass()
def SoFocalDistanceElement_set(*args):
"""
set(SoState state, SoNode node, float const distance)
SoFocalDistanceElement_set(SoState state, float const distance)
"""
return _coin.SoFocalDistanceElement_set(*args)
def SoFocalDistanceElement_get(state):
"""SoFocalDistanceElement_get(SoState state) -> float"""
return _coin.SoFocalDistanceElement_get(state)
def SoFocalDistanceElement_getDefault():
"""SoFocalDistanceElement_getDefault() -> float"""
return _coin.SoFocalDistanceElement_getDefault()
class SoFontSizeElement(SoFloatElement):
"""Proxy of C++ SoFontSizeElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoFontSizeElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoFontSizeElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoFontSizeElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoFontSizeElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoFontSizeElement self, SoState state)"""
return _coin.SoFontSizeElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, float const fontSize)
set(SoState state, float const fontSize)
"""
return _coin.SoFontSizeElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> float"""
return _coin.SoFontSizeElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> float"""
return _coin.SoFontSizeElement_getDefault()
getDefault = staticmethod(getDefault)
SoFontSizeElement_swigregister = _coin.SoFontSizeElement_swigregister
SoFontSizeElement_swigregister(SoFontSizeElement)
def SoFontSizeElement_getClassTypeId():
"""SoFontSizeElement_getClassTypeId() -> SoType"""
return _coin.SoFontSizeElement_getClassTypeId()
def SoFontSizeElement_getClassStackIndex():
"""SoFontSizeElement_getClassStackIndex() -> int"""
return _coin.SoFontSizeElement_getClassStackIndex()
def SoFontSizeElement_createInstance():
"""SoFontSizeElement_createInstance() -> void *"""
return _coin.SoFontSizeElement_createInstance()
def SoFontSizeElement_initClass():
"""SoFontSizeElement_initClass()"""
return _coin.SoFontSizeElement_initClass()
def SoFontSizeElement_set(*args):
"""
set(SoState state, SoNode node, float const fontSize)
SoFontSizeElement_set(SoState state, float const fontSize)
"""
return _coin.SoFontSizeElement_set(*args)
def SoFontSizeElement_get(state):
"""SoFontSizeElement_get(SoState state) -> float"""
return _coin.SoFontSizeElement_get(state)
def SoFontSizeElement_getDefault():
"""SoFontSizeElement_getDefault() -> float"""
return _coin.SoFontSizeElement_getDefault()
class SoLineWidthElement(SoFloatElement):
"""Proxy of C++ SoLineWidthElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoLineWidthElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoLineWidthElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoLineWidthElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoLineWidthElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoLineWidthElement self, SoState state)"""
return _coin.SoLineWidthElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, float const lineWidth)
set(SoState state, float const lineWidth)
"""
return _coin.SoLineWidthElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> float"""
return _coin.SoLineWidthElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> float"""
return _coin.SoLineWidthElement_getDefault()
getDefault = staticmethod(getDefault)
SoLineWidthElement_swigregister = _coin.SoLineWidthElement_swigregister
SoLineWidthElement_swigregister(SoLineWidthElement)
def SoLineWidthElement_getClassTypeId():
"""SoLineWidthElement_getClassTypeId() -> SoType"""
return _coin.SoLineWidthElement_getClassTypeId()
def SoLineWidthElement_getClassStackIndex():
"""SoLineWidthElement_getClassStackIndex() -> int"""
return _coin.SoLineWidthElement_getClassStackIndex()
def SoLineWidthElement_createInstance():
"""SoLineWidthElement_createInstance() -> void *"""
return _coin.SoLineWidthElement_createInstance()
def SoLineWidthElement_initClass():
"""SoLineWidthElement_initClass()"""
return _coin.SoLineWidthElement_initClass()
def SoLineWidthElement_set(*args):
"""
set(SoState state, SoNode node, float const lineWidth)
SoLineWidthElement_set(SoState state, float const lineWidth)
"""
return _coin.SoLineWidthElement_set(*args)
def SoLineWidthElement_get(state):
"""SoLineWidthElement_get(SoState state) -> float"""
return _coin.SoLineWidthElement_get(state)
def SoLineWidthElement_getDefault():
"""SoLineWidthElement_getDefault() -> float"""
return _coin.SoLineWidthElement_getDefault()
class SoGLLineWidthElement(SoLineWidthElement):
"""Proxy of C++ SoGLLineWidthElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLLineWidthElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLLineWidthElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLLineWidthElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLLineWidthElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLLineWidthElement self, SoState state)"""
return _coin.SoGLLineWidthElement_init(self, state)
def push(self, state):
"""push(SoGLLineWidthElement self, SoState state)"""
return _coin.SoGLLineWidthElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLLineWidthElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLLineWidthElement_pop(self, state, prevTopElement)
SoGLLineWidthElement_swigregister = _coin.SoGLLineWidthElement_swigregister
SoGLLineWidthElement_swigregister(SoGLLineWidthElement)
def SoGLLineWidthElement_getClassTypeId():
"""SoGLLineWidthElement_getClassTypeId() -> SoType"""
return _coin.SoGLLineWidthElement_getClassTypeId()
def SoGLLineWidthElement_getClassStackIndex():
"""SoGLLineWidthElement_getClassStackIndex() -> int"""
return _coin.SoGLLineWidthElement_getClassStackIndex()
def SoGLLineWidthElement_createInstance():
"""SoGLLineWidthElement_createInstance() -> void *"""
return _coin.SoGLLineWidthElement_createInstance()
def SoGLLineWidthElement_initClass():
"""SoGLLineWidthElement_initClass()"""
return _coin.SoGLLineWidthElement_initClass()
class SoPointSizeElement(SoFloatElement):
"""Proxy of C++ SoPointSizeElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoPointSizeElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoPointSizeElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoPointSizeElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoPointSizeElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoPointSizeElement self, SoState state)"""
return _coin.SoPointSizeElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, float const pointSize)
set(SoState state, float const pointSize)
"""
return _coin.SoPointSizeElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> float"""
return _coin.SoPointSizeElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> float"""
return _coin.SoPointSizeElement_getDefault()
getDefault = staticmethod(getDefault)
SoPointSizeElement_swigregister = _coin.SoPointSizeElement_swigregister
SoPointSizeElement_swigregister(SoPointSizeElement)
def SoPointSizeElement_getClassTypeId():
"""SoPointSizeElement_getClassTypeId() -> SoType"""
return _coin.SoPointSizeElement_getClassTypeId()
def SoPointSizeElement_getClassStackIndex():
"""SoPointSizeElement_getClassStackIndex() -> int"""
return _coin.SoPointSizeElement_getClassStackIndex()
def SoPointSizeElement_createInstance():
"""SoPointSizeElement_createInstance() -> void *"""
return _coin.SoPointSizeElement_createInstance()
def SoPointSizeElement_initClass():
"""SoPointSizeElement_initClass()"""
return _coin.SoPointSizeElement_initClass()
def SoPointSizeElement_set(*args):
"""
set(SoState state, SoNode node, float const pointSize)
SoPointSizeElement_set(SoState state, float const pointSize)
"""
return _coin.SoPointSizeElement_set(*args)
def SoPointSizeElement_get(state):
"""SoPointSizeElement_get(SoState state) -> float"""
return _coin.SoPointSizeElement_get(state)
def SoPointSizeElement_getDefault():
"""SoPointSizeElement_getDefault() -> float"""
return _coin.SoPointSizeElement_getDefault()
class SoGLPointSizeElement(SoPointSizeElement):
"""Proxy of C++ SoGLPointSizeElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLPointSizeElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLPointSizeElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLPointSizeElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLPointSizeElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLPointSizeElement self, SoState state)"""
return _coin.SoGLPointSizeElement_init(self, state)
def push(self, state):
"""push(SoGLPointSizeElement self, SoState state)"""
return _coin.SoGLPointSizeElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLPointSizeElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLPointSizeElement_pop(self, state, prevTopElement)
SoGLPointSizeElement_swigregister = _coin.SoGLPointSizeElement_swigregister
SoGLPointSizeElement_swigregister(SoGLPointSizeElement)
def SoGLPointSizeElement_getClassTypeId():
"""SoGLPointSizeElement_getClassTypeId() -> SoType"""
return _coin.SoGLPointSizeElement_getClassTypeId()
def SoGLPointSizeElement_getClassStackIndex():
"""SoGLPointSizeElement_getClassStackIndex() -> int"""
return _coin.SoGLPointSizeElement_getClassStackIndex()
def SoGLPointSizeElement_createInstance():
"""SoGLPointSizeElement_createInstance() -> void *"""
return _coin.SoGLPointSizeElement_createInstance()
def SoGLPointSizeElement_initClass():
"""SoGLPointSizeElement_initClass()"""
return _coin.SoGLPointSizeElement_initClass()
class SoTextureQualityElement(SoFloatElement):
"""Proxy of C++ SoTextureQualityElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTextureQualityElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoTextureQualityElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoTextureQualityElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoTextureQualityElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoTextureQualityElement self, SoState state)"""
return _coin.SoTextureQualityElement_init(self, state)
def set(*args):
"""
set(SoState state, SoNode node, float const quality)
set(SoState state, float const quality)
"""
return _coin.SoTextureQualityElement_set(*args)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> float"""
return _coin.SoTextureQualityElement_get(state)
get = staticmethod(get)
def getDefault():
"""getDefault() -> float"""
return _coin.SoTextureQualityElement_getDefault()
getDefault = staticmethod(getDefault)
SoTextureQualityElement_swigregister = _coin.SoTextureQualityElement_swigregister
SoTextureQualityElement_swigregister(SoTextureQualityElement)
def SoTextureQualityElement_getClassTypeId():
"""SoTextureQualityElement_getClassTypeId() -> SoType"""
return _coin.SoTextureQualityElement_getClassTypeId()
def SoTextureQualityElement_getClassStackIndex():
"""SoTextureQualityElement_getClassStackIndex() -> int"""
return _coin.SoTextureQualityElement_getClassStackIndex()
def SoTextureQualityElement_createInstance():
"""SoTextureQualityElement_createInstance() -> void *"""
return _coin.SoTextureQualityElement_createInstance()
def SoTextureQualityElement_initClass():
"""SoTextureQualityElement_initClass()"""
return _coin.SoTextureQualityElement_initClass()
def SoTextureQualityElement_set(*args):
"""
set(SoState state, SoNode node, float const quality)
SoTextureQualityElement_set(SoState state, float const quality)
"""
return _coin.SoTextureQualityElement_set(*args)
def SoTextureQualityElement_get(state):
"""SoTextureQualityElement_get(SoState state) -> float"""
return _coin.SoTextureQualityElement_get(state)
def SoTextureQualityElement_getDefault():
"""SoTextureQualityElement_getDefault() -> float"""
return _coin.SoTextureQualityElement_getDefault()
class SoTextureOverrideElement(SoElement):
"""Proxy of C++ SoTextureOverrideElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoTextureOverrideElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoTextureOverrideElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoTextureOverrideElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoTextureOverrideElement_initClass()
initClass = staticmethod(initClass)
def matches(self, element):
"""matches(SoTextureOverrideElement self, SoElement element) -> SbBool"""
return _coin.SoTextureOverrideElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoTextureOverrideElement self) -> SoElement"""
return _coin.SoTextureOverrideElement_copyMatchInfo(self)
def init(self, state):
"""init(SoTextureOverrideElement self, SoState state)"""
return _coin.SoTextureOverrideElement_init(self, state)
def push(self, state):
"""push(SoTextureOverrideElement self, SoState state)"""
return _coin.SoTextureOverrideElement_push(self, state)
def getQualityOverride(state):
"""getQualityOverride(SoState state) -> SbBool"""
return _coin.SoTextureOverrideElement_getQualityOverride(state)
getQualityOverride = staticmethod(getQualityOverride)
def getImageOverride(state):
"""getImageOverride(SoState state) -> SbBool"""
return _coin.SoTextureOverrideElement_getImageOverride(state)
getImageOverride = staticmethod(getImageOverride)
def getBumpMapOverride(state):
"""getBumpMapOverride(SoState state) -> SbBool"""
return _coin.SoTextureOverrideElement_getBumpMapOverride(state)
getBumpMapOverride = staticmethod(getBumpMapOverride)
def setQualityOverride(state, value):
"""setQualityOverride(SoState state, SbBool const value)"""
return _coin.SoTextureOverrideElement_setQualityOverride(state, value)
setQualityOverride = staticmethod(setQualityOverride)
def setImageOverride(state, value):
"""setImageOverride(SoState state, SbBool const value)"""
return _coin.SoTextureOverrideElement_setImageOverride(state, value)
setImageOverride = staticmethod(setImageOverride)
def setBumpMapOverride(state, value):
"""setBumpMapOverride(SoState state, SbBool const value)"""
return _coin.SoTextureOverrideElement_setBumpMapOverride(state, value)
setBumpMapOverride = staticmethod(setBumpMapOverride)
def output(self, fp):
"""output(SoTextureOverrideElement self, FILE * fp)"""
return _coin.SoTextureOverrideElement_output(self, fp)
SoTextureOverrideElement_swigregister = _coin.SoTextureOverrideElement_swigregister
SoTextureOverrideElement_swigregister(SoTextureOverrideElement)
def SoTextureOverrideElement_getClassTypeId():
"""SoTextureOverrideElement_getClassTypeId() -> SoType"""
return _coin.SoTextureOverrideElement_getClassTypeId()
def SoTextureOverrideElement_getClassStackIndex():
"""SoTextureOverrideElement_getClassStackIndex() -> int"""
return _coin.SoTextureOverrideElement_getClassStackIndex()
def SoTextureOverrideElement_createInstance():
"""SoTextureOverrideElement_createInstance() -> void *"""
return _coin.SoTextureOverrideElement_createInstance()
def SoTextureOverrideElement_initClass():
"""SoTextureOverrideElement_initClass()"""
return _coin.SoTextureOverrideElement_initClass()
def SoTextureOverrideElement_getQualityOverride(state):
"""SoTextureOverrideElement_getQualityOverride(SoState state) -> SbBool"""
return _coin.SoTextureOverrideElement_getQualityOverride(state)
def SoTextureOverrideElement_getImageOverride(state):
"""SoTextureOverrideElement_getImageOverride(SoState state) -> SbBool"""
return _coin.SoTextureOverrideElement_getImageOverride(state)
def SoTextureOverrideElement_getBumpMapOverride(state):
"""SoTextureOverrideElement_getBumpMapOverride(SoState state) -> SbBool"""
return _coin.SoTextureOverrideElement_getBumpMapOverride(state)
def SoTextureOverrideElement_setQualityOverride(state, value):
"""SoTextureOverrideElement_setQualityOverride(SoState state, SbBool const value)"""
return _coin.SoTextureOverrideElement_setQualityOverride(state, value)
def SoTextureOverrideElement_setImageOverride(state, value):
"""SoTextureOverrideElement_setImageOverride(SoState state, SbBool const value)"""
return _coin.SoTextureOverrideElement_setImageOverride(state, value)
def SoTextureOverrideElement_setBumpMapOverride(state, value):
"""SoTextureOverrideElement_setBumpMapOverride(SoState state, SbBool const value)"""
return _coin.SoTextureOverrideElement_setBumpMapOverride(state, value)
class SoGLRenderPassElement(SoElement):
"""Proxy of C++ SoGLRenderPassElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLRenderPassElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLRenderPassElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLRenderPassElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLRenderPassElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLRenderPassElement self, SoState state)"""
return _coin.SoGLRenderPassElement_init(self, state)
def matches(self, element):
"""matches(SoGLRenderPassElement self, SoElement element) -> SbBool"""
return _coin.SoGLRenderPassElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoGLRenderPassElement self) -> SoElement"""
return _coin.SoGLRenderPassElement_copyMatchInfo(self)
def set(state, passNumber):
"""set(SoState state, int const passNumber)"""
return _coin.SoGLRenderPassElement_set(state, passNumber)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> int"""
return _coin.SoGLRenderPassElement_get(state)
get = staticmethod(get)
SoGLRenderPassElement_swigregister = _coin.SoGLRenderPassElement_swigregister
SoGLRenderPassElement_swigregister(SoGLRenderPassElement)
def SoGLRenderPassElement_getClassTypeId():
"""SoGLRenderPassElement_getClassTypeId() -> SoType"""
return _coin.SoGLRenderPassElement_getClassTypeId()
def SoGLRenderPassElement_getClassStackIndex():
"""SoGLRenderPassElement_getClassStackIndex() -> int"""
return _coin.SoGLRenderPassElement_getClassStackIndex()
def SoGLRenderPassElement_createInstance():
"""SoGLRenderPassElement_createInstance() -> void *"""
return _coin.SoGLRenderPassElement_createInstance()
def SoGLRenderPassElement_initClass():
"""SoGLRenderPassElement_initClass()"""
return _coin.SoGLRenderPassElement_initClass()
def SoGLRenderPassElement_set(state, passNumber):
"""SoGLRenderPassElement_set(SoState state, int const passNumber)"""
return _coin.SoGLRenderPassElement_set(state, passNumber)
def SoGLRenderPassElement_get(state):
"""SoGLRenderPassElement_get(SoState state) -> int"""
return _coin.SoGLRenderPassElement_get(state)
class SoGLUpdateAreaElement(SoElement):
"""Proxy of C++ SoGLUpdateAreaElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLUpdateAreaElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLUpdateAreaElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLUpdateAreaElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLUpdateAreaElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoGLUpdateAreaElement self, SoState state)"""
return _coin.SoGLUpdateAreaElement_init(self, state)
def push(self, state):
"""push(SoGLUpdateAreaElement self, SoState state)"""
return _coin.SoGLUpdateAreaElement_push(self, state)
def pop(self, state, prevTopElement):
"""pop(SoGLUpdateAreaElement self, SoState state, SoElement prevTopElement)"""
return _coin.SoGLUpdateAreaElement_pop(self, state, prevTopElement)
def matches(self, element):
"""matches(SoGLUpdateAreaElement self, SoElement element) -> SbBool"""
return _coin.SoGLUpdateAreaElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoGLUpdateAreaElement self) -> SoElement"""
return _coin.SoGLUpdateAreaElement_copyMatchInfo(self)
def set(state, origin, size):
"""set(SoState state, SbVec2f origin, SbVec2f size)"""
return _coin.SoGLUpdateAreaElement_set(state, origin, size)
set = staticmethod(set)
def get(state, origin, size):
"""get(SoState state, SbVec2f origin, SbVec2f size) -> SbBool"""
return _coin.SoGLUpdateAreaElement_get(state, origin, size)
get = staticmethod(get)
def getDefaultOrigin():
"""getDefaultOrigin() -> SbVec2f"""
return _coin.SoGLUpdateAreaElement_getDefaultOrigin()
getDefaultOrigin = staticmethod(getDefaultOrigin)
def getDefaultSize():
"""getDefaultSize() -> SbVec2f"""
return _coin.SoGLUpdateAreaElement_getDefaultSize()
getDefaultSize = staticmethod(getDefaultSize)
SoGLUpdateAreaElement_swigregister = _coin.SoGLUpdateAreaElement_swigregister
SoGLUpdateAreaElement_swigregister(SoGLUpdateAreaElement)
def SoGLUpdateAreaElement_getClassTypeId():
"""SoGLUpdateAreaElement_getClassTypeId() -> SoType"""
return _coin.SoGLUpdateAreaElement_getClassTypeId()
def SoGLUpdateAreaElement_getClassStackIndex():
"""SoGLUpdateAreaElement_getClassStackIndex() -> int"""
return _coin.SoGLUpdateAreaElement_getClassStackIndex()
def SoGLUpdateAreaElement_createInstance():
"""SoGLUpdateAreaElement_createInstance() -> void *"""
return _coin.SoGLUpdateAreaElement_createInstance()
def SoGLUpdateAreaElement_initClass():
"""SoGLUpdateAreaElement_initClass()"""
return _coin.SoGLUpdateAreaElement_initClass()
def SoGLUpdateAreaElement_set(state, origin, size):
"""SoGLUpdateAreaElement_set(SoState state, SbVec2f origin, SbVec2f size)"""
return _coin.SoGLUpdateAreaElement_set(state, origin, size)
def SoGLUpdateAreaElement_get(state, origin, size):
"""SoGLUpdateAreaElement_get(SoState state, SbVec2f origin, SbVec2f size) -> SbBool"""
return _coin.SoGLUpdateAreaElement_get(state, origin, size)
def SoGLUpdateAreaElement_getDefaultOrigin():
"""SoGLUpdateAreaElement_getDefaultOrigin() -> SbVec2f"""
return _coin.SoGLUpdateAreaElement_getDefaultOrigin()
def SoGLUpdateAreaElement_getDefaultSize():
"""SoGLUpdateAreaElement_getDefaultSize() -> SbVec2f"""
return _coin.SoGLUpdateAreaElement_getDefaultSize()
class SoLocalBBoxMatrixElement(SoElement):
"""Proxy of C++ SoLocalBBoxMatrixElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoLocalBBoxMatrixElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoLocalBBoxMatrixElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoLocalBBoxMatrixElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoLocalBBoxMatrixElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoLocalBBoxMatrixElement self, SoState state)"""
return _coin.SoLocalBBoxMatrixElement_init(self, state)
def push(self, state):
"""push(SoLocalBBoxMatrixElement self, SoState state)"""
return _coin.SoLocalBBoxMatrixElement_push(self, state)
def makeIdentity(state):
"""makeIdentity(SoState state)"""
return _coin.SoLocalBBoxMatrixElement_makeIdentity(state)
makeIdentity = staticmethod(makeIdentity)
def set(state):
"""set(SoState state)"""
return _coin.SoLocalBBoxMatrixElement_set(state)
set = staticmethod(set)
def mult(state):
"""mult(SoState state)"""
return _coin.SoLocalBBoxMatrixElement_mult(state)
mult = staticmethod(mult)
def translateBy(state, translation):
"""translateBy(SoState state, SbVec3f translation)"""
return _coin.SoLocalBBoxMatrixElement_translateBy(state, translation)
translateBy = staticmethod(translateBy)
def rotateBy(state, rotation):
"""rotateBy(SoState state, SbRotation rotation)"""
return _coin.SoLocalBBoxMatrixElement_rotateBy(state, rotation)
rotateBy = staticmethod(rotateBy)
def scaleBy(state, scaleFactor):
"""scaleBy(SoState state, SbVec3f scaleFactor)"""
return _coin.SoLocalBBoxMatrixElement_scaleBy(state, scaleFactor)
scaleBy = staticmethod(scaleBy)
def pushMatrix(state):
"""pushMatrix(SoState state) -> SbMatrix"""
return _coin.SoLocalBBoxMatrixElement_pushMatrix(state)
pushMatrix = staticmethod(pushMatrix)
def popMatrix(state):
"""popMatrix(SoState state)"""
return _coin.SoLocalBBoxMatrixElement_popMatrix(state)
popMatrix = staticmethod(popMatrix)
def resetAll(state):
"""resetAll(SoState state)"""
return _coin.SoLocalBBoxMatrixElement_resetAll(state)
resetAll = staticmethod(resetAll)
def get(state):
"""get(SoState state) -> SbMatrix"""
return _coin.SoLocalBBoxMatrixElement_get(state)
get = staticmethod(get)
def matches(self, element):
"""matches(SoLocalBBoxMatrixElement self, SoElement element) -> SbBool"""
return _coin.SoLocalBBoxMatrixElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoLocalBBoxMatrixElement self) -> SoElement"""
return _coin.SoLocalBBoxMatrixElement_copyMatchInfo(self)
SoLocalBBoxMatrixElement_swigregister = _coin.SoLocalBBoxMatrixElement_swigregister
SoLocalBBoxMatrixElement_swigregister(SoLocalBBoxMatrixElement)
def SoLocalBBoxMatrixElement_getClassTypeId():
"""SoLocalBBoxMatrixElement_getClassTypeId() -> SoType"""
return _coin.SoLocalBBoxMatrixElement_getClassTypeId()
def SoLocalBBoxMatrixElement_getClassStackIndex():
"""SoLocalBBoxMatrixElement_getClassStackIndex() -> int"""
return _coin.SoLocalBBoxMatrixElement_getClassStackIndex()
def SoLocalBBoxMatrixElement_createInstance():
"""SoLocalBBoxMatrixElement_createInstance() -> void *"""
return _coin.SoLocalBBoxMatrixElement_createInstance()
def SoLocalBBoxMatrixElement_initClass():
"""SoLocalBBoxMatrixElement_initClass()"""
return _coin.SoLocalBBoxMatrixElement_initClass()
def SoLocalBBoxMatrixElement_makeIdentity(state):
"""SoLocalBBoxMatrixElement_makeIdentity(SoState state)"""
return _coin.SoLocalBBoxMatrixElement_makeIdentity(state)
def SoLocalBBoxMatrixElement_set(state):
"""SoLocalBBoxMatrixElement_set(SoState state)"""
return _coin.SoLocalBBoxMatrixElement_set(state)
def SoLocalBBoxMatrixElement_mult(state):
"""SoLocalBBoxMatrixElement_mult(SoState state)"""
return _coin.SoLocalBBoxMatrixElement_mult(state)
def SoLocalBBoxMatrixElement_translateBy(state, translation):
"""SoLocalBBoxMatrixElement_translateBy(SoState state, SbVec3f translation)"""
return _coin.SoLocalBBoxMatrixElement_translateBy(state, translation)
def SoLocalBBoxMatrixElement_rotateBy(state, rotation):
"""SoLocalBBoxMatrixElement_rotateBy(SoState state, SbRotation rotation)"""
return _coin.SoLocalBBoxMatrixElement_rotateBy(state, rotation)
def SoLocalBBoxMatrixElement_scaleBy(state, scaleFactor):
"""SoLocalBBoxMatrixElement_scaleBy(SoState state, SbVec3f scaleFactor)"""
return _coin.SoLocalBBoxMatrixElement_scaleBy(state, scaleFactor)
def SoLocalBBoxMatrixElement_pushMatrix(state):
"""SoLocalBBoxMatrixElement_pushMatrix(SoState state) -> SbMatrix"""
return _coin.SoLocalBBoxMatrixElement_pushMatrix(state)
def SoLocalBBoxMatrixElement_popMatrix(state):
"""SoLocalBBoxMatrixElement_popMatrix(SoState state)"""
return _coin.SoLocalBBoxMatrixElement_popMatrix(state)
def SoLocalBBoxMatrixElement_resetAll(state):
"""SoLocalBBoxMatrixElement_resetAll(SoState state)"""
return _coin.SoLocalBBoxMatrixElement_resetAll(state)
def SoLocalBBoxMatrixElement_get(state):
"""SoLocalBBoxMatrixElement_get(SoState state) -> SbMatrix"""
return _coin.SoLocalBBoxMatrixElement_get(state)
class SoOverrideElement(SoElement):
"""Proxy of C++ SoOverrideElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoOverrideElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoOverrideElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoOverrideElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoOverrideElement_initClass()
initClass = staticmethod(initClass)
AMBIENT_COLOR = _coin.SoOverrideElement_AMBIENT_COLOR
COLOR_INDEX = _coin.SoOverrideElement_COLOR_INDEX
COMPLEXITY = _coin.SoOverrideElement_COMPLEXITY
COMPLEXITY_TYPE = _coin.SoOverrideElement_COMPLEXITY_TYPE
CREASE_ANGLE = _coin.SoOverrideElement_CREASE_ANGLE
DIFFUSE_COLOR = _coin.SoOverrideElement_DIFFUSE_COLOR
DRAW_STYLE = _coin.SoOverrideElement_DRAW_STYLE
EMISSIVE_COLOR = _coin.SoOverrideElement_EMISSIVE_COLOR
FONT_NAME = _coin.SoOverrideElement_FONT_NAME
FONT_SIZE = _coin.SoOverrideElement_FONT_SIZE
LIGHT_MODEL = _coin.SoOverrideElement_LIGHT_MODEL
LINE_PATTERN = _coin.SoOverrideElement_LINE_PATTERN
LINE_WIDTH = _coin.SoOverrideElement_LINE_WIDTH
MATERIAL_BINDING = _coin.SoOverrideElement_MATERIAL_BINDING
POINT_SIZE = _coin.SoOverrideElement_POINT_SIZE
PICK_STYLE = _coin.SoOverrideElement_PICK_STYLE
SHAPE_HINTS = _coin.SoOverrideElement_SHAPE_HINTS
SHININESS = _coin.SoOverrideElement_SHININESS
SPECULAR_COLOR = _coin.SoOverrideElement_SPECULAR_COLOR
POLYGON_OFFSET = _coin.SoOverrideElement_POLYGON_OFFSET
TRANSPARENCY = _coin.SoOverrideElement_TRANSPARENCY
TRANSPARENCY_TYPE = _coin.SoOverrideElement_TRANSPARENCY_TYPE
NORMAL_VECTOR = _coin.SoOverrideElement_NORMAL_VECTOR
NORMAL_BINDING = _coin.SoOverrideElement_NORMAL_BINDING
def init(self, state):
"""init(SoOverrideElement self, SoState state)"""
return _coin.SoOverrideElement_init(self, state)
def push(self, state):
"""push(SoOverrideElement self, SoState state)"""
return _coin.SoOverrideElement_push(self, state)
def matches(self, element):
"""matches(SoOverrideElement self, SoElement element) -> SbBool"""
return _coin.SoOverrideElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoOverrideElement self) -> SoElement"""
return _coin.SoOverrideElement_copyMatchInfo(self)
def getFlags(state):
"""getFlags(SoState state) -> uint32_t"""
return _coin.SoOverrideElement_getFlags(state)
getFlags = staticmethod(getFlags)
def getAmbientColorOverride(state):
"""getAmbientColorOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getAmbientColorOverride(state)
getAmbientColorOverride = staticmethod(getAmbientColorOverride)
def getColorIndexOverride(state):
"""getColorIndexOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getColorIndexOverride(state)
getColorIndexOverride = staticmethod(getColorIndexOverride)
def getComplexityOverride(state):
"""getComplexityOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getComplexityOverride(state)
getComplexityOverride = staticmethod(getComplexityOverride)
def getComplexityTypeOverride(state):
"""getComplexityTypeOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getComplexityTypeOverride(state)
getComplexityTypeOverride = staticmethod(getComplexityTypeOverride)
def getCreaseAngleOverride(state):
"""getCreaseAngleOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getCreaseAngleOverride(state)
getCreaseAngleOverride = staticmethod(getCreaseAngleOverride)
def getDiffuseColorOverride(state):
"""getDiffuseColorOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getDiffuseColorOverride(state)
getDiffuseColorOverride = staticmethod(getDiffuseColorOverride)
def getDrawStyleOverride(state):
"""getDrawStyleOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getDrawStyleOverride(state)
getDrawStyleOverride = staticmethod(getDrawStyleOverride)
def getEmissiveColorOverride(state):
"""getEmissiveColorOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getEmissiveColorOverride(state)
getEmissiveColorOverride = staticmethod(getEmissiveColorOverride)
def getFontNameOverride(state):
"""getFontNameOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getFontNameOverride(state)
getFontNameOverride = staticmethod(getFontNameOverride)
def getFontSizeOverride(state):
"""getFontSizeOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getFontSizeOverride(state)
getFontSizeOverride = staticmethod(getFontSizeOverride)
def getLightModelOverride(state):
"""getLightModelOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getLightModelOverride(state)
getLightModelOverride = staticmethod(getLightModelOverride)
def getLinePatternOverride(state):
"""getLinePatternOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getLinePatternOverride(state)
getLinePatternOverride = staticmethod(getLinePatternOverride)
def getLineWidthOverride(state):
"""getLineWidthOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getLineWidthOverride(state)
getLineWidthOverride = staticmethod(getLineWidthOverride)
def getMaterialBindingOverride(state):
"""getMaterialBindingOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getMaterialBindingOverride(state)
getMaterialBindingOverride = staticmethod(getMaterialBindingOverride)
def getPickStyleOverride(state):
"""getPickStyleOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getPickStyleOverride(state)
getPickStyleOverride = staticmethod(getPickStyleOverride)
def getPointSizeOverride(state):
"""getPointSizeOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getPointSizeOverride(state)
getPointSizeOverride = staticmethod(getPointSizeOverride)
def getPolygonOffsetOverride(state):
"""getPolygonOffsetOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getPolygonOffsetOverride(state)
getPolygonOffsetOverride = staticmethod(getPolygonOffsetOverride)
def getShapeHintsOverride(state):
"""getShapeHintsOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getShapeHintsOverride(state)
getShapeHintsOverride = staticmethod(getShapeHintsOverride)
def getShininessOverride(state):
"""getShininessOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getShininessOverride(state)
getShininessOverride = staticmethod(getShininessOverride)
def getSpecularColorOverride(state):
"""getSpecularColorOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getSpecularColorOverride(state)
getSpecularColorOverride = staticmethod(getSpecularColorOverride)
def getTransparencyOverride(state):
"""getTransparencyOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getTransparencyOverride(state)
getTransparencyOverride = staticmethod(getTransparencyOverride)
def getTransparencyTypeOverride(state):
"""getTransparencyTypeOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getTransparencyTypeOverride(state)
getTransparencyTypeOverride = staticmethod(getTransparencyTypeOverride)
def getNormalVectorOverride(state):
"""getNormalVectorOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getNormalVectorOverride(state)
getNormalVectorOverride = staticmethod(getNormalVectorOverride)
def getNormalBindingOverride(state):
"""getNormalBindingOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getNormalBindingOverride(state)
getNormalBindingOverride = staticmethod(getNormalBindingOverride)
def setAmbientColorOverride(state, node, override):
"""setAmbientColorOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setAmbientColorOverride(state, node, override)
setAmbientColorOverride = staticmethod(setAmbientColorOverride)
def setColorIndexOverride(state, node, override):
"""setColorIndexOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setColorIndexOverride(state, node, override)
setColorIndexOverride = staticmethod(setColorIndexOverride)
def setComplexityOverride(state, node, override):
"""setComplexityOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setComplexityOverride(state, node, override)
setComplexityOverride = staticmethod(setComplexityOverride)
def setComplexityTypeOverride(state, node, override):
"""setComplexityTypeOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setComplexityTypeOverride(state, node, override)
setComplexityTypeOverride = staticmethod(setComplexityTypeOverride)
def setCreaseAngleOverride(state, node, override):
"""setCreaseAngleOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setCreaseAngleOverride(state, node, override)
setCreaseAngleOverride = staticmethod(setCreaseAngleOverride)
def setDiffuseColorOverride(state, node, override):
"""setDiffuseColorOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setDiffuseColorOverride(state, node, override)
setDiffuseColorOverride = staticmethod(setDiffuseColorOverride)
def setDrawStyleOverride(state, node, override):
"""setDrawStyleOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setDrawStyleOverride(state, node, override)
setDrawStyleOverride = staticmethod(setDrawStyleOverride)
def setEmissiveColorOverride(state, node, override):
"""setEmissiveColorOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setEmissiveColorOverride(state, node, override)
setEmissiveColorOverride = staticmethod(setEmissiveColorOverride)
def setFontNameOverride(state, node, override):
"""setFontNameOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setFontNameOverride(state, node, override)
setFontNameOverride = staticmethod(setFontNameOverride)
def setFontSizeOverride(state, node, override):
"""setFontSizeOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setFontSizeOverride(state, node, override)
setFontSizeOverride = staticmethod(setFontSizeOverride)
def setLightModelOverride(state, node, override):
"""setLightModelOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setLightModelOverride(state, node, override)
setLightModelOverride = staticmethod(setLightModelOverride)
def setLinePatternOverride(state, node, override):
"""setLinePatternOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setLinePatternOverride(state, node, override)
setLinePatternOverride = staticmethod(setLinePatternOverride)
def setLineWidthOverride(state, node, override):
"""setLineWidthOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setLineWidthOverride(state, node, override)
setLineWidthOverride = staticmethod(setLineWidthOverride)
def setMaterialBindingOverride(state, node, override):
"""setMaterialBindingOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setMaterialBindingOverride(state, node, override)
setMaterialBindingOverride = staticmethod(setMaterialBindingOverride)
def setPickStyleOverride(state, node, override):
"""setPickStyleOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setPickStyleOverride(state, node, override)
setPickStyleOverride = staticmethod(setPickStyleOverride)
def setPointSizeOverride(state, node, override):
"""setPointSizeOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setPointSizeOverride(state, node, override)
setPointSizeOverride = staticmethod(setPointSizeOverride)
def setPolygonOffsetOverride(state, node, override):
"""setPolygonOffsetOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setPolygonOffsetOverride(state, node, override)
setPolygonOffsetOverride = staticmethod(setPolygonOffsetOverride)
def setShapeHintsOverride(state, node, override):
"""setShapeHintsOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setShapeHintsOverride(state, node, override)
setShapeHintsOverride = staticmethod(setShapeHintsOverride)
def setShininessOverride(state, node, override):
"""setShininessOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setShininessOverride(state, node, override)
setShininessOverride = staticmethod(setShininessOverride)
def setSpecularColorOverride(state, node, override):
"""setSpecularColorOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setSpecularColorOverride(state, node, override)
setSpecularColorOverride = staticmethod(setSpecularColorOverride)
def setTransparencyOverride(state, node, override):
"""setTransparencyOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setTransparencyOverride(state, node, override)
setTransparencyOverride = staticmethod(setTransparencyOverride)
def setTransparencyTypeOverride(state, node, override):
"""setTransparencyTypeOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setTransparencyTypeOverride(state, node, override)
setTransparencyTypeOverride = staticmethod(setTransparencyTypeOverride)
def setNormalVectorOverride(state, node, override):
"""setNormalVectorOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setNormalVectorOverride(state, node, override)
setNormalVectorOverride = staticmethod(setNormalVectorOverride)
def setNormalBindingOverride(state, node, override):
"""setNormalBindingOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setNormalBindingOverride(state, node, override)
setNormalBindingOverride = staticmethod(setNormalBindingOverride)
def output(self, file):
"""output(SoOverrideElement self, FILE * file)"""
return _coin.SoOverrideElement_output(self, file)
SoOverrideElement_swigregister = _coin.SoOverrideElement_swigregister
SoOverrideElement_swigregister(SoOverrideElement)
def SoOverrideElement_getClassTypeId():
"""SoOverrideElement_getClassTypeId() -> SoType"""
return _coin.SoOverrideElement_getClassTypeId()
def SoOverrideElement_getClassStackIndex():
"""SoOverrideElement_getClassStackIndex() -> int"""
return _coin.SoOverrideElement_getClassStackIndex()
def SoOverrideElement_createInstance():
"""SoOverrideElement_createInstance() -> void *"""
return _coin.SoOverrideElement_createInstance()
def SoOverrideElement_initClass():
"""SoOverrideElement_initClass()"""
return _coin.SoOverrideElement_initClass()
def SoOverrideElement_getFlags(state):
"""SoOverrideElement_getFlags(SoState state) -> uint32_t"""
return _coin.SoOverrideElement_getFlags(state)
def SoOverrideElement_getAmbientColorOverride(state):
"""SoOverrideElement_getAmbientColorOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getAmbientColorOverride(state)
def SoOverrideElement_getColorIndexOverride(state):
"""SoOverrideElement_getColorIndexOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getColorIndexOverride(state)
def SoOverrideElement_getComplexityOverride(state):
"""SoOverrideElement_getComplexityOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getComplexityOverride(state)
def SoOverrideElement_getComplexityTypeOverride(state):
"""SoOverrideElement_getComplexityTypeOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getComplexityTypeOverride(state)
def SoOverrideElement_getCreaseAngleOverride(state):
"""SoOverrideElement_getCreaseAngleOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getCreaseAngleOverride(state)
def SoOverrideElement_getDiffuseColorOverride(state):
"""SoOverrideElement_getDiffuseColorOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getDiffuseColorOverride(state)
def SoOverrideElement_getDrawStyleOverride(state):
"""SoOverrideElement_getDrawStyleOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getDrawStyleOverride(state)
def SoOverrideElement_getEmissiveColorOverride(state):
"""SoOverrideElement_getEmissiveColorOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getEmissiveColorOverride(state)
def SoOverrideElement_getFontNameOverride(state):
"""SoOverrideElement_getFontNameOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getFontNameOverride(state)
def SoOverrideElement_getFontSizeOverride(state):
"""SoOverrideElement_getFontSizeOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getFontSizeOverride(state)
def SoOverrideElement_getLightModelOverride(state):
"""SoOverrideElement_getLightModelOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getLightModelOverride(state)
def SoOverrideElement_getLinePatternOverride(state):
"""SoOverrideElement_getLinePatternOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getLinePatternOverride(state)
def SoOverrideElement_getLineWidthOverride(state):
"""SoOverrideElement_getLineWidthOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getLineWidthOverride(state)
def SoOverrideElement_getMaterialBindingOverride(state):
"""SoOverrideElement_getMaterialBindingOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getMaterialBindingOverride(state)
def SoOverrideElement_getPickStyleOverride(state):
"""SoOverrideElement_getPickStyleOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getPickStyleOverride(state)
def SoOverrideElement_getPointSizeOverride(state):
"""SoOverrideElement_getPointSizeOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getPointSizeOverride(state)
def SoOverrideElement_getPolygonOffsetOverride(state):
"""SoOverrideElement_getPolygonOffsetOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getPolygonOffsetOverride(state)
def SoOverrideElement_getShapeHintsOverride(state):
"""SoOverrideElement_getShapeHintsOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getShapeHintsOverride(state)
def SoOverrideElement_getShininessOverride(state):
"""SoOverrideElement_getShininessOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getShininessOverride(state)
def SoOverrideElement_getSpecularColorOverride(state):
"""SoOverrideElement_getSpecularColorOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getSpecularColorOverride(state)
def SoOverrideElement_getTransparencyOverride(state):
"""SoOverrideElement_getTransparencyOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getTransparencyOverride(state)
def SoOverrideElement_getTransparencyTypeOverride(state):
"""SoOverrideElement_getTransparencyTypeOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getTransparencyTypeOverride(state)
def SoOverrideElement_getNormalVectorOverride(state):
"""SoOverrideElement_getNormalVectorOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getNormalVectorOverride(state)
def SoOverrideElement_getNormalBindingOverride(state):
"""SoOverrideElement_getNormalBindingOverride(SoState state) -> SbBool"""
return _coin.SoOverrideElement_getNormalBindingOverride(state)
def SoOverrideElement_setAmbientColorOverride(state, node, override):
"""SoOverrideElement_setAmbientColorOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setAmbientColorOverride(state, node, override)
def SoOverrideElement_setColorIndexOverride(state, node, override):
"""SoOverrideElement_setColorIndexOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setColorIndexOverride(state, node, override)
def SoOverrideElement_setComplexityOverride(state, node, override):
"""SoOverrideElement_setComplexityOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setComplexityOverride(state, node, override)
def SoOverrideElement_setComplexityTypeOverride(state, node, override):
"""SoOverrideElement_setComplexityTypeOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setComplexityTypeOverride(state, node, override)
def SoOverrideElement_setCreaseAngleOverride(state, node, override):
"""SoOverrideElement_setCreaseAngleOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setCreaseAngleOverride(state, node, override)
def SoOverrideElement_setDiffuseColorOverride(state, node, override):
"""SoOverrideElement_setDiffuseColorOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setDiffuseColorOverride(state, node, override)
def SoOverrideElement_setDrawStyleOverride(state, node, override):
"""SoOverrideElement_setDrawStyleOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setDrawStyleOverride(state, node, override)
def SoOverrideElement_setEmissiveColorOverride(state, node, override):
"""SoOverrideElement_setEmissiveColorOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setEmissiveColorOverride(state, node, override)
def SoOverrideElement_setFontNameOverride(state, node, override):
"""SoOverrideElement_setFontNameOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setFontNameOverride(state, node, override)
def SoOverrideElement_setFontSizeOverride(state, node, override):
"""SoOverrideElement_setFontSizeOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setFontSizeOverride(state, node, override)
def SoOverrideElement_setLightModelOverride(state, node, override):
"""SoOverrideElement_setLightModelOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setLightModelOverride(state, node, override)
def SoOverrideElement_setLinePatternOverride(state, node, override):
"""SoOverrideElement_setLinePatternOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setLinePatternOverride(state, node, override)
def SoOverrideElement_setLineWidthOverride(state, node, override):
"""SoOverrideElement_setLineWidthOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setLineWidthOverride(state, node, override)
def SoOverrideElement_setMaterialBindingOverride(state, node, override):
"""SoOverrideElement_setMaterialBindingOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setMaterialBindingOverride(state, node, override)
def SoOverrideElement_setPickStyleOverride(state, node, override):
"""SoOverrideElement_setPickStyleOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setPickStyleOverride(state, node, override)
def SoOverrideElement_setPointSizeOverride(state, node, override):
"""SoOverrideElement_setPointSizeOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setPointSizeOverride(state, node, override)
def SoOverrideElement_setPolygonOffsetOverride(state, node, override):
"""SoOverrideElement_setPolygonOffsetOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setPolygonOffsetOverride(state, node, override)
def SoOverrideElement_setShapeHintsOverride(state, node, override):
"""SoOverrideElement_setShapeHintsOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setShapeHintsOverride(state, node, override)
def SoOverrideElement_setShininessOverride(state, node, override):
"""SoOverrideElement_setShininessOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setShininessOverride(state, node, override)
def SoOverrideElement_setSpecularColorOverride(state, node, override):
"""SoOverrideElement_setSpecularColorOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setSpecularColorOverride(state, node, override)
def SoOverrideElement_setTransparencyOverride(state, node, override):
"""SoOverrideElement_setTransparencyOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setTransparencyOverride(state, node, override)
def SoOverrideElement_setTransparencyTypeOverride(state, node, override):
"""SoOverrideElement_setTransparencyTypeOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setTransparencyTypeOverride(state, node, override)
def SoOverrideElement_setNormalVectorOverride(state, node, override):
"""SoOverrideElement_setNormalVectorOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setNormalVectorOverride(state, node, override)
def SoOverrideElement_setNormalBindingOverride(state, node, override):
"""SoOverrideElement_setNormalBindingOverride(SoState state, SoNode node, SbBool const override)"""
return _coin.SoOverrideElement_setNormalBindingOverride(state, node, override)
class SoPickRayElement(SoElement):
"""Proxy of C++ SoPickRayElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoPickRayElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoPickRayElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoPickRayElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoPickRayElement_initClass()
initClass = staticmethod(initClass)
def init(self, state):
"""init(SoPickRayElement self, SoState state)"""
return _coin.SoPickRayElement_init(self, state)
def matches(self, element):
"""matches(SoPickRayElement self, SoElement element) -> SbBool"""
return _coin.SoPickRayElement_matches(self, element)
def copyMatchInfo(self):
"""copyMatchInfo(SoPickRayElement self) -> SoElement"""
return _coin.SoPickRayElement_copyMatchInfo(self)
def set(state, volume):
"""set(SoState state, SbViewVolume volume)"""
return _coin.SoPickRayElement_set(state, volume)
set = staticmethod(set)
def get(state):
"""get(SoState state) -> SbViewVolume"""
return _coin.SoPickRayElement_get(state)
get = staticmethod(get)
SoPickRayElement_swigregister = _coin.SoPickRayElement_swigregister
SoPickRayElement_swigregister(SoPickRayElement)
def SoPickRayElement_getClassTypeId():
"""SoPickRayElement_getClassTypeId() -> SoType"""
return _coin.SoPickRayElement_getClassTypeId()
def SoPickRayElement_getClassStackIndex():
"""SoPickRayElement_getClassStackIndex() -> int"""
return _coin.SoPickRayElement_getClassStackIndex()
def SoPickRayElement_createInstance():
"""SoPickRayElement_createInstance() -> void *"""
return _coin.SoPickRayElement_createInstance()
def SoPickRayElement_initClass():
"""SoPickRayElement_initClass()"""
return _coin.SoPickRayElement_initClass()
def SoPickRayElement_set(state, volume):
"""SoPickRayElement_set(SoState state, SbViewVolume volume)"""
return _coin.SoPickRayElement_set(state, volume)
def SoPickRayElement_get(state):
"""SoPickRayElement_get(SoState state) -> SbViewVolume"""
return _coin.SoPickRayElement_get(state)
class SoGLCoordinateElement(SoCoordinateElement):
"""Proxy of C++ SoGLCoordinateElement class."""
thisown = _swig_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")
__repr__ = _swig_repr
def getClassTypeId():
"""getClassTypeId() -> SoType"""
return _coin.SoGLCoordinateElement_getClassTypeId()
getClassTypeId = staticmethod(getClassTypeId)
def getClassStackIndex():
"""getClassStackIndex() -> int"""
return _coin.SoGLCoordinateElement_getClassStackIndex()
getClassStackIndex = staticmethod(getClassStackIndex)
def createInstance():
"""createInstance() -> void *"""
return _coin.SoGLCoordinateElement_createInstance()
createInstance = staticmethod(createInstance)
def initClass():
"""initClass()"""
return _coin.SoGLCoordinateElement_initClass()
initClass = staticmethod(initClass)
def getPtr3(self):
"""getPtr3(SoGLCoordinateElement self) -> SbVec3f"""
return _coin.SoGLCoordinateElement_getPtr3(self)
def get
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment