# 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


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)

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 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 createTextureFromMemory(*args): return _demoscript.TextureManager_createTextureFromMemory(*args)
    def createCubeTextureFromFile(*args): return _demoscript.TextureManager_createCubeTextureFromFile(*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 pompom::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 pompom::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 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<(pompom::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(EffectNodeRefCount):
    __swig_setmethods__ = {}
    for _s in [EffectNodeRefCount]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, EffectNode, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNodeRefCount]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, EffectNode, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<C pompom::EffectNode instance at %s>" % (self.this,)
    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<(pompom::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


time = _demoscript.time
class SVertex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SVertex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SVertex, name)
    def __repr__(self):
        return "<C pompom::SVertex instance at %s>" % (self.this,)
    __swig_setmethods__["x"] = _demoscript.SVertex_x_set
    __swig_getmethods__["x"] = _demoscript.SVertex_x_get
    if _newclass:x = property(_demoscript.SVertex_x_get, _demoscript.SVertex_x_set)
    __swig_setmethods__["y"] = _demoscript.SVertex_y_set
    __swig_getmethods__["y"] = _demoscript.SVertex_y_get
    if _newclass:y = property(_demoscript.SVertex_y_get, _demoscript.SVertex_y_set)
    __swig_setmethods__["z"] = _demoscript.SVertex_z_set
    __swig_getmethods__["z"] = _demoscript.SVertex_z_get
    if _newclass:z = property(_demoscript.SVertex_z_get, _demoscript.SVertex_z_set)
    __swig_setmethods__["u"] = _demoscript.SVertex_u_set
    __swig_getmethods__["u"] = _demoscript.SVertex_u_get
    if _newclass:u = property(_demoscript.SVertex_u_get, _demoscript.SVertex_u_set)
    __swig_setmethods__["v"] = _demoscript.SVertex_v_set
    __swig_getmethods__["v"] = _demoscript.SVertex_v_get
    if _newclass:v = property(_demoscript.SVertex_v_get, _demoscript.SVertex_v_set)
    __swig_setmethods__["r"] = _demoscript.SVertex_r_set
    __swig_getmethods__["r"] = _demoscript.SVertex_r_get
    if _newclass:r = property(_demoscript.SVertex_r_get, _demoscript.SVertex_r_set)
    __swig_setmethods__["g"] = _demoscript.SVertex_g_set
    __swig_getmethods__["g"] = _demoscript.SVertex_g_get
    if _newclass:g = property(_demoscript.SVertex_g_get, _demoscript.SVertex_g_set)
    __swig_setmethods__["b"] = _demoscript.SVertex_b_set
    __swig_getmethods__["b"] = _demoscript.SVertex_b_get
    if _newclass:b = property(_demoscript.SVertex_b_get, _demoscript.SVertex_b_set)
    __swig_setmethods__["a"] = _demoscript.SVertex_a_set
    __swig_getmethods__["a"] = _demoscript.SVertex_a_get
    if _newclass:a = property(_demoscript.SVertex_a_get, _demoscript.SVertex_a_set)
    def __init__(self, *args):
        _swig_setattr(self, SVertex, 'this', _demoscript.new_SVertex(*args))
        _swig_setattr(self, SVertex, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_SVertex):
        try:
            if self.thisown: destroy(self)
        except: pass

class SVertexPtr(SVertex):
    def __init__(self, this):
        _swig_setattr(self, SVertex, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SVertex, 'thisown', 0)
        _swig_setattr(self, SVertex,self.__class__,SVertex)
_demoscript.SVertex_swigregister(SVertexPtr)

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_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 pompom::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__["transition"] = _demoscript.Job_transition_set
    __swig_getmethods__["transition"] = _demoscript.Job_transition_get
    if _newclass:transition = property(_demoscript.Job_transition_get, _demoscript.Job_transition_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 __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 pompom::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 JobHash(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, JobHash, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, JobHash, name)
    def __repr__(self):
        return "<C pompom::JobHash instance at %s>" % (self.this,)
    def __call__(*args): return _demoscript.JobHash___call__(*args)
    def __init__(self, *args):
        _swig_setattr(self, JobHash, 'this', _demoscript.new_JobHash(*args))
        _swig_setattr(self, JobHash, 'thisown', 1)
    def __del__(self, destroy=_demoscript.delete_JobHash):
        try:
            if self.thisown: destroy(self)
        except: pass

class JobHashPtr(JobHash):
    def __init__(self, this):
        _swig_setattr(self, JobHash, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, JobHash, 'thisown', 0)
        _swig_setattr(self, JobHash,self.__class__,JobHash)
_demoscript.JobHash_swigregister(JobHashPtr)

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 pompom::Scheduler instance at %s>" % (self.this,)
    def schedule(*args): return _demoscript.Scheduler_schedule(*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 __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)

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__["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 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

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

getEvent = _demoscript.getEvent
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)

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)

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 __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 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)
    __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__["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)
    __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)
    def save(*args): return _demoscript.llScene_save(*args)
    def renderRefMap(*args): return _demoscript.llScene_renderRefMap(*args)
    def load(*args): return _demoscript.llScene_load(*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)

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(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, llCamera, name, value)
    __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 save(*args): return _demoscript.llCamera_save(*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 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,)
    __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 __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)
    def callback(*args): return _demoscript.Scene_callback(*args)
    def krak(*args): return _demoscript.Scene_krak(*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 setScene(*args): return _demoscript.Scene_setScene(*args)
    def setCamera(*args): return _demoscript.Scene_setCamera(*args)
    def nextCamera(*args): return _demoscript.Scene_nextCamera(*args)
    def prevCamera(*args): return _demoscript.Scene_prevCamera(*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 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 load(*args): return _demoscript.RGBMap_load(*args)
    def unload(*args): return _demoscript.RGBMap_unload(*args)
    def render(*args): return _demoscript.RGBMap_render(*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 Voronoi(EffectNode):
    __swig_setmethods__ = {}
    for _s in [EffectNode]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, Voronoi, name, value)
    __swig_getmethods__ = {}
    for _s in [EffectNode]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, Voronoi, name)
    def __repr__(self):
        return "<C fx::Voronoi instance at %s>" % (self.this,)
    def __init__(self, *args):
        _swig_setattr(self, Voronoi, 'this', _demoscript.new_Voronoi(*args))
        _swig_setattr(self, Voronoi, 'thisown', 1)
    def load(*args): return _demoscript.Voronoi_load(*args)
    def unload(*args): return _demoscript.Voronoi_unload(*args)
    def render(*args): return _demoscript.Voronoi_render(*args)
    def callback(*args): return _demoscript.Voronoi_callback(*args)
    def __del__(self, destroy=_demoscript.delete_Voronoi):
        try:
            if self.thisown: destroy(self)
        except: pass

class VoronoiPtr(Voronoi):
    def __init__(self, this):
        _swig_setattr(self, Voronoi, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Voronoi, 'thisown', 0)
        _swig_setattr(self, Voronoi,self.__class__,Voronoi)
_demoscript.Voronoi_swigregister(VoronoiPtr)

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)
    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 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)

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 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 __del__(self, destroy=_demoscript.delete_Bitmap):
        try:
            if self.thisown: destroy(self)
        except: pass
    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):
        _swig_setattr(self, Distort, 'this', _demoscript.new_Distort(*args))
        _swig_setattr(self, Distort, 'thisown', 1)
    def callback(*args): return _demoscript.Distort_callback(*args)
    def __del__(self, destroy=_demoscript.delete_Distort):
        try:
            if self.thisown: destroy(self)
        except: pass

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)


