# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

import _demoscript

def _swig_setattr(self,class_type,name,value):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    self.__dict__[name] = value

def _swig_getattr(self,class_type,name):
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


try:
    from weakref import proxy as weakref_proxy
except:
    weakref_proxy = lambda x: x



outputDebug = _demoscript.outputDebug
class Resource(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Resource, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Resource, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C fxcore::Resource instance at %s>" % (self.this,)
    def startUsing(*args): return _demoscript.Resource_startUsing(*args)
    def stopUsing(*args): return _demoscript.Resource_stopUsing(*args)
    def preCache(*args): return _demoscript.Resource_preCache(*args)
    def getUsageCount(*args): return _demoscript.Resource_getUsageCount(*args)

class ResourcePtr(Resource):
    def __init__(self, this):
        _swig_setattr(self, Resource, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Resource, 'thisown', 0)
        _swig_setattr(self, Resource,self.__class__,Resource)
_demoscript.Resource_swigregister(ResourcePtr)

class TextureManagerSingleton(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextureManagerSingleton, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TextureManagerSingleton, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C singleton<(pompom::TextureManager)> instance at %s>" % (self.this,)
    __swig_getmethods__["instance"] = lambda x: _demoscript.TextureManagerSingleton_instance
    if _newclass:instance = staticmethod(_demoscript.TextureManagerSingleton_instance)
    __swig_getmethods__["const_instance"] = lambda x: _demoscript.TextureManagerSingleton_const_instance
    if _newclass:const_instance = staticmethod(_demoscript.TextureManagerSingleton_const_instance)

class TextureManagerSingletonPtr(TextureManagerSingleton):
    def __init__(self, this):
        _swig_setattr(self, TextureManagerSingleton, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, TextureManagerSingleton, 'thisown', 0)
        _swig_setattr(self, TextureManagerSingleton,self.__class__,TextureManagerSingleton)
_demoscript.TextureManagerSingleton_swigregister(TextureManagerSingletonPtr)

TextureManagerSingleton_instance = _demoscript.TextureManagerSingleton_instance

TextureManagerSingleton_const_instance = _demoscript.TextureManagerSingleton_const_instance

class Texture(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Texture, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Texture, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C pompom::Texture instance at %s>" % (self.this,)
    TT_1D = _demoscript.Texture_TT_1D
    TT_2D = _demoscript.Texture_TT_2D
    TT_3D = _demoscript.Texture_TT_3D
    TT_CUBEMAP = _demoscript.Texture_TT_CUBEMAP
    TT_UNKNOWN = _demoscript.Texture_TT_UNKNOWN
    def addReference(*args): return _demoscript.Texture_addReference(*args)
    def release(*args): return _demoscript.Texture_release(*args)
    def mapTo(*args): return _demoscript.Texture_mapTo(*args)
    def getBaseTexture(*args): return _demoscript.Texture_getBaseTexture(*args)
    def getTextureSurface(*args): return _demoscript.Texture_getTextureSurface(*args)
    def getDepthStencilSurface(*args): return _demoscript.Texture_getDepthStencilSurface(*args)
    def getName(*args): return _demoscript.Texture_getName(*args)
    def getWidth(*args): return _demoscript.Texture_getWidth(*args)
    def getHeight(*args): return _demoscript.Texture_getHeight(*args)
    def getSourceWidth(*args): return _demoscript.Texture_getSourceWidth(*args)
    def getSourceHeight(*args): return _demoscript.Texture_getSourceHeight(*args)
    def getBufferFormat(*args): return _demoscript.Texture_getBufferFormat(*args)
    def getDepthStencilFormat(*args): return _demoscript.Texture_getDepthStencilFormat(*args)
    def isLinear(*args): return _demoscript.Texture_isLinear(*args)
    def getPlane(*args): return _demoscript.Texture_getPlane(*args)
    def destroyDepthStencilBuffer(*args): return _demoscript.Texture_destroyDepthStencilBuffer(*args)
    def swapOut(*args): return _demoscript.Texture_swapOut(*args)
    def swapIn(*args): return _demoscript.Texture_swapIn(*args)

class TexturePtr(Texture):
    def __init__(self, this):
        _swig_setattr(self, Texture, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Texture, 'thisown', 0)
        _swig_setattr(self, Texture,self.__class__,Texture)
_demoscript.Texture_swigregister(TexturePtr)

class TextureLayer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextureLayer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TextureLayer, name)
    def __repr__(self):
        return "<C pompom::TextureLayer instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, TextureLayer, 'this', _demoscript.new_TextureLayer(*args))
        _swig_setattr(self, TextureLayer, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_TextureLayer):
        try:
            if self.thisown: destroy(self)
        except: pass
    def setTexture(*args): return _demoscript.TextureLayer_setTexture(*args)
    def getTexture(*args): return _demoscript.TextureLayer_getTexture(*args)
    def setAddressU(*args): return _demoscript.TextureLayer_setAddressU(*args)
    def setAddressV(*args): return _demoscript.TextureLayer_setAddressV(*args)
    def setAddressW(*args): return _demoscript.TextureLayer_setAddressW(*args)
    def getAddressU(*args): return _demoscript.TextureLayer_getAddressU(*args)
    def getAddressV(*args): return _demoscript.TextureLayer_getAddressV(*args)
    def getAddressW(*args): return _demoscript.TextureLayer_getAddressW(*args)
    def setAlphaKill(*args): return _demoscript.TextureLayer_setAlphaKill(*args)
    def getAlphaKill(*args): return _demoscript.TextureLayer_getAlphaKill(*args)
    def setColorOp(*args): return _demoscript.TextureLayer_setColorOp(*args)
    def setAlphaOp(*args): return _demoscript.TextureLayer_setAlphaOp(*args)
    def setFilter(*args): return _demoscript.TextureLayer_setFilter(*args)
    def getFilter(*args): return _demoscript.TextureLayer_getFilter(*args)
    def getColorOp(*args): return _demoscript.TextureLayer_getColorOp(*args)
    def getAlphaOp(*args): return _demoscript.TextureLayer_getAlphaOp(*args)
    __swig_setmethods__["transform"] = _demoscript.TextureLayer_transform_set
    __swig_getmethods__["transform"] = _demoscript.TextureLayer_transform_get
    if _newclass:transform = property(_demoscript.TextureLayer_transform_get, _demoscript.TextureLayer_transform_set)

class TextureLayerPtr(TextureLayer):
    def __init__(self, this):
        _swig_setattr(self, TextureLayer, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, TextureLayer, 'thisown', 0)
        _swig_setattr(self, TextureLayer,self.__class__,TextureLayer)
_demoscript.TextureLayer_swigregister(TextureLayerPtr)

class TextureState(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextureState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TextureState, name)
    def __repr__(self):
        return "<C pompom::TextureState instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, TextureState, 'this', _demoscript.new_TextureState(*args))
        _swig_setattr(self, TextureState, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_TextureState):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getTextureFactor(*args): return _demoscript.TextureState_getTextureFactor(*args)
    def setTextureFactor(*args): return _demoscript.TextureState_setTextureFactor(*args)
    __swig_setmethods__["layers"] = _demoscript.TextureState_layers_set
    __swig_getmethods__["layers"] = _demoscript.TextureState_layers_get
    if _newclass:layers = property(_demoscript.TextureState_layers_get, _demoscript.TextureState_layers_set)
    def pushTextureLayer(*args): return _demoscript.TextureState_pushTextureLayer(*args)

class TextureStatePtr(TextureState):
    def __init__(self, this):
        _swig_setattr(self, TextureState, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, TextureState, 'thisown', 0)
        _swig_setattr(self, TextureState,self.__class__,TextureState)
_demoscript.TextureState_swigregister(TextureStatePtr)

class TextureManager(TextureManagerSingleton):
    __swig_setmethods__ = {}
    for _s in [TextureManagerSingleton]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextureManager, name, value)
    __swig_getmethods__ = {}
    for _s in [TextureManagerSingleton]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, TextureManager, name)
    def __repr__(self):
        return "<C pompom::TextureManager instance at %s>" % (self.this,)
    def createTextureFromFile(*args): return _demoscript.TextureManager_createTextureFromFile(*args)
    def createTextureFromFileLinear(*args): return _demoscript.TextureManager_createTextureFromFileLinear(*args)
    def createTextureFromMemory(*args): return _demoscript.TextureManager_createTextureFromMemory(*args)
    def createCubeTextureFromFile(*args): return _demoscript.TextureManager_createCubeTextureFromFile(*args)
    def createVolumeTextureFromMemoryRaw(*args): return _demoscript.TextureManager_createVolumeTextureFromMemoryRaw(*args)
    def createVolumeTextureFromFileRaw(*args): return _demoscript.TextureManager_createVolumeTextureFromFileRaw(*args)
    def createVolumeTextureFromFile(*args): return _demoscript.TextureManager_createVolumeTextureFromFile(*args)
    def createRenderTarget(*args): return _demoscript.TextureManager_createRenderTarget(*args)
    def createCubeRenderTarget(*args): return _demoscript.TextureManager_createCubeRenderTarget(*args)
    def getTexture(*args): return _demoscript.TextureManager_getTexture(*args)
    def __init__(self, *args):
        _swig_setattr(self, TextureManager, 'this', _demoscript.new_TextureManager(*args))
        _swig_setattr(self, TextureManager, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_TextureManager):
        try:
            if self.thisown: destroy(self)
        except: pass

class TextureManagerPtr(TextureManager):
    def __init__(self, this):
        _swig_setattr(self, TextureManager, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, TextureManager, 'thisown', 0)
        _swig_setattr(self, TextureManager,self.__class__,TextureManager)
_demoscript.TextureManager_swigregister(TextureManagerPtr)

class Slider(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Slider, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Slider, name)
    def __repr__(self):
        return "<C fxcore::Slider instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Slider, 'this', _demoscript.new_Slider(*args))
        _swig_setattr(self, Slider, 'thisown', 1)
    def update(*args): return _demoscript.Slider_update(*args)
    def setDamping(*args): return _demoscript.Slider_setDamping(*args)
    def getDamping(*args): return _demoscript.Slider_getDamping(*args)
    def getTargetValue(*args): return _demoscript.Slider_getTargetValue(*args)
    def __del__(self, destroy=_demoscript.delete_Slider):
        try:
            if self.thisown: destroy(self)
        except: pass

class SliderPtr(Slider):
    def __init__(self, this):
        _swig_setattr(self, Slider, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Slider, 'thisown', 0)
        _swig_setattr(self, Slider,self.__class__,Slider)
_demoscript.Slider_swigregister(SliderPtr)

class FixedSlider(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FixedSlider, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FixedSlider, name)
    def __repr__(self):
        return "<C fxcore::FixedSlider instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, FixedSlider, 'this', _demoscript.new_FixedSlider(*args))
        _swig_setattr(self, FixedSlider, 'thisown', 1)
    def update(*args): return _demoscript.FixedSlider_update(*args)
    def setDamping(*args): return _demoscript.FixedSlider_setDamping(*args)
    def getDamping(*args): return _demoscript.FixedSlider_getDamping(*args)
    def setTargetValue(*args): return _demoscript.FixedSlider_setTargetValue(*args)
    def getTargetValue(*args): return _demoscript.FixedSlider_getTargetValue(*args)
    def setMode(*args): return _demoscript.FixedSlider_setMode(*args)
    def setFixPointDamping(*args): return _demoscript.FixedSlider_setFixPointDamping(*args)
    def getFixPointDamping(*args): return _demoscript.FixedSlider_getFixPointDamping(*args)
    def setFixPoint(*args): return _demoscript.FixedSlider_setFixPoint(*args)
    def getFixPoint(*args): return _demoscript.FixedSlider_getFixPoint(*args)
    def __del__(self, destroy=_demoscript.delete_FixedSlider):
        try:
            if self.thisown: destroy(self)
        except: pass

class FixedSliderPtr(FixedSlider):
    def __init__(self, this):
        _swig_setattr(self, FixedSlider, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, FixedSlider, 'thisown', 0)
        _swig_setattr(self, FixedSlider,self.__class__,FixedSlider)
_demoscript.FixedSlider_swigregister(FixedSliderPtr)

class EffectNodeRefCount(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EffectNodeRefCount, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EffectNodeRefCount, name)
    def __repr__(self):
        return "<C pompom::refcount<(fxcore::EffectNode)> instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, EffectNodeRefCount, 'this', _demoscript.new_EffectNodeRefCount(*args))
        _swig_setattr(self, EffectNodeRefCount, 'thisown', 1)
    def setSelfOwn(*args): return _demoscript.EffectNodeRefCount_setSelfOwn(*args)
    def getRefCount(*args): return _demoscript.EffectNodeRefCount_getRefCount(*args)
    def addReference(*args): return _demoscript.EffectNodeRefCount_addReference(*args)
    def release(*args): return _demoscript.EffectNodeRefCount_release(*args)

class EffectNodeRefCountPtr(EffectNodeRefCount):
    def __init__(self, this):
        _swig_setattr(self, EffectNodeRefCount, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, EffectNodeRefCount, 'thisown', 0)
        _swig_setattr(self, EffectNodeRefCount,self.__class__,EffectNodeRefCount)
_demoscript.EffectNodeRefCount_swigregister(EffectNodeRefCountPtr)

class EffectNode(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EffectNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EffectNode, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C fxcore::EffectNode instance at %s>" % (self.this,)
    __swig_setmethods__["effect_name"] = _demoscript.EffectNode_effect_name_set
    __swig_getmethods__["effect_name"] = _demoscript.EffectNode_effect_name_get
    if _newclass:effect_name = property(_demoscript.EffectNode_effect_name_get, _demoscript.EffectNode_effect_name_set)
    def setName(*args): return _demoscript.EffectNode_setName(*args)
    def connectOutput(*args): return _demoscript.EffectNode_connectOutput(*args)
    def disconnectOutput(*args): return _demoscript.EffectNode_disconnectOutput(*args)
    __swig_setmethods__["mix"] = _demoscript.EffectNode_mix_set
    __swig_getmethods__["mix"] = _demoscript.EffectNode_mix_get
    if _newclass:mix = property(_demoscript.EffectNode_mix_get, _demoscript.EffectNode_mix_set)
    def callback(*args): return _demoscript.EffectNode_callback(*args)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_EffectNode(self)
        return weakref_proxy(self)

class EffectNodePtr(EffectNode):
    def __init__(self, this):
        _swig_setattr(self, EffectNode, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, EffectNode, 'thisown', 0)
        _swig_setattr(self, EffectNode,self.__class__,EffectNode)
_demoscript.EffectNode_swigregister(EffectNodePtr)
cvar = _demoscript.cvar
WET = cvar.WET
DRY = cvar.DRY

class SchedulerSingleton(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SchedulerSingleton, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SchedulerSingleton, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C singleton<(fxcore::Scheduler)> instance at %s>" % (self.this,)
    __swig_getmethods__["instance"] = lambda x: _demoscript.SchedulerSingleton_instance
    if _newclass:instance = staticmethod(_demoscript.SchedulerSingleton_instance)
    __swig_getmethods__["const_instance"] = lambda x: _demoscript.SchedulerSingleton_const_instance
    if _newclass:const_instance = staticmethod(_demoscript.SchedulerSingleton_const_instance)

class SchedulerSingletonPtr(SchedulerSingleton):
    def __init__(self, this):
        _swig_setattr(self, SchedulerSingleton, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SchedulerSingleton, 'thisown', 0)
        _swig_setattr(self, SchedulerSingleton,self.__class__,SchedulerSingleton)
_demoscript.SchedulerSingleton_swigregister(SchedulerSingletonPtr)

SchedulerSingleton_instance = _demoscript.SchedulerSingleton_instance

SchedulerSingleton_const_instance = _demoscript.SchedulerSingleton_const_instance

ST_NONE = _demoscript.ST_NONE
ST_AB = _demoscript.ST_AB
ST_BA = _demoscript.ST_BA
SI_A = _demoscript.SI_A
SI_B = _demoscript.SI_B
SI_MIX = _demoscript.SI_MIX
SI_POST = _demoscript.SI_POST
SI_SUPER = _demoscript.SI_SUPER
SI_LAST = _demoscript.SI_LAST
class Job(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Job, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Job, name)
    def __repr__(self):
        return "<C fxcore::Job instance at %s>" % (self.this,)
    __swig_setmethods__["start"] = _demoscript.Job_start_set
    __swig_getmethods__["start"] = _demoscript.Job_start_get
    if _newclass:start = property(_demoscript.Job_start_get, _demoscript.Job_start_set)
    __swig_setmethods__["length"] = _demoscript.Job_length_set
    __swig_getmethods__["length"] = _demoscript.Job_length_get
    if _newclass:length = property(_demoscript.Job_length_get, _demoscript.Job_length_set)
    __swig_setmethods__["effect"] = _demoscript.Job_effect_set
    __swig_getmethods__["effect"] = _demoscript.Job_effect_get
    if _newclass:effect = property(_demoscript.Job_effect_get, _demoscript.Job_effect_set)
    __swig_setmethods__["input"] = _demoscript.Job_input_set
    __swig_getmethods__["input"] = _demoscript.Job_input_get
    if _newclass:input = property(_demoscript.Job_input_get, _demoscript.Job_input_set)
    __swig_setmethods__["layer"] = _demoscript.Job_layer_set
    __swig_getmethods__["layer"] = _demoscript.Job_layer_get
    if _newclass:layer = property(_demoscript.Job_layer_get, _demoscript.Job_layer_set)
    def isActive(*args): return _demoscript.Job_isActive(*args)
    def __init__(self, *args):
        _swig_setattr(self, Job, 'this', _demoscript.new_Job(*args))
        _swig_setattr(self, Job, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Job):
        try:
            if self.thisown: destroy(self)
        except: pass

class JobPtr(Job):
    def __init__(self, this):
        _swig_setattr(self, Job, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Job, 'thisown', 0)
        _swig_setattr(self, Job,self.__class__,Job)
_demoscript.Job_swigregister(JobPtr)

class JobEqual(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, JobEqual, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, JobEqual, name)
    def __repr__(self):
        return "<C fxcore::JobEqual instance at %s>" % (self.this,)
    def __call__(*args): return _demoscript.JobEqual___call__(*args)
    def __init__(self, *args):
        _swig_setattr(self, JobEqual, 'this', _demoscript.new_JobEqual(*args))
        _swig_setattr(self, JobEqual, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_JobEqual):
        try:
            if self.thisown: destroy(self)
        except: pass

class JobEqualPtr(JobEqual):
    def __init__(self, this):
        _swig_setattr(self, JobEqual, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, JobEqual, 'thisown', 0)
        _swig_setattr(self, JobEqual,self.__class__,JobEqual)
_demoscript.JobEqual_swigregister(JobEqualPtr)

class JobLess(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, JobLess, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, JobLess, name)
    def __repr__(self):
        return "<C fxcore::JobLess instance at %s>" % (self.this,)
    def __call__(*args): return _demoscript.JobLess___call__(*args)
    def __init__(self, *args):
        _swig_setattr(self, JobLess, 'this', _demoscript.new_JobLess(*args))
        _swig_setattr(self, JobLess, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_JobLess):
        try:
            if self.thisown: destroy(self)
        except: pass

class JobLessPtr(JobLess):
    def __init__(self, this):
        _swig_setattr(self, JobLess, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, JobLess, 'thisown', 0)
        _swig_setattr(self, JobLess,self.__class__,JobLess)
_demoscript.JobLess_swigregister(JobLessPtr)

class Scheduler(SchedulerSingleton):
    __swig_setmethods__ = {}
    for _s in [SchedulerSingleton]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scheduler, name, value)
    __swig_getmethods__ = {}
    for _s in [SchedulerSingleton]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Scheduler, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C fxcore::Scheduler instance at %s>" % (self.this,)
    def schedule(*args): return _demoscript.Scheduler_schedule(*args)
    def getJobs(*args): return _demoscript.Scheduler_getJobs(*args)
    def render(*args): return _demoscript.Scheduler_render(*args)
    def getTime(*args): return _demoscript.Scheduler_getTime(*args)
    def setTime(*args): return _demoscript.Scheduler_setTime(*args)
    def getLength(*args): return _demoscript.Scheduler_getLength(*args)
    def stop(*args): return _demoscript.Scheduler_stop(*args)
    def __del__(self, destroy=_demoscript.delete_Scheduler):
        try:
            if self.thisown: destroy(self)
        except: pass

class SchedulerPtr(Scheduler):
    def __init__(self, this):
        _swig_setattr(self, Scheduler, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Scheduler, 'thisown', 0)
        _swig_setattr(self, Scheduler,self.__class__,Scheduler)
_demoscript.Scheduler_swigregister(SchedulerPtr)


getTime = _demoscript.getTime

getDelta = _demoscript.getDelta

setTime = _demoscript.setTime

update = _demoscript.update

setDelta = _demoscript.setDelta

seek = _demoscript.seek
class Event(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Event, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Event, name)
    def __repr__(self):
        return "<C pompom::Event instance at %s>" % (self.this,)
    __swig_setmethods__["recorded"] = _demoscript.Event_recorded_set
    __swig_getmethods__["recorded"] = _demoscript.Event_recorded_get
    if _newclass:recorded = property(_demoscript.Event_recorded_get, _demoscript.Event_recorded_set)
    def __init__(self, *args):
        _swig_setattr(self, Event, 'this', _demoscript.new_Event(*args))
        _swig_setattr(self, Event, 'thisown', 1)
    __swig_setmethods__["time"] = _demoscript.Event_time_set
    __swig_getmethods__["time"] = _demoscript.Event_time_get
    if _newclass:time = property(_demoscript.Event_time_get, _demoscript.Event_time_set)
    __swig_setmethods__["name"] = _demoscript.Event_name_set
    __swig_getmethods__["name"] = _demoscript.Event_name_get
    if _newclass:name = property(_demoscript.Event_name_get, _demoscript.Event_name_set)
    __swig_setmethods__["channel"] = _demoscript.Event_channel_set
    __swig_getmethods__["channel"] = _demoscript.Event_channel_get
    if _newclass:channel = property(_demoscript.Event_channel_get, _demoscript.Event_channel_set)
    __swig_setmethods__["command"] = _demoscript.Event_command_set
    __swig_getmethods__["command"] = _demoscript.Event_command_get
    if _newclass:command = property(_demoscript.Event_command_get, _demoscript.Event_command_set)
    __swig_setmethods__["velocity"] = _demoscript.Event_velocity_set
    __swig_getmethods__["velocity"] = _demoscript.Event_velocity_get
    if _newclass:velocity = property(_demoscript.Event_velocity_get, _demoscript.Event_velocity_set)
    __swig_setmethods__["note"] = _demoscript.Event_note_set
    __swig_getmethods__["note"] = _demoscript.Event_note_get
    if _newclass:note = property(_demoscript.Event_note_get, _demoscript.Event_note_set)
    __swig_setmethods__["volume"] = _demoscript.Event_volume_set
    __swig_getmethods__["volume"] = _demoscript.Event_volume_get
    if _newclass:volume = property(_demoscript.Event_volume_get, _demoscript.Event_volume_set)
    __swig_setmethods__["wheel"] = _demoscript.Event_wheel_set
    __swig_getmethods__["wheel"] = _demoscript.Event_wheel_get
    if _newclass:wheel = property(_demoscript.Event_wheel_get, _demoscript.Event_wheel_set)
    __swig_setmethods__["wheelx"] = _demoscript.Event_wheelx_set
    __swig_getmethods__["wheelx"] = _demoscript.Event_wheelx_get
    if _newclass:wheelx = property(_demoscript.Event_wheelx_get, _demoscript.Event_wheelx_set)
    __swig_setmethods__["wheely"] = _demoscript.Event_wheely_set
    __swig_getmethods__["wheely"] = _demoscript.Event_wheely_get
    if _newclass:wheely = property(_demoscript.Event_wheely_get, _demoscript.Event_wheely_set)
    def __eq__(*args): return _demoscript.Event___eq__(*args)
    def serialize(*args): return _demoscript.Event_serialize(*args)
    __swig_getmethods__["deserialize"] = lambda x: _demoscript.Event_deserialize
    if _newclass:deserialize = staticmethod(_demoscript.Event_deserialize)
    def __del__(self, destroy=_demoscript.delete_Event):
        try:
            if self.thisown: destroy(self)
        except: pass

class EventPtr(Event):
    def __init__(self, this):
        _swig_setattr(self, Event, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Event, 'thisown', 0)
        _swig_setattr(self, Event,self.__class__,Event)
_demoscript.Event_swigregister(EventPtr)

Event_deserialize = _demoscript.Event_deserialize

class EventLess(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventLess, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EventLess, name)
    def __repr__(self):
        return "<C pompom::EventLess instance at %s>" % (self.this,)
    def __call__(*args): return _demoscript.EventLess___call__(*args)
    def __init__(self, *args):
        _swig_setattr(self, EventLess, 'this', _demoscript.new_EventLess(*args))
        _swig_setattr(self, EventLess, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_EventLess):
        try:
            if self.thisown: destroy(self)
        except: pass

class EventLessPtr(EventLess):
    def __init__(self, this):
        _swig_setattr(self, EventLess, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, EventLess, 'thisown', 0)
        _swig_setattr(self, EventLess,self.__class__,EventLess)
_demoscript.EventLess_swigregister(EventLessPtr)

EC_NOTE_ON = _demoscript.EC_NOTE_ON
EC_NOTE_OFF = _demoscript.EC_NOTE_OFF
EC_NOTE_CONTROL = _demoscript.EC_NOTE_CONTROL
EC_MODIFIER = _demoscript.EC_MODIFIER
EC_NAVIGATE = _demoscript.EC_NAVIGATE

addMapping = _demoscript.addMapping

playSong = _demoscript.playSong

playModule = _demoscript.playModule

isModulePlaying = _demoscript.isModulePlaying
BMODE_DEFAULTFADE = _demoscript.BMODE_DEFAULTFADE
BMODE_NOFADE = _demoscript.BMODE_NOFADE
class Blender(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Blender, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Blender, name)
    def __repr__(self):
        return "<C fx::Blender instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Blender, 'this', _demoscript.new_Blender(*args))
        _swig_setattr(self, Blender, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Blender):
        try:
            if self.thisown: destroy(self)
        except: pass
    def callback(*args): return _demoscript.Blender_callback(*args)
    def setMode(*args): return _demoscript.Blender_setMode(*args)

class BlenderPtr(Blender):
    def __init__(self, this):
        _swig_setattr(self, Blender, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Blender, 'thisown', 0)
        _swig_setattr(self, Blender,self.__class__,Blender)
_demoscript.Blender_swigregister(BlenderPtr)

getEvent = _demoscript.getEvent

class Blur(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Blur, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Blur, name)
    def __repr__(self):
        return "<C fx::Blur instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == Blur:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Blur, 'this', _demoscript.new_Blur(*args))
        _swig_setattr(self, Blur, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Blur):
        try:
            if self.thisown: destroy(self)
        except: pass
    def callback(*args): return _demoscript.Blur_callback(*args)
    __swig_setmethods__["spread"] = _demoscript.Blur_spread_set
    __swig_getmethods__["spread"] = _demoscript.Blur_spread_get
    if _newclass:spread = property(_demoscript.Blur_spread_get, _demoscript.Blur_spread_set)
    def setAdditive(*args): return _demoscript.Blur_setAdditive(*args)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Blur(self)
        return weakref_proxy(self)

class BlurPtr(Blur):
    def __init__(self, this):
        _swig_setattr(self, Blur, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Blur, 'thisown', 0)
        _swig_setattr(self, Blur,self.__class__,Blur)
_demoscript.Blur_swigregister(BlurPtr)

class llSceneRefCount(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, llSceneRefCount, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, llSceneRefCount, name)
    def __repr__(self):
        return "<C pompom::refcount<(llScene)> instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, llSceneRefCount, 'this', _demoscript.new_llSceneRefCount(*args))
        _swig_setattr(self, llSceneRefCount, 'thisown', 1)
    def setSelfOwn(*args): return _demoscript.llSceneRefCount_setSelfOwn(*args)
    def getRefCount(*args): return _demoscript.llSceneRefCount_getRefCount(*args)
    def addReference(*args): return _demoscript.llSceneRefCount_addReference(*args)
    def release(*args): return _demoscript.llSceneRefCount_release(*args)

class llSceneRefCountPtr(llSceneRefCount):
    def __init__(self, this):
        _swig_setattr(self, llSceneRefCount, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, llSceneRefCount, 'thisown', 0)
        _swig_setattr(self, llSceneRefCount,self.__class__,llSceneRefCount)
_demoscript.llSceneRefCount_swigregister(llSceneRefCountPtr)

class ObjectDict(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ObjectDict, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ObjectDict, name)
    def __repr__(self):
        return "<C std::map<(int,p.llObject)> instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ObjectDict, 'this', _demoscript.new_ObjectDict(*args))
        _swig_setattr(self, ObjectDict, 'thisown', 1)
    def __len__(*args): return _demoscript.ObjectDict___len__(*args)
    def clear(*args): return _demoscript.ObjectDict_clear(*args)
    def __nonzero__(*args): return _demoscript.ObjectDict___nonzero__(*args)
    def __getitem__(*args): return _demoscript.ObjectDict___getitem__(*args)
    def __setitem__(*args): return _demoscript.ObjectDict___setitem__(*args)
    def __delitem__(*args): return _demoscript.ObjectDict___delitem__(*args)
    def has_key(*args): return _demoscript.ObjectDict_has_key(*args)
    def keys(*args): return _demoscript.ObjectDict_keys(*args)
    def values(*args): return _demoscript.ObjectDict_values(*args)
    def items(*args): return _demoscript.ObjectDict_items(*args)
    def __contains__(*args): return _demoscript.ObjectDict___contains__(*args)
    def __iter__(*args): return _demoscript.ObjectDict___iter__(*args)
    def __del__(self, destroy=_demoscript.delete_ObjectDict):
        try:
            if self.thisown: destroy(self)
        except: pass

class ObjectDictPtr(ObjectDict):
    def __init__(self, this):
        _swig_setattr(self, ObjectDict, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ObjectDict, 'thisown', 0)
        _swig_setattr(self, ObjectDict,self.__class__,ObjectDict)
_demoscript.ObjectDict_swigregister(ObjectDictPtr)

class ObjectTuple(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ObjectTuple, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ObjectTuple, name)
    def __repr__(self):
        return "<C std::vector<(p.llObject)> instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ObjectTuple, 'this', _demoscript.new_ObjectTuple(*args))
        _swig_setattr(self, ObjectTuple, 'thisown', 1)
    def __len__(*args): return _demoscript.ObjectTuple___len__(*args)
    def clear(*args): return _demoscript.ObjectTuple_clear(*args)
    def append(*args): return _demoscript.ObjectTuple_append(*args)
    def __nonzero__(*args): return _demoscript.ObjectTuple___nonzero__(*args)
    def pop(*args): return _demoscript.ObjectTuple_pop(*args)
    def __getitem__(*args): return _demoscript.ObjectTuple___getitem__(*args)
    def __getslice__(*args): return _demoscript.ObjectTuple___getslice__(*args)
    def __setitem__(*args): return _demoscript.ObjectTuple___setitem__(*args)
    def __setslice__(*args): return _demoscript.ObjectTuple___setslice__(*args)
    def __delitem__(*args): return _demoscript.ObjectTuple___delitem__(*args)
    def __delslice__(*args): return _demoscript.ObjectTuple___delslice__(*args)
    def __del__(self, destroy=_demoscript.delete_ObjectTuple):
        try:
            if self.thisown: destroy(self)
        except: pass

class ObjectTuplePtr(ObjectTuple):
    def __init__(self, this):
        _swig_setattr(self, ObjectTuple, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ObjectTuple, 'thisown', 0)
        _swig_setattr(self, ObjectTuple,self.__class__,ObjectTuple)
_demoscript.ObjectTuple_swigregister(ObjectTuplePtr)

class MeshTuple(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MeshTuple, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MeshTuple, name)
    def __repr__(self):
        return "<C std::vector<(p.llMesh)> instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MeshTuple, 'this', _demoscript.new_MeshTuple(*args))
        _swig_setattr(self, MeshTuple, 'thisown', 1)
    def __len__(*args): return _demoscript.MeshTuple___len__(*args)
    def clear(*args): return _demoscript.MeshTuple_clear(*args)
    def append(*args): return _demoscript.MeshTuple_append(*args)
    def __nonzero__(*args): return _demoscript.MeshTuple___nonzero__(*args)
    def pop(*args): return _demoscript.MeshTuple_pop(*args)
    def __getitem__(*args): return _demoscript.MeshTuple___getitem__(*args)
    def __getslice__(*args): return _demoscript.MeshTuple___getslice__(*args)
    def __setitem__(*args): return _demoscript.MeshTuple___setitem__(*args)
    def __setslice__(*args): return _demoscript.MeshTuple___setslice__(*args)
    def __delitem__(*args): return _demoscript.MeshTuple___delitem__(*args)
    def __delslice__(*args): return _demoscript.MeshTuple___delslice__(*args)
    def __del__(self, destroy=_demoscript.delete_MeshTuple):
        try:
            if self.thisown: destroy(self)
        except: pass

class MeshTuplePtr(MeshTuple):
    def __init__(self, this):
        _swig_setattr(self, MeshTuple, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MeshTuple, 'thisown', 0)
        _swig_setattr(self, MeshTuple,self.__class__,MeshTuple)
_demoscript.MeshTuple_swigregister(MeshTuplePtr)

class ImageTuple(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImageTuple, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ImageTuple, name)
    def __repr__(self):
        return "<C std::vector<(p.fx::Image)> instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, ImageTuple, 'this', _demoscript.new_ImageTuple(*args))
        _swig_setattr(self, ImageTuple, 'thisown', 1)
    def __len__(*args): return _demoscript.ImageTuple___len__(*args)
    def clear(*args): return _demoscript.ImageTuple_clear(*args)
    def append(*args): return _demoscript.ImageTuple_append(*args)
    def __nonzero__(*args): return _demoscript.ImageTuple___nonzero__(*args)
    def pop(*args): return _demoscript.ImageTuple_pop(*args)
    def __getitem__(*args): return _demoscript.ImageTuple___getitem__(*args)
    def __getslice__(*args): return _demoscript.ImageTuple___getslice__(*args)
    def __setitem__(*args): return _demoscript.ImageTuple___setitem__(*args)
    def __setslice__(*args): return _demoscript.ImageTuple___setslice__(*args)
    def __delitem__(*args): return _demoscript.ImageTuple___delitem__(*args)
    def __delslice__(*args): return _demoscript.ImageTuple___delslice__(*args)
    def __del__(self, destroy=_demoscript.delete_ImageTuple):
        try:
            if self.thisown: destroy(self)
        except: pass

class ImageTuplePtr(ImageTuple):
    def __init__(self, this):
        _swig_setattr(self, ImageTuple, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ImageTuple, 'thisown', 0)
        _swig_setattr(self, ImageTuple,self.__class__,ImageTuple)
_demoscript.ImageTuple_swigregister(ImageTuplePtr)

class llObject(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, llObject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, llObject, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C llObject instance at %s>" % (self.this,)
    __swig_setmethods__["offset"] = _demoscript.llObject_offset_set
    __swig_getmethods__["offset"] = _demoscript.llObject_offset_get
    if _newclass:offset = property(_demoscript.llObject_offset_get, _demoscript.llObject_offset_set)
    __swig_setmethods__["noiseAmplitude"] = _demoscript.llObject_noiseAmplitude_set
    __swig_getmethods__["noiseAmplitude"] = _demoscript.llObject_noiseAmplitude_get
    if _newclass:noiseAmplitude = property(_demoscript.llObject_noiseAmplitude_get, _demoscript.llObject_noiseAmplitude_set)
    __swig_setmethods__["noiseFreq"] = _demoscript.llObject_noiseFreq_set
    __swig_getmethods__["noiseFreq"] = _demoscript.llObject_noiseFreq_get
    if _newclass:noiseFreq = property(_demoscript.llObject_noiseFreq_get, _demoscript.llObject_noiseFreq_set)
    __swig_setmethods__["noiseOffset"] = _demoscript.llObject_noiseOffset_set
    __swig_getmethods__["noiseOffset"] = _demoscript.llObject_noiseOffset_get
    if _newclass:noiseOffset = property(_demoscript.llObject_noiseOffset_get, _demoscript.llObject_noiseOffset_set)
    __swig_setmethods__["red"] = _demoscript.llObject_red_set
    __swig_getmethods__["red"] = _demoscript.llObject_red_get
    if _newclass:red = property(_demoscript.llObject_red_get, _demoscript.llObject_red_set)
    __swig_setmethods__["green"] = _demoscript.llObject_green_set
    __swig_getmethods__["green"] = _demoscript.llObject_green_get
    if _newclass:green = property(_demoscript.llObject_green_get, _demoscript.llObject_green_set)
    __swig_setmethods__["blue"] = _demoscript.llObject_blue_set
    __swig_getmethods__["blue"] = _demoscript.llObject_blue_get
    if _newclass:blue = property(_demoscript.llObject_blue_get, _demoscript.llObject_blue_set)
    __swig_setmethods__["curveTaper"] = _demoscript.llObject_curveTaper_set
    __swig_getmethods__["curveTaper"] = _demoscript.llObject_curveTaper_get
    if _newclass:curveTaper = property(_demoscript.llObject_curveTaper_get, _demoscript.llObject_curveTaper_set)
    __swig_setmethods__["curveLength"] = _demoscript.llObject_curveLength_set
    __swig_getmethods__["curveLength"] = _demoscript.llObject_curveLength_get
    if _newclass:curveLength = property(_demoscript.llObject_curveLength_get, _demoscript.llObject_curveLength_set)
    __swig_setmethods__["curveWidth"] = _demoscript.llObject_curveWidth_set
    __swig_getmethods__["curveWidth"] = _demoscript.llObject_curveWidth_get
    if _newclass:curveWidth = property(_demoscript.llObject_curveWidth_get, _demoscript.llObject_curveWidth_set)
    __swig_setmethods__["curveBumpAmplitude"] = _demoscript.llObject_curveBumpAmplitude_set
    __swig_getmethods__["curveBumpAmplitude"] = _demoscript.llObject_curveBumpAmplitude_get
    if _newclass:curveBumpAmplitude = property(_demoscript.llObject_curveBumpAmplitude_get, _demoscript.llObject_curveBumpAmplitude_set)
    __swig_setmethods__["curveBumpFreq"] = _demoscript.llObject_curveBumpFreq_set
    __swig_getmethods__["curveBumpFreq"] = _demoscript.llObject_curveBumpFreq_get
    if _newclass:curveBumpFreq = property(_demoscript.llObject_curveBumpFreq_get, _demoscript.llObject_curveBumpFreq_set)
    def getAnimationLength(*args): return _demoscript.llObject_getAnimationLength(*args)
    def getName(*args): return _demoscript.llObject_getName(*args)
    __swig_setmethods__["transforms"] = _demoscript.llObject_transforms_set
    __swig_getmethods__["transforms"] = _demoscript.llObject_transforms_get
    if _newclass:transforms = property(_demoscript.llObject_transforms_get, _demoscript.llObject_transforms_set)
    def addTransform(*args): return _demoscript.llObject_addTransform(*args)

class llObjectPtr(llObject):
    def __init__(self, this):
        _swig_setattr(self, llObject, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, llObject, 'thisown', 0)
        _swig_setattr(self, llObject,self.__class__,llObject)
_demoscript.llObject_swigregister(llObjectPtr)

class llScene(llSceneRefCount):
    __swig_setmethods__ = {}
    for _s in [llSceneRefCount]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, llScene, name, value)
    __swig_getmethods__ = {}
    for _s in [llSceneRefCount]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, llScene, name)
    def __repr__(self):
        return "<C llScene instance at %s>" % (self.this,)
    __swig_setmethods__["preproc"] = _demoscript.llScene_preproc_set
    __swig_getmethods__["preproc"] = _demoscript.llScene_preproc_get
    if _newclass:preproc = property(_demoscript.llScene_preproc_get, _demoscript.llScene_preproc_set)
    def __init__(self, *args):
        _swig_setattr(self, llScene, 'this', _demoscript.new_llScene(*args))
        _swig_setattr(self, llScene, 'thisown', 1)
    def getObjects(*args): return _demoscript.llScene_getObjects(*args)
    def getObjectMap(*args): return _demoscript.llScene_getObjectMap(*args)
    __swig_setmethods__["cameras"] = _demoscript.llScene_cameras_set
    __swig_getmethods__["cameras"] = _demoscript.llScene_cameras_get
    if _newclass:cameras = property(_demoscript.llScene_cameras_get, _demoscript.llScene_cameras_set)
    __swig_setmethods__["objects"] = _demoscript.llScene_objects_set
    __swig_getmethods__["objects"] = _demoscript.llScene_objects_get
    if _newclass:objects = property(_demoscript.llScene_objects_get, _demoscript.llScene_objects_set)
    __swig_setmethods__["meshes"] = _demoscript.llScene_meshes_set
    __swig_getmethods__["meshes"] = _demoscript.llScene_meshes_get
    if _newclass:meshes = property(_demoscript.llScene_meshes_get, _demoscript.llScene_meshes_set)
    __swig_setmethods__["matshad"] = _demoscript.llScene_matshad_set
    __swig_getmethods__["matshad"] = _demoscript.llScene_matshad_get
    if _newclass:matshad = property(_demoscript.llScene_matshad_get, _demoscript.llScene_matshad_set)
    __swig_setmethods__["textures"] = _demoscript.llScene_textures_set
    __swig_getmethods__["textures"] = _demoscript.llScene_textures_get
    if _newclass:textures = property(_demoscript.llScene_textures_get, _demoscript.llScene_textures_set)
    __swig_setmethods__["materials"] = _demoscript.llScene_materials_set
    __swig_getmethods__["materials"] = _demoscript.llScene_materials_get
    if _newclass:materials = property(_demoscript.llScene_materials_get, _demoscript.llScene_materials_set)
    def load(*args): return _demoscript.llScene_load(*args)
    def getShader(*args): return _demoscript.llScene_getShader(*args)
    def getObject(*args): return _demoscript.llScene_getObject(*args)

class llScenePtr(llScene):
    def __init__(self, this):
        _swig_setattr(self, llScene, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, llScene, 'thisown', 0)
        _swig_setattr(self, llScene,self.__class__,llScene)
_demoscript.llScene_swigregister(llScenePtr)

class llVertex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, llVertex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, llVertex, name)
    def __repr__(self):
        return "<C llVertex instance at %s>" % (self.this,)
    __swig_setmethods__["x"] = _demoscript.llVertex_x_set
    __swig_getmethods__["x"] = _demoscript.llVertex_x_get
    if _newclass:x = property(_demoscript.llVertex_x_get, _demoscript.llVertex_x_set)
    __swig_setmethods__["y"] = _demoscript.llVertex_y_set
    __swig_getmethods__["y"] = _demoscript.llVertex_y_get
    if _newclass:y = property(_demoscript.llVertex_y_get, _demoscript.llVertex_y_set)
    __swig_setmethods__["z"] = _demoscript.llVertex_z_set
    __swig_getmethods__["z"] = _demoscript.llVertex_z_get
    if _newclass:z = property(_demoscript.llVertex_z_get, _demoscript.llVertex_z_set)
    __swig_setmethods__["nx"] = _demoscript.llVertex_nx_set
    __swig_getmethods__["nx"] = _demoscript.llVertex_nx_get
    if _newclass:nx = property(_demoscript.llVertex_nx_get, _demoscript.llVertex_nx_set)
    __swig_setmethods__["ny"] = _demoscript.llVertex_ny_set
    __swig_getmethods__["ny"] = _demoscript.llVertex_ny_get
    if _newclass:ny = property(_demoscript.llVertex_ny_get, _demoscript.llVertex_ny_set)
    __swig_setmethods__["nz"] = _demoscript.llVertex_nz_set
    __swig_getmethods__["nz"] = _demoscript.llVertex_nz_get
    if _newclass:nz = property(_demoscript.llVertex_nz_get, _demoscript.llVertex_nz_set)
    def __init__(self, *args):
        _swig_setattr(self, llVertex, 'this', _demoscript.new_llVertex(*args))
        _swig_setattr(self, llVertex, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_llVertex):
        try:
            if self.thisown: destroy(self)
        except: pass

class llVertexPtr(llVertex):
    def __init__(self, this):
        _swig_setattr(self, llVertex, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, llVertex, 'thisown', 0)
        _swig_setattr(self, llVertex,self.__class__,llVertex)
_demoscript.llVertex_swigregister(llVertexPtr)

MT_FACES = _demoscript.MT_FACES
MT_LINES = _demoscript.MT_LINES
class llMesh(llObject):
    __swig_setmethods__ = {}
    for _s in [llObject]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, llMesh, name, value)
    __swig_getmethods__ = {}
    for _s in [llObject]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, llMesh, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C llMesh instance at %s>" % (self.this,)

class llMeshPtr(llMesh):
    def __init__(self, this):
        _swig_setattr(self, llMesh, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, llMesh, 'thisown', 0)
        _swig_setattr(self, llMesh,self.__class__,llMesh)
_demoscript.llMesh_swigregister(llMeshPtr)

class llLightSetting(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, llLightSetting, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, llLightSetting, name)
    def __repr__(self):
        return "<C llLightSetting instance at %s>" % (self.this,)
    __swig_setmethods__["time"] = _demoscript.llLightSetting_time_set
    __swig_getmethods__["time"] = _demoscript.llLightSetting_time_get
    if _newclass:time = property(_demoscript.llLightSetting_time_get, _demoscript.llLightSetting_time_set)
    __swig_setmethods__["col"] = _demoscript.llLightSetting_col_set
    __swig_getmethods__["col"] = _demoscript.llLightSetting_col_get
    if _newclass:col = property(_demoscript.llLightSetting_col_get, _demoscript.llLightSetting_col_set)
    __swig_setmethods__["intensity"] = _demoscript.llLightSetting_intensity_set
    __swig_getmethods__["intensity"] = _demoscript.llLightSetting_intensity_get
    if _newclass:intensity = property(_demoscript.llLightSetting_intensity_get, _demoscript.llLightSetting_intensity_set)
    __swig_setmethods__["hotspot_angle"] = _demoscript.llLightSetting_hotspot_angle_set
    __swig_getmethods__["hotspot_angle"] = _demoscript.llLightSetting_hotspot_angle_get
    if _newclass:hotspot_angle = property(_demoscript.llLightSetting_hotspot_angle_get, _demoscript.llLightSetting_hotspot_angle_set)
    __swig_setmethods__["falloff_angle"] = _demoscript.llLightSetting_falloff_angle_set
    __swig_getmethods__["falloff_angle"] = _demoscript.llLightSetting_falloff_angle_get
    if _newclass:falloff_angle = property(_demoscript.llLightSetting_falloff_angle_get, _demoscript.llLightSetting_falloff_angle_set)
    __swig_setmethods__["attenuation_near"] = _demoscript.llLightSetting_attenuation_near_set
    __swig_getmethods__["attenuation_near"] = _demoscript.llLightSetting_attenuation_near_get
    if _newclass:attenuation_near = property(_demoscript.llLightSetting_attenuation_near_get, _demoscript.llLightSetting_attenuation_near_set)
    __swig_setmethods__["attenuation_far"] = _demoscript.llLightSetting_attenuation_far_set
    __swig_getmethods__["attenuation_far"] = _demoscript.llLightSetting_attenuation_far_get
    if _newclass:attenuation_far = property(_demoscript.llLightSetting_attenuation_far_get, _demoscript.llLightSetting_attenuation_far_set)
    def __init__(self, *args):
        _swig_setattr(self, llLightSetting, 'this', _demoscript.new_llLightSetting(*args))
        _swig_setattr(self, llLightSetting, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_llLightSetting):
        try:
            if self.thisown: destroy(self)
        except: pass

class llLightSettingPtr(llLightSetting):
    def __init__(self, this):
        _swig_setattr(self, llLightSetting, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, llLightSetting, 'thisown', 0)
        _swig_setattr(self, llLightSetting,self.__class__,llLightSetting)
_demoscript.llLightSetting_swigregister(llLightSettingPtr)

class llLight(llObject):
    __swig_setmethods__ = {}
    for _s in [llObject]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, llLight, name, value)
    __swig_getmethods__ = {}
    for _s in [llObject]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, llLight, name)
    def __repr__(self):
        return "<C llLight instance at %s>" % (self.this,)
    LL_OMNI = _demoscript.llLight_LL_OMNI
    LL_SPOT = _demoscript.llLight_LL_SPOT
    LL_DIRECTIONAL = _demoscript.llLight_LL_DIRECTIONAL
    def __init__(self, *args):
        _swig_setattr(self, llLight, 'this', _demoscript.new_llLight(*args))
        _swig_setattr(self, llLight, 'thisown', 1)
    __swig_setmethods__["type"] = _demoscript.llLight_type_set
    __swig_getmethods__["type"] = _demoscript.llLight_type_get
    if _newclass:type = property(_demoscript.llLight_type_get, _demoscript.llLight_type_set)
    def getType(*args): return _demoscript.llLight_getType(*args)
    __swig_setmethods__["settings"] = _demoscript.llLight_settings_set
    __swig_getmethods__["settings"] = _demoscript.llLight_settings_get
    if _newclass:settings = property(_demoscript.llLight_settings_get, _demoscript.llLight_settings_set)
    def getSettings(*args): return _demoscript.llLight_getSettings(*args)
    def __del__(self, destroy=_demoscript.delete_llLight):
        try:
            if self.thisown: destroy(self)
        except: pass

class llLightPtr(llLight):
    def __init__(self, this):
        _swig_setattr(self, llLight, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, llLight, 'thisown', 0)
        _swig_setattr(self, llLight,self.__class__,llLight)
_demoscript.llLight_swigregister(llLightPtr)

CT_NORMAL = _demoscript.CT_NORMAL
CT_TRANSFORM = _demoscript.CT_TRANSFORM
CT_USER = _demoscript.CT_USER
class llCameraSetting(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, llCameraSetting, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, llCameraSetting, name)
    def __repr__(self):
        return "<C llCameraSetting instance at %s>" % (self.this,)
    __swig_setmethods__["time"] = _demoscript.llCameraSetting_time_set
    __swig_getmethods__["time"] = _demoscript.llCameraSetting_time_get
    if _newclass:time = property(_demoscript.llCameraSetting_time_get, _demoscript.llCameraSetting_time_set)
    __swig_setmethods__["fov"] = _demoscript.llCameraSetting_fov_set
    __swig_getmethods__["fov"] = _demoscript.llCameraSetting_fov_get
    if _newclass:fov = property(_demoscript.llCameraSetting_fov_get, _demoscript.llCameraSetting_fov_set)
    def __init__(self, *args):
        _swig_setattr(self, llCameraSetting, 'this', _demoscript.new_llCameraSetting(*args))
        _swig_setattr(self, llCameraSetting, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_llCameraSetting):
        try:
            if self.thisown: destroy(self)
        except: pass

class llCameraSettingPtr(llCameraSetting):
    def __init__(self, this):
        _swig_setattr(self, llCameraSetting, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, llCameraSetting, 'thisown', 0)
        _swig_setattr(self, llCameraSetting,self.__class__,llCameraSetting)
_demoscript.llCameraSetting_swigregister(llCameraSettingPtr)

class llCamera(llObject):
    __swig_setmethods__ = {}
    for _s in [llObject]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, llCamera, name, value)
    __swig_getmethods__ = {}
    for _s in [llObject]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, llCamera, name)
    def __repr__(self):
        return "<C llCamera instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, llCamera, 'this', _demoscript.new_llCamera(*args))
        _swig_setattr(self, llCamera, 'thisown', 1)
    def getType(*args): return _demoscript.llCamera_getType(*args)
    __swig_setmethods__["camsettings"] = _demoscript.llCamera_camsettings_set
    __swig_getmethods__["camsettings"] = _demoscript.llCamera_camsettings_get
    if _newclass:camsettings = property(_demoscript.llCamera_camsettings_get, _demoscript.llCamera_camsettings_set)
    def getFov(*args): return _demoscript.llCamera_getFov(*args)
    def getAspectRatio(*args): return _demoscript.llCamera_getAspectRatio(*args)
    def getCameraType(*args): return _demoscript.llCamera_getCameraType(*args)
    def __del__(self, destroy=_demoscript.delete_llCamera):
        try:
            if self.thisown: destroy(self)
        except: pass

class llCameraPtr(llCamera):
    def __init__(self, this):
        _swig_setattr(self, llCamera, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, llCamera, 'thisown', 0)
        _swig_setattr(self, llCamera,self.__class__,llCamera)
_demoscript.llCamera_swigregister(llCameraPtr)

class llUserCamera(llCamera):
    __swig_setmethods__ = {}
    for _s in [llCamera]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, llUserCamera, name, value)
    __swig_getmethods__ = {}
    for _s in [llCamera]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, llUserCamera, name)
    def __repr__(self):
        return "<C llUserCamera instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, llUserCamera, 'this', _demoscript.new_llUserCamera(*args))
        _swig_setattr(self, llUserCamera, 'thisown', 1)
    def getTransform(*args): return _demoscript.llUserCamera_getTransform(*args)
    def get0TransformInv(*args): return _demoscript.llUserCamera_get0TransformInv(*args)
    def getFov(*args): return _demoscript.llUserCamera_getFov(*args)
    def update(*args): return _demoscript.llUserCamera_update(*args)
    def getCameraType(*args): return _demoscript.llUserCamera_getCameraType(*args)
    def yaw(*args): return _demoscript.llUserCamera_yaw(*args)
    def pitch(*args): return _demoscript.llUserCamera_pitch(*args)
    def bank(*args): return _demoscript.llUserCamera_bank(*args)
    def translate(*args): return _demoscript.llUserCamera_translate(*args)
    def __del__(self, destroy=_demoscript.delete_llUserCamera):
        try:
            if self.thisown: destroy(self)
        except: pass

class llUserCameraPtr(llUserCamera):
    def __init__(self, this):
        _swig_setattr(self, llUserCamera, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, llUserCamera, 'thisown', 0)
        _swig_setattr(self, llUserCamera,self.__class__,llUserCamera)
_demoscript.llUserCamera_swigregister(llUserCameraPtr)

class SceneProxy(Resource):
    __swig_setmethods__ = {}
    for _s in [Resource]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, SceneProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [Resource]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, SceneProxy, name)
    def __repr__(self):
        return "<C SceneProxy instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, SceneProxy, 'this', _demoscript.new_SceneProxy(*args))
        _swig_setattr(self, SceneProxy, 'thisown', 1)
    def load(*args): return _demoscript.SceneProxy_load(*args)
    def unload(*args): return _demoscript.SceneProxy_unload(*args)
    def getObjects(*args): return _demoscript.SceneProxy_getObjects(*args)
    def getMeshes(*args): return _demoscript.SceneProxy_getMeshes(*args)
    def getCameras(*args): return _demoscript.SceneProxy_getCameras(*args)
    def getLights(*args): return _demoscript.SceneProxy_getLights(*args)
    def __del__(self, destroy=_demoscript.delete_SceneProxy):
        try:
            if self.thisown: destroy(self)
        except: pass

class SceneProxyPtr(SceneProxy):
    def __init__(self, this):
        _swig_setattr(self, SceneProxy, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SceneProxy, 'thisown', 0)
        _swig_setattr(self, SceneProxy,self.__class__,SceneProxy)
_demoscript.SceneProxy_swigregister(SceneProxyPtr)

SET_TRIANGLES = _demoscript.SET_TRIANGLES
SET_POINTS = _demoscript.SET_POINTS
class SubMeshLess(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubMeshLess, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SubMeshLess, name)
    def __repr__(self):
        return "<C SubMeshLess instance at %s>" % (self.this,)
    def __call__(*args): return _demoscript.SubMeshLess___call__(*args)
    def __init__(self, *args):
        _swig_setattr(self, SubMeshLess, 'this', _demoscript.new_SubMeshLess(*args))
        _swig_setattr(self, SubMeshLess, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_SubMeshLess):
        try:
            if self.thisown: destroy(self)
        except: pass

class SubMeshLessPtr(SubMeshLess):
    def __init__(self, this):
        _swig_setattr(self, SubMeshLess, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SubMeshLess, 'thisown', 0)
        _swig_setattr(self, SubMeshLess,self.__class__,SubMeshLess)
_demoscript.SubMeshLess_swigregister(SubMeshLessPtr)

class Scene(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scene, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Scene, name)
    def __repr__(self):
        return "<C Scene instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == Scene:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Scene, 'this', _demoscript.new_Scene(*args))
        _swig_setattr(self, Scene, 'thisown', 1)
    __swig_setmethods__["speed"] = _demoscript.Scene_speed_set
    __swig_getmethods__["speed"] = _demoscript.Scene_speed_get
    if _newclass:speed = property(_demoscript.Scene_speed_get, _demoscript.Scene_speed_set)
    __swig_setmethods__["offset"] = _demoscript.Scene_offset_set
    __swig_getmethods__["offset"] = _demoscript.Scene_offset_get
    if _newclass:offset = property(_demoscript.Scene_offset_get, _demoscript.Scene_offset_set)
    def callback(*args): return _demoscript.Scene_callback(*args)
    __swig_setmethods__["usercam"] = _demoscript.Scene_usercam_set
    __swig_getmethods__["usercam"] = _demoscript.Scene_usercam_get
    if _newclass:usercam = property(_demoscript.Scene_usercam_get, _demoscript.Scene_usercam_set)
    def getScene(*args): return _demoscript.Scene_getScene(*args)
    def setScene(*args): return _demoscript.Scene_setScene(*args)
    def setCamera(*args): return _demoscript.Scene_setCamera(*args)
    def getNumCameras(*args): return _demoscript.Scene_getNumCameras(*args)
    def nextCamera(*args): return _demoscript.Scene_nextCamera(*args)
    def prevCamera(*args): return _demoscript.Scene_prevCamera(*args)
    def cameraAnimEnded(*args): return _demoscript.Scene_cameraAnimEnded(*args)
    def reset(*args): return _demoscript.Scene_reset(*args)
    def getActiveCamera(*args): return _demoscript.Scene_getActiveCamera(*args)
    def attachEffect(*args): return _demoscript.Scene_attachEffect(*args)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Scene(self)
        return weakref_proxy(self)

class ScenePtr(Scene):
    def __init__(self, this):
        _swig_setattr(self, Scene, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Scene, 'thisown', 0)
        _swig_setattr(self, Scene,self.__class__,Scene)
_demoscript.Scene_swigregister(ScenePtr)

class SceneEffect(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, SceneEffect, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, SceneEffect, name)
    def __repr__(self):
        return "<C fx::SceneEffect instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == SceneEffect:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, SceneEffect, 'this', _demoscript.new_SceneEffect(*args))
        _swig_setattr(self, SceneEffect, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_SceneEffect):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_SceneEffect(self)
        return weakref_proxy(self)

class SceneEffectPtr(SceneEffect):
    def __init__(self, this):
        _swig_setattr(self, SceneEffect, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SceneEffect, 'thisown', 0)
        _swig_setattr(self, SceneEffect,self.__class__,SceneEffect)
_demoscript.SceneEffect_swigregister(SceneEffectPtr)

class RGBMix(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, RGBMix, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, RGBMix, name)
    def __repr__(self):
        return "<C fx::RGBMix instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, RGBMix, 'this', _demoscript.new_RGBMix(*args))
        _swig_setattr(self, RGBMix, 'thisown', 1)
    def setRed(*args): return _demoscript.RGBMix_setRed(*args)
    def setGreen(*args): return _demoscript.RGBMix_setGreen(*args)
    def setBlue(*args): return _demoscript.RGBMix_setBlue(*args)
    def callback(*args): return _demoscript.RGBMix_callback(*args)
    def __del__(self, destroy=_demoscript.delete_RGBMix):
        try:
            if self.thisown: destroy(self)
        except: pass

class RGBMixPtr(RGBMix):
    def __init__(self, this):
        _swig_setattr(self, RGBMix, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, RGBMix, 'thisown', 0)
        _swig_setattr(self, RGBMix,self.__class__,RGBMix)
_demoscript.RGBMix_swigregister(RGBMixPtr)

class RGBMap(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, RGBMap, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, RGBMap, name)
    def __repr__(self):
        return "<C fx::RGBMap instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == RGBMap:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, RGBMap, 'this', _demoscript.new_RGBMap(*args))
        _swig_setattr(self, RGBMap, 'thisown', 1)
    def callback(*args): return _demoscript.RGBMap_callback(*args)
    def __del__(self, destroy=_demoscript.delete_RGBMap):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_RGBMap(self)
        return weakref_proxy(self)

class RGBMapPtr(RGBMap):
    def __init__(self, this):
        _swig_setattr(self, RGBMap, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, RGBMap, 'thisown', 0)
        _swig_setattr(self, RGBMap,self.__class__,RGBMap)
_demoscript.RGBMap_swigregister(RGBMapPtr)

class Ripple(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Ripple, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Ripple, name)
    def __repr__(self):
        return "<C fx::Ripple instance at %s>" % (self.this,)
    def callback(*args): return _demoscript.Ripple_callback(*args)
    def __init__(self, *args):
        _swig_setattr(self, Ripple, 'this', _demoscript.new_Ripple(*args))
        _swig_setattr(self, Ripple, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Ripple):
        try:
            if self.thisown: destroy(self)
        except: pass
    __swig_setmethods__["amplitude"] = _demoscript.Ripple_amplitude_set
    __swig_getmethods__["amplitude"] = _demoscript.Ripple_amplitude_get
    if _newclass:amplitude = property(_demoscript.Ripple_amplitude_get, _demoscript.Ripple_amplitude_set)
    __swig_setmethods__["waves"] = _demoscript.Ripple_waves_set
    __swig_getmethods__["waves"] = _demoscript.Ripple_waves_get
    if _newclass:waves = property(_demoscript.Ripple_waves_get, _demoscript.Ripple_waves_set)
    __swig_setmethods__["speed"] = _demoscript.Ripple_speed_set
    __swig_getmethods__["speed"] = _demoscript.Ripple_speed_get
    if _newclass:speed = property(_demoscript.Ripple_speed_get, _demoscript.Ripple_speed_set)
    __swig_setmethods__["scrollx"] = _demoscript.Ripple_scrollx_set
    __swig_getmethods__["scrollx"] = _demoscript.Ripple_scrollx_get
    if _newclass:scrollx = property(_demoscript.Ripple_scrollx_get, _demoscript.Ripple_scrollx_set)
    __swig_setmethods__["scrolly"] = _demoscript.Ripple_scrolly_set
    __swig_getmethods__["scrolly"] = _demoscript.Ripple_scrolly_get
    if _newclass:scrolly = property(_demoscript.Ripple_scrolly_get, _demoscript.Ripple_scrolly_set)

class RipplePtr(Ripple):
    def __init__(self, this):
        _swig_setattr(self, Ripple, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Ripple, 'thisown', 0)
        _swig_setattr(self, Ripple,self.__class__,Ripple)
_demoscript.Ripple_swigregister(RipplePtr)

class Ripple2(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Ripple2, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Ripple2, name)
    def __repr__(self):
        return "<C fx::Ripple2 instance at %s>" % (self.this,)
    def callback(*args): return _demoscript.Ripple2_callback(*args)
    def __init__(self, *args):
        if self.__class__ == Ripple2:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Ripple2, 'this', _demoscript.new_Ripple2(*args))
        _swig_setattr(self, Ripple2, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Ripple2):
        try:
            if self.thisown: destroy(self)
        except: pass
    __swig_setmethods__["amplitude"] = _demoscript.Ripple2_amplitude_set
    __swig_getmethods__["amplitude"] = _demoscript.Ripple2_amplitude_get
    if _newclass:amplitude = property(_demoscript.Ripple2_amplitude_get, _demoscript.Ripple2_amplitude_set)
    __swig_setmethods__["waves"] = _demoscript.Ripple2_waves_set
    __swig_getmethods__["waves"] = _demoscript.Ripple2_waves_get
    if _newclass:waves = property(_demoscript.Ripple2_waves_get, _demoscript.Ripple2_waves_set)
    __swig_setmethods__["speed"] = _demoscript.Ripple2_speed_set
    __swig_getmethods__["speed"] = _demoscript.Ripple2_speed_get
    if _newclass:speed = property(_demoscript.Ripple2_speed_get, _demoscript.Ripple2_speed_set)
    __swig_setmethods__["offset"] = _demoscript.Ripple2_offset_set
    __swig_getmethods__["offset"] = _demoscript.Ripple2_offset_get
    if _newclass:offset = property(_demoscript.Ripple2_offset_get, _demoscript.Ripple2_offset_set)
    __swig_setmethods__["scrollx"] = _demoscript.Ripple2_scrollx_set
    __swig_getmethods__["scrollx"] = _demoscript.Ripple2_scrollx_get
    if _newclass:scrollx = property(_demoscript.Ripple2_scrollx_get, _demoscript.Ripple2_scrollx_set)
    __swig_setmethods__["scrolly"] = _demoscript.Ripple2_scrolly_set
    __swig_getmethods__["scrolly"] = _demoscript.Ripple2_scrolly_get
    if _newclass:scrolly = property(_demoscript.Ripple2_scrolly_get, _demoscript.Ripple2_scrolly_set)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Ripple2(self)
        return weakref_proxy(self)

class Ripple2Ptr(Ripple2):
    def __init__(self, this):
        _swig_setattr(self, Ripple2, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Ripple2, 'thisown', 0)
        _swig_setattr(self, Ripple2,self.__class__,Ripple2)
_demoscript.Ripple2_swigregister(Ripple2Ptr)

class MGGamma(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MGGamma, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MGGamma, name)
    def __repr__(self):
        return "<C fx::MGGamma instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == MGGamma:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, MGGamma, 'this', _demoscript.new_MGGamma(*args))
        _swig_setattr(self, MGGamma, 'thisown', 1)
    def callback(*args): return _demoscript.MGGamma_callback(*args)
    __swig_setmethods__["red"] = _demoscript.MGGamma_red_set
    __swig_getmethods__["red"] = _demoscript.MGGamma_red_get
    if _newclass:red = property(_demoscript.MGGamma_red_get, _demoscript.MGGamma_red_set)
    __swig_setmethods__["green"] = _demoscript.MGGamma_green_set
    __swig_getmethods__["green"] = _demoscript.MGGamma_green_get
    if _newclass:green = property(_demoscript.MGGamma_green_get, _demoscript.MGGamma_green_set)
    __swig_setmethods__["blue"] = _demoscript.MGGamma_blue_set
    __swig_getmethods__["blue"] = _demoscript.MGGamma_blue_get
    if _newclass:blue = property(_demoscript.MGGamma_blue_get, _demoscript.MGGamma_blue_set)
    def __del__(self, destroy=_demoscript.delete_MGGamma):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_MGGamma(self)
        return weakref_proxy(self)

class MGGammaPtr(MGGamma):
    def __init__(self, this):
        _swig_setattr(self, MGGamma, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MGGamma, 'thisown', 0)
        _swig_setattr(self, MGGamma,self.__class__,MGGamma)
_demoscript.MGGamma_swigregister(MGGammaPtr)

class MGOverflow(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MGOverflow, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MGOverflow, name)
    def __repr__(self):
        return "<C fx::MGOverflow instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == MGOverflow:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, MGOverflow, 'this', _demoscript.new_MGOverflow(*args))
        _swig_setattr(self, MGOverflow, 'thisown', 1)
    def callback(*args): return _demoscript.MGOverflow_callback(*args)
    __swig_setmethods__["red"] = _demoscript.MGOverflow_red_set
    __swig_getmethods__["red"] = _demoscript.MGOverflow_red_get
    if _newclass:red = property(_demoscript.MGOverflow_red_get, _demoscript.MGOverflow_red_set)
    __swig_setmethods__["green"] = _demoscript.MGOverflow_green_set
    __swig_getmethods__["green"] = _demoscript.MGOverflow_green_get
    if _newclass:green = property(_demoscript.MGOverflow_green_get, _demoscript.MGOverflow_green_set)
    __swig_setmethods__["blue"] = _demoscript.MGOverflow_blue_set
    __swig_getmethods__["blue"] = _demoscript.MGOverflow_blue_get
    if _newclass:blue = property(_demoscript.MGOverflow_blue_get, _demoscript.MGOverflow_blue_set)
    def __del__(self, destroy=_demoscript.delete_MGOverflow):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_MGOverflow(self)
        return weakref_proxy(self)

class MGOverflowPtr(MGOverflow):
    def __init__(self, this):
        _swig_setattr(self, MGOverflow, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MGOverflow, 'thisown', 0)
        _swig_setattr(self, MGOverflow,self.__class__,MGOverflow)
_demoscript.MGOverflow_swigregister(MGOverflowPtr)

class Add(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Add, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Add, name)
    def __repr__(self):
        return "<C fx::Add instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Add, 'this', _demoscript.new_Add(*args))
        _swig_setattr(self, Add, 'thisown', 1)
    def callback(*args): return _demoscript.Add_callback(*args)
    def __del__(self, destroy=_demoscript.delete_Add):
        try:
            if self.thisown: destroy(self)
        except: pass

class AddPtr(Add):
    def __init__(self, this):
        _swig_setattr(self, Add, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Add, 'thisown', 0)
        _swig_setattr(self, Add,self.__class__,Add)
_demoscript.Add_swigregister(AddPtr)

OM_NORMAL = _demoscript.OM_NORMAL
OM_FILL = _demoscript.OM_FILL
class Over(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Over, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Over, name)
    def __repr__(self):
        return "<C fx::Over instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == Over:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Over, 'this', _demoscript.new_Over(*args))
        _swig_setattr(self, Over, 'thisown', 1)
    def callback(*args): return _demoscript.Over_callback(*args)
    def setMode(*args): return _demoscript.Over_setMode(*args)
    __swig_setmethods__["red"] = _demoscript.Over_red_set
    __swig_getmethods__["red"] = _demoscript.Over_red_get
    if _newclass:red = property(_demoscript.Over_red_get, _demoscript.Over_red_set)
    __swig_setmethods__["green"] = _demoscript.Over_green_set
    __swig_getmethods__["green"] = _demoscript.Over_green_get
    if _newclass:green = property(_demoscript.Over_green_get, _demoscript.Over_green_set)
    __swig_setmethods__["blue"] = _demoscript.Over_blue_set
    __swig_getmethods__["blue"] = _demoscript.Over_blue_get
    if _newclass:blue = property(_demoscript.Over_blue_get, _demoscript.Over_blue_set)
    __swig_setmethods__["fillOpacity"] = _demoscript.Over_fillOpacity_set
    __swig_getmethods__["fillOpacity"] = _demoscript.Over_fillOpacity_get
    if _newclass:fillOpacity = property(_demoscript.Over_fillOpacity_get, _demoscript.Over_fillOpacity_set)
    def __del__(self, destroy=_demoscript.delete_Over):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Over(self)
        return weakref_proxy(self)

class OverPtr(Over):
    def __init__(self, this):
        _swig_setattr(self, Over, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Over, 'thisown', 0)
        _swig_setattr(self, Over,self.__class__,Over)
_demoscript.Over_swigregister(OverPtr)

class Subtract(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Subtract, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Subtract, name)
    def __repr__(self):
        return "<C fx::Subtract instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Subtract, 'this', _demoscript.new_Subtract(*args))
        _swig_setattr(self, Subtract, 'thisown', 1)
    def callback(*args): return _demoscript.Subtract_callback(*args)
    def __del__(self, destroy=_demoscript.delete_Subtract):
        try:
            if self.thisown: destroy(self)
        except: pass

class SubtractPtr(Subtract):
    def __init__(self, this):
        _swig_setattr(self, Subtract, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Subtract, 'thisown', 0)
        _swig_setattr(self, Subtract,self.__class__,Subtract)
_demoscript.Subtract_swigregister(SubtractPtr)

class Multiply(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Multiply, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Multiply, name)
    def __repr__(self):
        return "<C fx::Multiply instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Multiply, 'this', _demoscript.new_Multiply(*args))
        _swig_setattr(self, Multiply, 'thisown', 1)
    def callback(*args): return _demoscript.Multiply_callback(*args)
    __swig_setmethods__["aFactor"] = _demoscript.Multiply_aFactor_set
    __swig_getmethods__["aFactor"] = _demoscript.Multiply_aFactor_get
    if _newclass:aFactor = property(_demoscript.Multiply_aFactor_get, _demoscript.Multiply_aFactor_set)
    __swig_setmethods__["bFactor"] = _demoscript.Multiply_bFactor_set
    __swig_getmethods__["bFactor"] = _demoscript.Multiply_bFactor_get
    if _newclass:bFactor = property(_demoscript.Multiply_bFactor_get, _demoscript.Multiply_bFactor_set)
    def __del__(self, destroy=_demoscript.delete_Multiply):
        try:
            if self.thisown: destroy(self)
        except: pass

class MultiplyPtr(Multiply):
    def __init__(self, this):
        _swig_setattr(self, Multiply, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Multiply, 'thisown', 0)
        _swig_setattr(self, Multiply,self.__class__,Multiply)
_demoscript.Multiply_swigregister(MultiplyPtr)

class Bitmap(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bitmap, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Bitmap, name)
    def __repr__(self):
        return "<C fx::Bitmap instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Bitmap, 'this', _demoscript.new_Bitmap(*args))
        _swig_setattr(self, Bitmap, 'thisown', 1)
    def callback(*args): return _demoscript.Bitmap_callback(*args)

class BitmapPtr(Bitmap):
    def __init__(self, this):
        _swig_setattr(self, Bitmap, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Bitmap, 'thisown', 0)
        _swig_setattr(self, Bitmap,self.__class__,Bitmap)
_demoscript.Bitmap_swigregister(BitmapPtr)

class Displace(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Displace, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Displace, name)
    def __repr__(self):
        return "<C fx::Displace instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Displace, 'this', _demoscript.new_Displace(*args))
        _swig_setattr(self, Displace, 'thisown', 1)
    def callback(*args): return _demoscript.Displace_callback(*args)
    def __del__(self, destroy=_demoscript.delete_Displace):
        try:
            if self.thisown: destroy(self)
        except: pass

class DisplacePtr(Displace):
    def __init__(self, this):
        _swig_setattr(self, Displace, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Displace, 'thisown', 0)
        _swig_setattr(self, Displace,self.__class__,Displace)
_demoscript.Displace_swigregister(DisplacePtr)

class XFade(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, XFade, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, XFade, name)
    def __repr__(self):
        return "<C fx::XFade instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, XFade, 'this', _demoscript.new_XFade(*args))
        _swig_setattr(self, XFade, 'thisown', 1)
    def callback(*args): return _demoscript.XFade_callback(*args)
    def __del__(self, destroy=_demoscript.delete_XFade):
        try:
            if self.thisown: destroy(self)
        except: pass

class XFadePtr(XFade):
    def __init__(self, this):
        _swig_setattr(self, XFade, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XFade, 'thisown', 0)
        _swig_setattr(self, XFade,self.__class__,XFade)
_demoscript.XFade_swigregister(XFadePtr)

class Distort(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Distort, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Distort, name)
    def __repr__(self):
        return "<C fx::Distort instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == Distort:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Distort, 'this', _demoscript.new_Distort(*args))
        _swig_setattr(self, Distort, 'thisown', 1)
    def callback(*args): return _demoscript.Distort_callback(*args)
    __swig_setmethods__["amount"] = _demoscript.Distort_amount_set
    __swig_getmethods__["amount"] = _demoscript.Distort_amount_get
    if _newclass:amount = property(_demoscript.Distort_amount_get, _demoscript.Distort_amount_set)
    def __del__(self, destroy=_demoscript.delete_Distort):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Distort(self)
        return weakref_proxy(self)

class DistortPtr(Distort):
    def __init__(self, this):
        _swig_setattr(self, Distort, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Distort, 'thisown', 0)
        _swig_setattr(self, Distort,self.__class__,Distort)
_demoscript.Distort_swigregister(DistortPtr)

class Overlay(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Overlay, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Overlay, name)
    def __repr__(self):
        return "<C fx::Overlay instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == Overlay:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Overlay, 'this', _demoscript.new_Overlay(*args))
        _swig_setattr(self, Overlay, 'thisown', 1)
    def callback(*args): return _demoscript.Overlay_callback(*args)
    __swig_setmethods__["opacity"] = _demoscript.Overlay_opacity_set
    __swig_getmethods__["opacity"] = _demoscript.Overlay_opacity_get
    if _newclass:opacity = property(_demoscript.Overlay_opacity_get, _demoscript.Overlay_opacity_set)
    __swig_setmethods__["posx"] = _demoscript.Overlay_posx_set
    __swig_getmethods__["posx"] = _demoscript.Overlay_posx_get
    if _newclass:posx = property(_demoscript.Overlay_posx_get, _demoscript.Overlay_posx_set)
    __swig_setmethods__["posy"] = _demoscript.Overlay_posy_set
    __swig_getmethods__["posy"] = _demoscript.Overlay_posy_get
    if _newclass:posy = property(_demoscript.Overlay_posy_get, _demoscript.Overlay_posy_set)
    __swig_setmethods__["scale"] = _demoscript.Overlay_scale_set
    __swig_getmethods__["scale"] = _demoscript.Overlay_scale_get
    if _newclass:scale = property(_demoscript.Overlay_scale_get, _demoscript.Overlay_scale_set)
    __swig_setmethods__["rotation"] = _demoscript.Overlay_rotation_set
    __swig_getmethods__["rotation"] = _demoscript.Overlay_rotation_get
    if _newclass:rotation = property(_demoscript.Overlay_rotation_get, _demoscript.Overlay_rotation_set)
    def __del__(self, destroy=_demoscript.delete_Overlay):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Overlay(self)
        return weakref_proxy(self)

class OverlayPtr(Overlay):
    def __init__(self, this):
        _swig_setattr(self, Overlay, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Overlay, 'thisown', 0)
        _swig_setattr(self, Overlay,self.__class__,Overlay)
_demoscript.Overlay_swigregister(OverlayPtr)

class MotionBlur(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MotionBlur, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MotionBlur, name)
    def __repr__(self):
        return "<C fx::MotionBlur instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, MotionBlur, 'this', _demoscript.new_MotionBlur(*args))
        _swig_setattr(self, MotionBlur, 'thisown', 1)
    __swig_setmethods__["blur"] = _demoscript.MotionBlur_blur_set
    __swig_getmethods__["blur"] = _demoscript.MotionBlur_blur_get
    if _newclass:blur = property(_demoscript.MotionBlur_blur_get, _demoscript.MotionBlur_blur_set)
    def callback(*args): return _demoscript.MotionBlur_callback(*args)
    def __del__(self, destroy=_demoscript.delete_MotionBlur):
        try:
            if self.thisown: destroy(self)
        except: pass

class MotionBlurPtr(MotionBlur):
    def __init__(self, this):
        _swig_setattr(self, MotionBlur, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MotionBlur, 'thisown', 0)
        _swig_setattr(self, MotionBlur,self.__class__,MotionBlur)
_demoscript.MotionBlur_swigregister(MotionBlurPtr)

class Overflow(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Overflow, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Overflow, name)
    def __repr__(self):
        return "<C fx::Overflow instance at %s>" % (self.this,)
    __swig_setmethods__["red"] = _demoscript.Overflow_red_set
    __swig_getmethods__["red"] = _demoscript.Overflow_red_get
    if _newclass:red = property(_demoscript.Overflow_red_get, _demoscript.Overflow_red_set)
    __swig_setmethods__["green"] = _demoscript.Overflow_green_set
    __swig_getmethods__["green"] = _demoscript.Overflow_green_get
    if _newclass:green = property(_demoscript.Overflow_green_get, _demoscript.Overflow_green_set)
    __swig_setmethods__["blue"] = _demoscript.Overflow_blue_set
    __swig_getmethods__["blue"] = _demoscript.Overflow_blue_get
    if _newclass:blue = property(_demoscript.Overflow_blue_get, _demoscript.Overflow_blue_set)
    def callback(*args): return _demoscript.Overflow_callback(*args)
    def __init__(self, *args):
        if self.__class__ == Overflow:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Overflow, 'this', _demoscript.new_Overflow(*args))
        _swig_setattr(self, Overflow, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Overflow):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Overflow(self)
        return weakref_proxy(self)

class OverflowPtr(Overflow):
    def __init__(self, this):
        _swig_setattr(self, Overflow, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Overflow, 'thisown', 0)
        _swig_setattr(self, Overflow,self.__class__,Overflow)
_demoscript.Overflow_swigregister(OverflowPtr)

class Noise(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Noise, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Noise, name)
    def __repr__(self):
        return "<C fx::Noise instance at %s>" % (self.this,)
    def callback(*args): return _demoscript.Noise_callback(*args)
    def __init__(self, *args):
        if self.__class__ == Noise:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Noise, 'this', _demoscript.new_Noise(*args))
        _swig_setattr(self, Noise, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Noise):
        try:
            if self.thisown: destroy(self)
        except: pass
    __swig_setmethods__["spread"] = _demoscript.Noise_spread_set
    __swig_getmethods__["spread"] = _demoscript.Noise_spread_get
    if _newclass:spread = property(_demoscript.Noise_spread_get, _demoscript.Noise_spread_set)
    __swig_setmethods__["frequency"] = _demoscript.Noise_frequency_set
    __swig_getmethods__["frequency"] = _demoscript.Noise_frequency_get
    if _newclass:frequency = property(_demoscript.Noise_frequency_get, _demoscript.Noise_frequency_set)
    __swig_setmethods__["intensity"] = _demoscript.Noise_intensity_set
    __swig_getmethods__["intensity"] = _demoscript.Noise_intensity_get
    if _newclass:intensity = property(_demoscript.Noise_intensity_get, _demoscript.Noise_intensity_set)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Noise(self)
        return weakref_proxy(self)

class NoisePtr(Noise):
    def __init__(self, this):
        _swig_setattr(self, Noise, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Noise, 'thisown', 0)
        _swig_setattr(self, Noise,self.__class__,Noise)
_demoscript.Noise_swigregister(NoisePtr)

class VintageNoise(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, VintageNoise, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, VintageNoise, name)
    def __repr__(self):
        return "<C fx::VintageNoise instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, VintageNoise, 'this', _demoscript.new_VintageNoise(*args))
        _swig_setattr(self, VintageNoise, 'thisown', 1)
    def render(*args): return _demoscript.VintageNoise_render(*args)
    def addBitmap(*args): return _demoscript.VintageNoise_addBitmap(*args)

class VintageNoisePtr(VintageNoise):
    def __init__(self, this):
        _swig_setattr(self, VintageNoise, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, VintageNoise, 'thisown', 0)
        _swig_setattr(self, VintageNoise,self.__class__,VintageNoise)
_demoscript.VintageNoise_swigregister(VintageNoisePtr)

class Image(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Image, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Image, name)
    def __repr__(self):
        return "<C fx::Image instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == Image:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Image, 'this', _demoscript.new_Image(*args))
        _swig_setattr(self, Image, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Image):
        try:
            if self.thisown: destroy(self)
        except: pass
    def swapOut(*args): return _demoscript.Image_swapOut(*args)
    def getAdditive(*args): return _demoscript.Image_getAdditive(*args)
    def setAdditive(*args): return _demoscript.Image_setAdditive(*args)
    def setScaleX(*args): return _demoscript.Image_setScaleX(*args)
    def setScaleY(*args): return _demoscript.Image_setScaleY(*args)
    def setPos(*args): return _demoscript.Image_setPos(*args)
    def slidePos(*args): return _demoscript.Image_slidePos(*args)
    def setOpacity(*args): return _demoscript.Image_setOpacity(*args)
    def update(*args): return _demoscript.Image_update(*args)
    def getPosX(*args): return _demoscript.Image_getPosX(*args)
    def getPosY(*args): return _demoscript.Image_getPosY(*args)
    def getScaleX(*args): return _demoscript.Image_getScaleX(*args)
    def getScaleY(*args): return _demoscript.Image_getScaleY(*args)
    def getOpacity(*args): return _demoscript.Image_getOpacity(*args)
    def revive(*args): return _demoscript.Image_revive(*args)
    __swig_setmethods__["opacity"] = _demoscript.Image_opacity_set
    __swig_getmethods__["opacity"] = _demoscript.Image_opacity_get
    if _newclass:opacity = property(_demoscript.Image_opacity_get, _demoscript.Image_opacity_set)
    __swig_setmethods__["posX"] = _demoscript.Image_posX_set
    __swig_getmethods__["posX"] = _demoscript.Image_posX_get
    if _newclass:posX = property(_demoscript.Image_posX_get, _demoscript.Image_posX_set)
    __swig_setmethods__["posY"] = _demoscript.Image_posY_set
    __swig_getmethods__["posY"] = _demoscript.Image_posY_get
    if _newclass:posY = property(_demoscript.Image_posY_get, _demoscript.Image_posY_set)
    __swig_setmethods__["scaleX"] = _demoscript.Image_scaleX_set
    __swig_getmethods__["scaleX"] = _demoscript.Image_scaleX_get
    if _newclass:scaleX = property(_demoscript.Image_scaleX_get, _demoscript.Image_scaleX_set)
    __swig_setmethods__["scaleY"] = _demoscript.Image_scaleY_set
    __swig_getmethods__["scaleY"] = _demoscript.Image_scaleY_get
    if _newclass:scaleY = property(_demoscript.Image_scaleY_get, _demoscript.Image_scaleY_set)
    __swig_setmethods__["alive"] = _demoscript.Image_alive_set
    __swig_getmethods__["alive"] = _demoscript.Image_alive_get
    if _newclass:alive = property(_demoscript.Image_alive_get, _demoscript.Image_alive_set)
    def addToSequencer(*args): return _demoscript.Image_addToSequencer(*args)
    def getTransform(*args): return _demoscript.Image_getTransform(*args)
    def callback(*args): return _demoscript.Image_callback(*args)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Image(self)
        return weakref_proxy(self)

class ImagePtr(Image):
    def __init__(self, this):
        _swig_setattr(self, Image, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Image, 'thisown', 0)
        _swig_setattr(self, Image,self.__class__,Image)
_demoscript.Image_swigregister(ImagePtr)

class ImageSeq(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImageSeq, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, ImageSeq, name)
    def __repr__(self):
        return "<C fx::ImageSeq instance at %s>" % (self.this,)
    __swig_setmethods__["opacity"] = _demoscript.ImageSeq_opacity_set
    __swig_getmethods__["opacity"] = _demoscript.ImageSeq_opacity_get
    if _newclass:opacity = property(_demoscript.ImageSeq_opacity_get, _demoscript.ImageSeq_opacity_set)
    def callback(*args): return _demoscript.ImageSeq_callback(*args)
    def addImage(*args): return _demoscript.ImageSeq_addImage(*args)
    def addImageHack(*args): return _demoscript.ImageSeq_addImageHack(*args)
    def __init__(self, *args):
        if self.__class__ == ImageSeq:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, ImageSeq, 'this', _demoscript.new_ImageSeq(*args))
        _swig_setattr(self, ImageSeq, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_ImageSeq):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getImages(*args): return _demoscript.ImageSeq_getImages(*args)
    def next(*args): return _demoscript.ImageSeq_next(*args)
    def prev(*args): return _demoscript.ImageSeq_prev(*args)
    def take(*args): return _demoscript.ImageSeq_take(*args)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_ImageSeq(self)
        return weakref_proxy(self)

class ImageSeqPtr(ImageSeq):
    def __init__(self, this):
        _swig_setattr(self, ImageSeq, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ImageSeq, 'thisown', 0)
        _swig_setattr(self, ImageSeq,self.__class__,ImageSeq)
_demoscript.ImageSeq_swigregister(ImageSeqPtr)

class MarchingSquares(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MarchingSquares, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MarchingSquares, name)
    def __repr__(self):
        return "<C fx::MarchingSquares instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == MarchingSquares:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, MarchingSquares, 'this', _demoscript.new_MarchingSquares(*args))
        _swig_setattr(self, MarchingSquares, 'thisown', 1)
    __swig_setmethods__["treshold"] = _demoscript.MarchingSquares_treshold_set
    __swig_getmethods__["treshold"] = _demoscript.MarchingSquares_treshold_get
    if _newclass:treshold = property(_demoscript.MarchingSquares_treshold_get, _demoscript.MarchingSquares_treshold_set)
    def callback(*args): return _demoscript.MarchingSquares_callback(*args)
    def __del__(self, destroy=_demoscript.delete_MarchingSquares):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_MarchingSquares(self)
        return weakref_proxy(self)

class MarchingSquaresPtr(MarchingSquares):
    def __init__(self, this):
        _swig_setattr(self, MarchingSquares, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MarchingSquares, 'thisown', 0)
        _swig_setattr(self, MarchingSquares,self.__class__,MarchingSquares)
_demoscript.MarchingSquares_swigregister(MarchingSquaresPtr)

class Mosaic(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mosaic, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Mosaic, name)
    def __repr__(self):
        return "<C fx::Mosaic instance at %s>" % (self.this,)
    def callback(*args): return _demoscript.Mosaic_callback(*args)
    def __init__(self, *args):
        _swig_setattr(self, Mosaic, 'this', _demoscript.new_Mosaic(*args))
        _swig_setattr(self, Mosaic, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Mosaic):
        try:
            if self.thisown: destroy(self)
        except: pass

class MosaicPtr(Mosaic):
    def __init__(self, this):
        _swig_setattr(self, Mosaic, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Mosaic, 'thisown', 0)
        _swig_setattr(self, Mosaic,self.__class__,Mosaic)
_demoscript.Mosaic_swigregister(MosaicPtr)

class SweepEdge(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SweepEdge, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SweepEdge, name)
    def __repr__(self):
        return "<C fx::SweepEdge instance at %s>" % (self.this,)
    __swig_setmethods__["p0"] = _demoscript.SweepEdge_p0_set
    __swig_getmethods__["p0"] = _demoscript.SweepEdge_p0_get
    if _newclass:p0 = property(_demoscript.SweepEdge_p0_get, _demoscript.SweepEdge_p0_set)
    __swig_setmethods__["p1"] = _demoscript.SweepEdge_p1_set
    __swig_getmethods__["p1"] = _demoscript.SweepEdge_p1_get
    if _newclass:p1 = property(_demoscript.SweepEdge_p1_get, _demoscript.SweepEdge_p1_set)
    def __init__(self, *args):
        _swig_setattr(self, SweepEdge, 'this', _demoscript.new_SweepEdge(*args))
        _swig_setattr(self, SweepEdge, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_SweepEdge):
        try:
            if self.thisown: destroy(self)
        except: pass

class SweepEdgePtr(SweepEdge):
    def __init__(self, this):
        _swig_setattr(self, SweepEdge, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SweepEdge, 'thisown', 0)
        _swig_setattr(self, SweepEdge,self.__class__,SweepEdge)
_demoscript.SweepEdge_swigregister(SweepEdgePtr)

class MSSweep(SceneEffect):
    __swig_setmethods__ = {}
    for _s in [SceneEffect]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, MSSweep, name, value)
    __swig_getmethods__ = {}
    for _s in [SceneEffect]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, MSSweep, name)
    def __repr__(self):
        return "<C fx::MSSweep instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == MSSweep:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, MSSweep, 'this', _demoscript.new_MSSweep(*args))
        _swig_setattr(self, MSSweep, 'thisown', 1)
    __swig_setmethods__["treshold"] = _demoscript.MSSweep_treshold_set
    __swig_getmethods__["treshold"] = _demoscript.MSSweep_treshold_get
    if _newclass:treshold = property(_demoscript.MSSweep_treshold_get, _demoscript.MSSweep_treshold_set)
    __swig_setmethods__["xoff"] = _demoscript.MSSweep_xoff_set
    __swig_getmethods__["xoff"] = _demoscript.MSSweep_xoff_get
    if _newclass:xoff = property(_demoscript.MSSweep_xoff_get, _demoscript.MSSweep_xoff_set)
    __swig_setmethods__["yoff"] = _demoscript.MSSweep_yoff_set
    __swig_getmethods__["yoff"] = _demoscript.MSSweep_yoff_get
    if _newclass:yoff = property(_demoscript.MSSweep_yoff_get, _demoscript.MSSweep_yoff_set)
    __swig_setmethods__["distance"] = _demoscript.MSSweep_distance_set
    __swig_getmethods__["distance"] = _demoscript.MSSweep_distance_get
    if _newclass:distance = property(_demoscript.MSSweep_distance_get, _demoscript.MSSweep_distance_set)
    __swig_setmethods__["segmentWidth"] = _demoscript.MSSweep_segmentWidth_set
    __swig_getmethods__["segmentWidth"] = _demoscript.MSSweep_segmentWidth_get
    if _newclass:segmentWidth = property(_demoscript.MSSweep_segmentWidth_get, _demoscript.MSSweep_segmentWidth_set)
    __swig_setmethods__["segmentHeight"] = _demoscript.MSSweep_segmentHeight_set
    __swig_getmethods__["segmentHeight"] = _demoscript.MSSweep_segmentHeight_get
    if _newclass:segmentHeight = property(_demoscript.MSSweep_segmentHeight_get, _demoscript.MSSweep_segmentHeight_set)
    __swig_setmethods__["starShape"] = _demoscript.MSSweep_starShape_set
    __swig_getmethods__["starShape"] = _demoscript.MSSweep_starShape_get
    if _newclass:starShape = property(_demoscript.MSSweep_starShape_get, _demoscript.MSSweep_starShape_set)
    __swig_setmethods__["red0"] = _demoscript.MSSweep_red0_set
    __swig_getmethods__["red0"] = _demoscript.MSSweep_red0_get
    if _newclass:red0 = property(_demoscript.MSSweep_red0_get, _demoscript.MSSweep_red0_set)
    __swig_setmethods__["green0"] = _demoscript.MSSweep_green0_set
    __swig_getmethods__["green0"] = _demoscript.MSSweep_green0_get
    if _newclass:green0 = property(_demoscript.MSSweep_green0_get, _demoscript.MSSweep_green0_set)
    __swig_setmethods__["blue0"] = _demoscript.MSSweep_blue0_set
    __swig_getmethods__["blue0"] = _demoscript.MSSweep_blue0_get
    if _newclass:blue0 = property(_demoscript.MSSweep_blue0_get, _demoscript.MSSweep_blue0_set)
    __swig_setmethods__["red1"] = _demoscript.MSSweep_red1_set
    __swig_getmethods__["red1"] = _demoscript.MSSweep_red1_get
    if _newclass:red1 = property(_demoscript.MSSweep_red1_get, _demoscript.MSSweep_red1_set)
    __swig_setmethods__["green1"] = _demoscript.MSSweep_green1_set
    __swig_getmethods__["green1"] = _demoscript.MSSweep_green1_get
    if _newclass:green1 = property(_demoscript.MSSweep_green1_get, _demoscript.MSSweep_green1_set)
    __swig_setmethods__["blue1"] = _demoscript.MSSweep_blue1_set
    __swig_getmethods__["blue1"] = _demoscript.MSSweep_blue1_get
    if _newclass:blue1 = property(_demoscript.MSSweep_blue1_get, _demoscript.MSSweep_blue1_set)
    def callback(*args): return _demoscript.MSSweep_callback(*args)
    def setBlendMode(*args): return _demoscript.MSSweep_setBlendMode(*args)
    def __del__(self, destroy=_demoscript.delete_MSSweep):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_MSSweep(self)
        return weakref_proxy(self)

class MSSweepPtr(MSSweep):
    def __init__(self, this):
        _swig_setattr(self, MSSweep, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, MSSweep, 'thisown', 0)
        _swig_setattr(self, MSSweep,self.__class__,MSSweep)
_demoscript.MSSweep_swigregister(MSSweepPtr)

class RadialBlur(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, RadialBlur, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, RadialBlur, name)
    def __repr__(self):
        return "<C fx::RadialBlur instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == RadialBlur:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, RadialBlur, 'this', _demoscript.new_RadialBlur(*args))
        _swig_setattr(self, RadialBlur, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_RadialBlur):
        try:
            if self.thisown: destroy(self)
        except: pass
    def callback(*args): return _demoscript.RadialBlur_callback(*args)
    __swig_setmethods__["spread"] = _demoscript.RadialBlur_spread_set
    __swig_getmethods__["spread"] = _demoscript.RadialBlur_spread_get
    if _newclass:spread = property(_demoscript.RadialBlur_spread_get, _demoscript.RadialBlur_spread_set)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_RadialBlur(self)
        return weakref_proxy(self)

class RadialBlurPtr(RadialBlur):
    def __init__(self, this):
        _swig_setattr(self, RadialBlur, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, RadialBlur, 'thisown', 0)
        _swig_setattr(self, RadialBlur,self.__class__,RadialBlur)
_demoscript.RadialBlur_swigregister(RadialBlurPtr)

class Split(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Split, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Split, name)
    def __repr__(self):
        return "<C fx::Split instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Split, 'this', _demoscript.new_Split(*args))
        _swig_setattr(self, Split, 'thisown', 1)
    __swig_setmethods__["dTopX"] = _demoscript.Split_dTopX_set
    __swig_getmethods__["dTopX"] = _demoscript.Split_dTopX_get
    if _newclass:dTopX = property(_demoscript.Split_dTopX_get, _demoscript.Split_dTopX_set)
    __swig_setmethods__["dTopY"] = _demoscript.Split_dTopY_set
    __swig_getmethods__["dTopY"] = _demoscript.Split_dTopY_get
    if _newclass:dTopY = property(_demoscript.Split_dTopY_get, _demoscript.Split_dTopY_set)
    __swig_setmethods__["dW"] = _demoscript.Split_dW_set
    __swig_getmethods__["dW"] = _demoscript.Split_dW_get
    if _newclass:dW = property(_demoscript.Split_dW_get, _demoscript.Split_dW_set)
    __swig_setmethods__["dH"] = _demoscript.Split_dH_set
    __swig_getmethods__["dH"] = _demoscript.Split_dH_get
    if _newclass:dH = property(_demoscript.Split_dH_get, _demoscript.Split_dH_set)
    __swig_setmethods__["sTopX"] = _demoscript.Split_sTopX_set
    __swig_getmethods__["sTopX"] = _demoscript.Split_sTopX_get
    if _newclass:sTopX = property(_demoscript.Split_sTopX_get, _demoscript.Split_sTopX_set)
    __swig_setmethods__["sTopY"] = _demoscript.Split_sTopY_set
    __swig_getmethods__["sTopY"] = _demoscript.Split_sTopY_get
    if _newclass:sTopY = property(_demoscript.Split_sTopY_get, _demoscript.Split_sTopY_set)
    __swig_setmethods__["sW"] = _demoscript.Split_sW_set
    __swig_getmethods__["sW"] = _demoscript.Split_sW_get
    if _newclass:sW = property(_demoscript.Split_sW_get, _demoscript.Split_sW_set)
    __swig_setmethods__["sH"] = _demoscript.Split_sH_set
    __swig_getmethods__["sH"] = _demoscript.Split_sH_get
    if _newclass:sH = property(_demoscript.Split_sH_get, _demoscript.Split_sH_set)
    __swig_setmethods__["zOrder"] = _demoscript.Split_zOrder_set
    __swig_getmethods__["zOrder"] = _demoscript.Split_zOrder_get
    if _newclass:zOrder = property(_demoscript.Split_zOrder_get, _demoscript.Split_zOrder_set)
    __swig_setmethods__["input"] = _demoscript.Split_input_set
    __swig_getmethods__["input"] = _demoscript.Split_input_get
    if _newclass:input = property(_demoscript.Split_input_get, _demoscript.Split_input_set)
    def __eq__(*args): return _demoscript.Split___eq__(*args)
    def __del__(self, destroy=_demoscript.delete_Split):
        try:
            if self.thisown: destroy(self)
        except: pass

class SplitPtr(Split):
    def __init__(self, this):
        _swig_setattr(self, Split, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Split, 'thisown', 0)
        _swig_setattr(self, Split,self.__class__,Split)
_demoscript.Split_swigregister(SplitPtr)

class SplitLess(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SplitLess, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SplitLess, name)
    def __repr__(self):
        return "<C fx::SplitLess instance at %s>" % (self.this,)
    def __call__(*args): return _demoscript.SplitLess___call__(*args)
    def __init__(self, *args):
        _swig_setattr(self, SplitLess, 'this', _demoscript.new_SplitLess(*args))
        _swig_setattr(self, SplitLess, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_SplitLess):
        try:
            if self.thisown: destroy(self)
        except: pass

class SplitLessPtr(SplitLess):
    def __init__(self, this):
        _swig_setattr(self, SplitLess, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SplitLess, 'thisown', 0)
        _swig_setattr(self, SplitLess,self.__class__,SplitLess)
_demoscript.SplitLess_swigregister(SplitLessPtr)

class Splitter(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Splitter, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Splitter, name)
    def __repr__(self):
        return "<C fx::Splitter instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Splitter, 'this', _demoscript.new_Splitter(*args))
        _swig_setattr(self, Splitter, 'thisown', 1)
    def callback(*args): return _demoscript.Splitter_callback(*args)
    def addSplit(*args): return _demoscript.Splitter_addSplit(*args)
    def removeSplit(*args): return _demoscript.Splitter_removeSplit(*args)
    def __del__(self, destroy=_demoscript.delete_Splitter):
        try:
            if self.thisown: destroy(self)
        except: pass

class SplitterPtr(Splitter):
    def __init__(self, this):
        _swig_setattr(self, Splitter, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Splitter, 'thisown', 0)
        _swig_setattr(self, Splitter,self.__class__,Splitter)
_demoscript.Splitter_swigregister(SplitterPtr)

class Max(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Max, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Max, name)
    def __repr__(self):
        return "<C fx::Max instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Max, 'this', _demoscript.new_Max(*args))
        _swig_setattr(self, Max, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Max):
        try:
            if self.thisown: destroy(self)
        except: pass
    def callback(*args): return _demoscript.Max_callback(*args)

class MaxPtr(Max):
    def __init__(self, this):
        _swig_setattr(self, Max, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Max, 'thisown', 0)
        _swig_setattr(self, Max,self.__class__,Max)
_demoscript.Max_swigregister(MaxPtr)

class Transformation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Transformation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Transformation, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C fxcore::Transformation instance at %s>" % (self.this,)
    def getMatrix(*args): return _demoscript.Transformation_getMatrix(*args)
    def __del__(self, destroy=_demoscript.delete_Transformation):
        try:
            if self.thisown: destroy(self)
        except: pass

class TransformationPtr(Transformation):
    def __init__(self, this):
        _swig_setattr(self, Transformation, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Transformation, 'thisown', 0)
        _swig_setattr(self, Transformation,self.__class__,Transformation)
_demoscript.Transformation_swigregister(TransformationPtr)

class Translation(Transformation):
    __swig_setmethods__ = {}
    for _s in [Transformation]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Translation, name, value)
    __swig_getmethods__ = {}
    for _s in [Transformation]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Translation, name)
    def __repr__(self):
        return "<C fxcore::Translation instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Translation, 'this', _demoscript.new_Translation(*args))
        _swig_setattr(self, Translation, 'thisown', 1)
    __swig_setmethods__["x"] = _demoscript.Translation_x_set
    __swig_getmethods__["x"] = _demoscript.Translation_x_get
    if _newclass:x = property(_demoscript.Translation_x_get, _demoscript.Translation_x_set)
    __swig_setmethods__["y"] = _demoscript.Translation_y_set
    __swig_getmethods__["y"] = _demoscript.Translation_y_get
    if _newclass:y = property(_demoscript.Translation_y_get, _demoscript.Translation_y_set)
    __swig_setmethods__["z"] = _demoscript.Translation_z_set
    __swig_getmethods__["z"] = _demoscript.Translation_z_get
    if _newclass:z = property(_demoscript.Translation_z_get, _demoscript.Translation_z_set)
    def getMatrix(*args): return _demoscript.Translation_getMatrix(*args)
    def __del__(self, destroy=_demoscript.delete_Translation):
        try:
            if self.thisown: destroy(self)
        except: pass

class TranslationPtr(Translation):
    def __init__(self, this):
        _swig_setattr(self, Translation, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Translation, 'thisown', 0)
        _swig_setattr(self, Translation,self.__class__,Translation)
_demoscript.Translation_swigregister(TranslationPtr)

class Scaling(Transformation):
    __swig_setmethods__ = {}
    for _s in [Transformation]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scaling, name, value)
    __swig_getmethods__ = {}
    for _s in [Transformation]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Scaling, name)
    def __repr__(self):
        return "<C fxcore::Scaling instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Scaling, 'this', _demoscript.new_Scaling(*args))
        _swig_setattr(self, Scaling, 'thisown', 1)
    __swig_setmethods__["x"] = _demoscript.Scaling_x_set
    __swig_getmethods__["x"] = _demoscript.Scaling_x_get
    if _newclass:x = property(_demoscript.Scaling_x_get, _demoscript.Scaling_x_set)
    __swig_setmethods__["y"] = _demoscript.Scaling_y_set
    __swig_getmethods__["y"] = _demoscript.Scaling_y_get
    if _newclass:y = property(_demoscript.Scaling_y_get, _demoscript.Scaling_y_set)
    __swig_setmethods__["z"] = _demoscript.Scaling_z_set
    __swig_getmethods__["z"] = _demoscript.Scaling_z_get
    if _newclass:z = property(_demoscript.Scaling_z_get, _demoscript.Scaling_z_set)
    def getMatrix(*args): return _demoscript.Scaling_getMatrix(*args)
    def __del__(self, destroy=_demoscript.delete_Scaling):
        try:
            if self.thisown: destroy(self)
        except: pass

class ScalingPtr(Scaling):
    def __init__(self, this):
        _swig_setattr(self, Scaling, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Scaling, 'thisown', 0)
        _swig_setattr(self, Scaling,self.__class__,Scaling)
_demoscript.Scaling_swigregister(ScalingPtr)

class Rotation(Transformation):
    __swig_setmethods__ = {}
    for _s in [Transformation]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rotation, name, value)
    __swig_getmethods__ = {}
    for _s in [Transformation]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Rotation, name)
    def __repr__(self):
        return "<C fxcore::Rotation instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Rotation, 'this', _demoscript.new_Rotation(*args))
        _swig_setattr(self, Rotation, 'thisown', 1)
    __swig_setmethods__["x"] = _demoscript.Rotation_x_set
    __swig_getmethods__["x"] = _demoscript.Rotation_x_get
    if _newclass:x = property(_demoscript.Rotation_x_get, _demoscript.Rotation_x_set)
    __swig_setmethods__["y"] = _demoscript.Rotation_y_set
    __swig_getmethods__["y"] = _demoscript.Rotation_y_get
    if _newclass:y = property(_demoscript.Rotation_y_get, _demoscript.Rotation_y_set)
    __swig_setmethods__["z"] = _demoscript.Rotation_z_set
    __swig_getmethods__["z"] = _demoscript.Rotation_z_get
    if _newclass:z = property(_demoscript.Rotation_z_get, _demoscript.Rotation_z_set)
    __swig_setmethods__["angle"] = _demoscript.Rotation_angle_set
    __swig_getmethods__["angle"] = _demoscript.Rotation_angle_get
    if _newclass:angle = property(_demoscript.Rotation_angle_get, _demoscript.Rotation_angle_set)
    def getMatrix(*args): return _demoscript.Rotation_getMatrix(*args)
    def __del__(self, destroy=_demoscript.delete_Rotation):
        try:
            if self.thisown: destroy(self)
        except: pass

class RotationPtr(Rotation):
    def __init__(self, this):
        _swig_setattr(self, Rotation, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Rotation, 'thisown', 0)
        _swig_setattr(self, Rotation,self.__class__,Rotation)
_demoscript.Rotation_swigregister(RotationPtr)

PT_SMOOTH = _demoscript.PT_SMOOTH
PT_CORNER = _demoscript.PT_CORNER
class PathPoint(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PathPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PathPoint, name)
    def __repr__(self):
        return "<C fxcore::PathPoint instance at %s>" % (self.this,)
    __swig_setmethods__["anchor"] = _demoscript.PathPoint_anchor_set
    __swig_getmethods__["anchor"] = _demoscript.PathPoint_anchor_get
    if _newclass:anchor = property(_demoscript.PathPoint_anchor_get, _demoscript.PathPoint_anchor_set)
    __swig_setmethods__["dirLeft"] = _demoscript.PathPoint_dirLeft_set
    __swig_getmethods__["dirLeft"] = _demoscript.PathPoint_dirLeft_get
    if _newclass:dirLeft = property(_demoscript.PathPoint_dirLeft_get, _demoscript.PathPoint_dirLeft_set)
    __swig_setmethods__["dirRight"] = _demoscript.PathPoint_dirRight_set
    __swig_getmethods__["dirRight"] = _demoscript.PathPoint_dirRight_get
    if _newclass:dirRight = property(_demoscript.PathPoint_dirRight_get, _demoscript.PathPoint_dirRight_set)
    __swig_setmethods__["pointType"] = _demoscript.PathPoint_pointType_set
    __swig_getmethods__["pointType"] = _demoscript.PathPoint_pointType_get
    if _newclass:pointType = property(_demoscript.PathPoint_pointType_get, _demoscript.PathPoint_pointType_set)
    def __init__(self, *args):
        _swig_setattr(self, PathPoint, 'this', _demoscript.new_PathPoint(*args))
        _swig_setattr(self, PathPoint, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_PathPoint):
        try:
            if self.thisown: destroy(self)
        except: pass

class PathPointPtr(PathPoint):
    def __init__(self, this):
        _swig_setattr(self, PathPoint, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, PathPoint, 'thisown', 0)
        _swig_setattr(self, PathPoint,self.__class__,PathPoint)
_demoscript.PathPoint_swigregister(PathPointPtr)

class SubPath(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubPath, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SubPath, name)
    def __repr__(self):
        return "<C fxcore::SubPath instance at %s>" % (self.this,)
    def getSegmentLength(*args): return _demoscript.SubPath_getSegmentLength(*args)
    def getVelocity(*args): return _demoscript.SubPath_getVelocity(*args)
    def getPoint(*args): return _demoscript.SubPath_getPoint(*args)
    __swig_setmethods__["points"] = _demoscript.SubPath_points_set
    __swig_getmethods__["points"] = _demoscript.SubPath_points_get
    if _newclass:points = property(_demoscript.SubPath_points_get, _demoscript.SubPath_points_set)
    __swig_setmethods__["lengths"] = _demoscript.SubPath_lengths_set
    __swig_getmethods__["lengths"] = _demoscript.SubPath_lengths_get
    if _newclass:lengths = property(_demoscript.SubPath_lengths_get, _demoscript.SubPath_lengths_set)
    def calcLengths(*args): return _demoscript.SubPath_calcLengths(*args)
    def getLength(*args): return _demoscript.SubPath_getLength(*args)
    def __init__(self, *args):
        _swig_setattr(self, SubPath, 'this', _demoscript.new_SubPath(*args))
        _swig_setattr(self, SubPath, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_SubPath):
        try:
            if self.thisown: destroy(self)
        except: pass

class SubPathPtr(SubPath):
    def __init__(self, this):
        _swig_setattr(self, SubPath, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SubPath, 'thisown', 0)
        _swig_setattr(self, SubPath,self.__class__,SubPath)
_demoscript.SubPath_swigregister(SubPathPtr)

class Path(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Path, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Path, name)
    def __repr__(self):
        return "<C fxcore::Path instance at %s>" % (self.this,)
    __swig_setmethods__["name"] = _demoscript.Path_name_set
    __swig_getmethods__["name"] = _demoscript.Path_name_get
    if _newclass:name = property(_demoscript.Path_name_get, _demoscript.Path_name_set)
    __swig_setmethods__["subPaths"] = _demoscript.Path_subPaths_set
    __swig_getmethods__["subPaths"] = _demoscript.Path_subPaths_get
    if _newclass:subPaths = property(_demoscript.Path_subPaths_get, _demoscript.Path_subPaths_set)
    def __init__(self, *args):
        _swig_setattr(self, Path, 'this', _demoscript.new_Path(*args))
        _swig_setattr(self, Path, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Path):
        try:
            if self.thisown: destroy(self)
        except: pass

class PathPtr(Path):
    def __init__(self, this):
        _swig_setattr(self, Path, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Path, 'thisown', 0)
        _swig_setattr(self, Path,self.__class__,Path)
_demoscript.Path_swigregister(PathPtr)

class PathSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PathSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PathSet, name)
    def __repr__(self):
        return "<C fxcore::PathSet instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, PathSet, 'this', _demoscript.new_PathSet(*args))
        _swig_setattr(self, PathSet, 'thisown', 1)
    __swig_setmethods__["paths"] = _demoscript.PathSet_paths_set
    __swig_getmethods__["paths"] = _demoscript.PathSet_paths_get
    if _newclass:paths = property(_demoscript.PathSet_paths_get, _demoscript.PathSet_paths_set)
    def __del__(self, destroy=_demoscript.delete_PathSet):
        try:
            if self.thisown: destroy(self)
        except: pass

class PathSetPtr(PathSet):
    def __init__(self, this):
        _swig_setattr(self, PathSet, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, PathSet, 'thisown', 0)
        _swig_setattr(self, PathSet,self.__class__,PathSet)
_demoscript.PathSet_swigregister(PathSetPtr)

class Glyph(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Glyph, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Glyph, name)
    def __repr__(self):
        return "<C fxcore::Glyph instance at %s>" % (self.this,)
    __swig_setmethods__["available"] = _demoscript.Glyph_available_set
    __swig_getmethods__["available"] = _demoscript.Glyph_available_get
    if _newclass:available = property(_demoscript.Glyph_available_get, _demoscript.Glyph_available_set)
    __swig_setmethods__["x1"] = _demoscript.Glyph_x1_set
    __swig_getmethods__["x1"] = _demoscript.Glyph_x1_get
    if _newclass:x1 = property(_demoscript.Glyph_x1_get, _demoscript.Glyph_x1_set)
    __swig_setmethods__["y1"] = _demoscript.Glyph_y1_set
    __swig_getmethods__["y1"] = _demoscript.Glyph_y1_get
    if _newclass:y1 = property(_demoscript.Glyph_y1_get, _demoscript.Glyph_y1_set)
    __swig_setmethods__["x2"] = _demoscript.Glyph_x2_set
    __swig_getmethods__["x2"] = _demoscript.Glyph_x2_get
    if _newclass:x2 = property(_demoscript.Glyph_x2_get, _demoscript.Glyph_x2_set)
    __swig_setmethods__["y2"] = _demoscript.Glyph_y2_set
    __swig_getmethods__["y2"] = _demoscript.Glyph_y2_get
    if _newclass:y2 = property(_demoscript.Glyph_y2_get, _demoscript.Glyph_y2_set)
    __swig_setmethods__["letteroffsetx"] = _demoscript.Glyph_letteroffsetx_set
    __swig_getmethods__["letteroffsetx"] = _demoscript.Glyph_letteroffsetx_get
    if _newclass:letteroffsetx = property(_demoscript.Glyph_letteroffsetx_get, _demoscript.Glyph_letteroffsetx_set)
    __swig_setmethods__["letteroffsety"] = _demoscript.Glyph_letteroffsety_set
    __swig_getmethods__["letteroffsety"] = _demoscript.Glyph_letteroffsety_get
    if _newclass:letteroffsety = property(_demoscript.Glyph_letteroffsety_get, _demoscript.Glyph_letteroffsety_set)
    __swig_setmethods__["spacingx"] = _demoscript.Glyph_spacingx_set
    __swig_getmethods__["spacingx"] = _demoscript.Glyph_spacingx_get
    if _newclass:spacingx = property(_demoscript.Glyph_spacingx_get, _demoscript.Glyph_spacingx_set)
    def __init__(self, *args):
        _swig_setattr(self, Glyph, 'this', _demoscript.new_Glyph(*args))
        _swig_setattr(self, Glyph, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Glyph):
        try:
            if self.thisown: destroy(self)
        except: pass

class GlyphPtr(Glyph):
    def __init__(self, this):
        _swig_setattr(self, Glyph, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Glyph, 'thisown', 0)
        _swig_setattr(self, Glyph,self.__class__,Glyph)
_demoscript.Glyph_swigregister(GlyphPtr)

class Font(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Font, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Font, name)
    def __repr__(self):
        return "<C fxcore::Font instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Font, 'this', _demoscript.new_Font(*args))
        _swig_setattr(self, Font, 'thisown', 1)
    __swig_setmethods__["glyphs"] = _demoscript.Font_glyphs_set
    __swig_getmethods__["glyphs"] = _demoscript.Font_glyphs_get
    if _newclass:glyphs = property(_demoscript.Font_glyphs_get, _demoscript.Font_glyphs_set)
    __swig_setmethods__["texture"] = _demoscript.Font_texture_set
    __swig_getmethods__["texture"] = _demoscript.Font_texture_get
    if _newclass:texture = property(_demoscript.Font_texture_get, _demoscript.Font_texture_set)
    __swig_setmethods__["kerning"] = _demoscript.Font_kerning_set
    __swig_getmethods__["kerning"] = _demoscript.Font_kerning_get
    if _newclass:kerning = property(_demoscript.Font_kerning_get, _demoscript.Font_kerning_set)
    __swig_setmethods__["ffac"] = _demoscript.Font_ffac_set
    __swig_getmethods__["ffac"] = _demoscript.Font_ffac_get
    if _newclass:ffac = property(_demoscript.Font_ffac_get, _demoscript.Font_ffac_set)
    def __del__(self, destroy=_demoscript.delete_Font):
        try:
            if self.thisown: destroy(self)
        except: pass

class FontPtr(Font):
    def __init__(self, this):
        _swig_setattr(self, Font, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Font, 'thisown', 0)
        _swig_setattr(self, Font,self.__class__,Font)
_demoscript.Font_swigregister(FontPtr)

class Particles(SceneEffect):
    __swig_setmethods__ = {}
    for _s in [SceneEffect]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Particles, name, value)
    __swig_getmethods__ = {}
    for _s in [SceneEffect]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Particles, name)
    def __repr__(self):
        return "<C fx::Particles instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == Particles:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Particles, 'this', _demoscript.new_Particles(*args))
        _swig_setattr(self, Particles, 'thisown', 1)
    def callback(*args): return _demoscript.Particles_callback(*args)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Particles(self)
        return weakref_proxy(self)

class ParticlesPtr(Particles):
    def __init__(self, this):
        _swig_setattr(self, Particles, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Particles, 'thisown', 0)
        _swig_setattr(self, Particles,self.__class__,Particles)
_demoscript.Particles_swigregister(ParticlesPtr)

class Blob(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Blob, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Blob, name)
    def __repr__(self):
        return "<C fx::Blob instance at %s>" % (self.this,)
    __swig_setmethods__["center"] = _demoscript.Blob_center_set
    __swig_getmethods__["center"] = _demoscript.Blob_center_get
    if _newclass:center = property(_demoscript.Blob_center_get, _demoscript.Blob_center_set)
    def __init__(self, *args):
        _swig_setattr(self, Blob, 'this', _demoscript.new_Blob(*args))
        _swig_setattr(self, Blob, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Blob):
        try:
            if self.thisown: destroy(self)
        except: pass

class BlobPtr(Blob):
    def __init__(self, this):
        _swig_setattr(self, Blob, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Blob, 'thisown', 0)
        _swig_setattr(self, Blob,self.__class__,Blob)
_demoscript.Blob_swigregister(BlobPtr)

class IsoParticles(Particles):
    __swig_setmethods__ = {}
    for _s in [Particles]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, IsoParticles, name, value)
    __swig_getmethods__ = {}
    for _s in [Particles]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, IsoParticles, name)
    def __repr__(self):
        return "<C fx::IsoParticles instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, IsoParticles, 'this', _demoscript.new_IsoParticles(*args))
        _swig_setattr(self, IsoParticles, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_IsoParticles):
        try:
            if self.thisown: destroy(self)
        except: pass

class IsoParticlesPtr(IsoParticles):
    def __init__(self, this):
        _swig_setattr(self, IsoParticles, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, IsoParticles, 'thisown', 0)
        _swig_setattr(self, IsoParticles,self.__class__,IsoParticles)
_demoscript.IsoParticles_swigregister(IsoParticlesPtr)

class Boid(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Boid, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Boid, name)
    def __repr__(self):
        return "<C fx::Boid instance at %s>" % (self.this,)
    __swig_setmethods__["position"] = _demoscript.Boid_position_set
    __swig_getmethods__["position"] = _demoscript.Boid_position_get
    if _newclass:position = property(_demoscript.Boid_position_get, _demoscript.Boid_position_set)
    __swig_setmethods__["velocity"] = _demoscript.Boid_velocity_set
    __swig_getmethods__["velocity"] = _demoscript.Boid_velocity_get
    if _newclass:velocity = property(_demoscript.Boid_velocity_get, _demoscript.Boid_velocity_set)
    def __init__(self, *args):
        _swig_setattr(self, Boid, 'this', _demoscript.new_Boid(*args))
        _swig_setattr(self, Boid, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Boid):
        try:
            if self.thisown: destroy(self)
        except: pass

class BoidPtr(Boid):
    def __init__(self, this):
        _swig_setattr(self, Boid, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Boid, 'thisown', 0)
        _swig_setattr(self, Boid,self.__class__,Boid)
_demoscript.Boid_swigregister(BoidPtr)

class Flocking(Particles):
    __swig_setmethods__ = {}
    for _s in [Particles]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Flocking, name, value)
    __swig_getmethods__ = {}
    for _s in [Particles]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Flocking, name)
    def __repr__(self):
        return "<C fx::Flocking instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == Flocking:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Flocking, 'this', _demoscript.new_Flocking(*args))
        _swig_setattr(self, Flocking, 'thisown', 1)
    def setTarget(*args): return _demoscript.Flocking_setTarget(*args)
    def callback(*args): return _demoscript.Flocking_callback(*args)
    __swig_setmethods__["particleSize"] = _demoscript.Flocking_particleSize_set
    __swig_getmethods__["particleSize"] = _demoscript.Flocking_particleSize_get
    if _newclass:particleSize = property(_demoscript.Flocking_particleSize_get, _demoscript.Flocking_particleSize_set)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Flocking(self)
        return weakref_proxy(self)

class FlockingPtr(Flocking):
    def __init__(self, this):
        _swig_setattr(self, Flocking, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Flocking, 'thisown', 0)
        _swig_setattr(self, Flocking,self.__class__,Flocking)
_demoscript.Flocking_swigregister(FlockingPtr)

class HypnoTunnel(MarchingSquares):
    __swig_setmethods__ = {}
    for _s in [MarchingSquares]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, HypnoTunnel, name, value)
    __swig_getmethods__ = {}
    for _s in [MarchingSquares]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, HypnoTunnel, name)
    def __repr__(self):
        return "<C fx::HypnoTunnel instance at %s>" % (self.this,)
    def fill(*args): return _demoscript.HypnoTunnel_fill(*args)
    def __init__(self, *args):
        _swig_setattr(self, HypnoTunnel, 'this', _demoscript.new_HypnoTunnel(*args))
        _swig_setattr(self, HypnoTunnel, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_HypnoTunnel):
        try:
            if self.thisown: destroy(self)
        except: pass

class HypnoTunnelPtr(HypnoTunnel):
    def __init__(self, this):
        _swig_setattr(self, HypnoTunnel, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, HypnoTunnel, 'thisown', 0)
        _swig_setattr(self, HypnoTunnel,self.__class__,HypnoTunnel)
_demoscript.HypnoTunnel_swigregister(HypnoTunnelPtr)

class Typo(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Typo, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Typo, name)
    def __repr__(self):
        return "<C fx::Typo instance at %s>" % (self.this,)
    __swig_setmethods__["minSize"] = _demoscript.Typo_minSize_set
    __swig_getmethods__["minSize"] = _demoscript.Typo_minSize_get
    if _newclass:minSize = property(_demoscript.Typo_minSize_get, _demoscript.Typo_minSize_set)
    __swig_setmethods__["posScatter"] = _demoscript.Typo_posScatter_set
    __swig_getmethods__["posScatter"] = _demoscript.Typo_posScatter_get
    if _newclass:posScatter = property(_demoscript.Typo_posScatter_get, _demoscript.Typo_posScatter_set)
    __swig_setmethods__["sizeScatter"] = _demoscript.Typo_sizeScatter_set
    __swig_getmethods__["sizeScatter"] = _demoscript.Typo_sizeScatter_get
    if _newclass:sizeScatter = property(_demoscript.Typo_sizeScatter_get, _demoscript.Typo_sizeScatter_set)
    __swig_setmethods__["rate"] = _demoscript.Typo_rate_set
    __swig_getmethods__["rate"] = _demoscript.Typo_rate_get
    if _newclass:rate = property(_demoscript.Typo_rate_get, _demoscript.Typo_rate_set)
    __swig_setmethods__["velocity"] = _demoscript.Typo_velocity_set
    __swig_getmethods__["velocity"] = _demoscript.Typo_velocity_get
    if _newclass:velocity = property(_demoscript.Typo_velocity_get, _demoscript.Typo_velocity_set)
    __swig_setmethods__["red"] = _demoscript.Typo_red_set
    __swig_getmethods__["red"] = _demoscript.Typo_red_get
    if _newclass:red = property(_demoscript.Typo_red_get, _demoscript.Typo_red_set)
    __swig_setmethods__["green"] = _demoscript.Typo_green_set
    __swig_getmethods__["green"] = _demoscript.Typo_green_get
    if _newclass:green = property(_demoscript.Typo_green_get, _demoscript.Typo_green_set)
    __swig_setmethods__["blue"] = _demoscript.Typo_blue_set
    __swig_getmethods__["blue"] = _demoscript.Typo_blue_get
    if _newclass:blue = property(_demoscript.Typo_blue_get, _demoscript.Typo_blue_set)
    def setPathSet(*args): return _demoscript.Typo_setPathSet(*args)
    def setFont(*args): return _demoscript.Typo_setFont(*args)
    def setText(*args): return _demoscript.Typo_setText(*args)
    def callback(*args): return _demoscript.Typo_callback(*args)
    def reset(*args): return _demoscript.Typo_reset(*args)
    def nextPath(*args): return _demoscript.Typo_nextPath(*args)
    def nextSubPath(*args): return _demoscript.Typo_nextSubPath(*args)
    def __init__(self, *args):
        if self.__class__ == Typo:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, Typo, 'this', _demoscript.new_Typo(*args))
        _swig_setattr(self, Typo, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_Typo):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_Typo(self)
        return weakref_proxy(self)

class TypoPtr(Typo):
    def __init__(self, this):
        _swig_setattr(self, Typo, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Typo, 'thisown', 0)
        _swig_setattr(self, Typo,self.__class__,Typo)
_demoscript.Typo_swigregister(TypoPtr)


setupDSound = _demoscript.setupDSound

updateDSound = _demoscript.updateDSound

getLeftLevel = _demoscript.getLeftLevel

getRightLevel = _demoscript.getRightLevel

getLevel = _demoscript.getLevel
class XMVPlayer(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMVPlayer, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, XMVPlayer, name)
    def __repr__(self):
        return "<C fx::XMVPlayer instance at %s>" % (self.this,)
    def __init__(self, *args):
        if self.__class__ == XMVPlayer:
            args = (None,) + args
        else:
            args = (self,) + args
        _swig_setattr(self, XMVPlayer, 'this', _demoscript.new_XMVPlayer(*args))
        _swig_setattr(self, XMVPlayer, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_XMVPlayer):
        try:
            if self.thisown: destroy(self)
        except: pass
    def callback(*args): return _demoscript.XMVPlayer_callback(*args)
    def restart(*args): return _demoscript.XMVPlayer_restart(*args)
    __swig_setmethods__["x"] = _demoscript.XMVPlayer_x_set
    __swig_getmethods__["x"] = _demoscript.XMVPlayer_x_get
    if _newclass:x = property(_demoscript.XMVPlayer_x_get, _demoscript.XMVPlayer_x_set)
    __swig_setmethods__["y"] = _demoscript.XMVPlayer_y_set
    __swig_getmethods__["y"] = _demoscript.XMVPlayer_y_get
    if _newclass:y = property(_demoscript.XMVPlayer_y_get, _demoscript.XMVPlayer_y_set)
    __swig_setmethods__["width"] = _demoscript.XMVPlayer_width_set
    __swig_getmethods__["width"] = _demoscript.XMVPlayer_width_get
    if _newclass:width = property(_demoscript.XMVPlayer_width_get, _demoscript.XMVPlayer_width_set)
    __swig_setmethods__["height"] = _demoscript.XMVPlayer_height_set
    __swig_getmethods__["height"] = _demoscript.XMVPlayer_height_get
    if _newclass:height = property(_demoscript.XMVPlayer_height_get, _demoscript.XMVPlayer_height_set)
    def __disown__(self):
        self.thisown = 0
        _demoscript.disown_XMVPlayer(self)
        return weakref_proxy(self)

class XMVPlayerPtr(XMVPlayer):
    def __init__(self, this):
        _swig_setattr(self, XMVPlayer, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XMVPlayer, 'thisown', 0)
        _swig_setattr(self, XMVPlayer,self.__class__,XMVPlayer)
_demoscript.XMVPlayer_swigregister(XMVPlayerPtr)


frand = _demoscript.frand

