Support for the new python-native interigate functions

direct/src/extensions_native/CInterval_extensions.py

@@ -0,0 +1,121 @@
+from extension_native_helpers import *
+from libdirect import *
+
+#####################################################################
+
+from direct.directnotify.DirectNotifyGlobal import directNotify
+notify = directNotify.newCategory("Interval")
+Dtool_ObjectToDict(CInterval,"notify", notify)        
+del notify
+#####################################################################
+def setT(self, t):
+    # Overridden from the C++ function to call privPostEvent
+    # afterward.  We do this by renaming the C++ function in
+    # FFIRename.
+    self._priv__cSetT(t)
+    self.privPostEvent()
+
+Dtool_funcToMethod(setT, CInterval)        
+del setT
+#####################################################################
+                       
+def play(self, t0 = 0.0, duration = None, scale = 1.0):
+        self.notify.error("using deprecated CInterval.play() interface")
+        if duration:  # None or 0 implies full length
+            self.start(t0, t0 + duration, scale)
+        else:
+            self.start(t0, -1, scale)
+            
+Dtool_funcToMethod(play, CInterval)        
+del play
+#####################################################################
+
+def stop(self):
+        self.notify.error("using deprecated CInterval.stop() interface")
+        self.finish()
+            
+Dtool_funcToMethod(stop, CInterval)        
+del stop
+#####################################################################
+
+def setFinalT(self):
+        self.notify.error("using deprecated CInterval.setFinalT() interface")
+        self.finish()
+
+Dtool_funcToMethod(setFinalT, CInterval)        
+del setFinalT
+#####################################################################
+
+def privPostEvent(self):
+        # Call after calling any of the priv* methods to do any required
+        # Python finishing steps.
+        t = self.getT()
+        if hasattr(self, "setTHooks"):
+            for func in self.setTHooks:
+                func(t)
+
+Dtool_funcToMethod(privPostEvent, CInterval)        
+del privPostEvent
+#####################################################################
+
+def popupControls(self, tl = None):
+        """
+        Popup control panel for interval.
+        """
+        from direct.showbase.TkGlobal import Toplevel, Frame, Button, LEFT, X, Pmw
+        import math
+        from direct.tkwidgets import EntryScale
+        if tl == None:
+            tl = Toplevel()
+            tl.title('Interval Controls')
+        outerFrame = Frame(tl)
+        def entryScaleCommand(t,s=self):
+            s.setT(t)
+            s.pause()
+        self.es = es = EntryScale.EntryScale(
+            outerFrame, text = self.getName(),
+            min = 0, max = math.floor(self.getDuration() * 100) / 100,
+            command = entryScaleCommand)
+        es.set(self.getT(), fCommand = 0)
+        es.pack(expand = 1, fill = X)
+        bf = Frame(outerFrame)
+        # Jump to start and end
+        def toStart(s=self, es=es):
+            s.setT(0.0)
+            s.pause()
+        def toEnd(s=self):
+            s.setT(s.getDuration())
+            s.pause()
+        jumpToStart = Button(bf, text = '<<', command = toStart)
+        # Stop/play buttons
+        def doPlay(s=self, es=es):
+            s.resume(es.get())
+                       
+        stop = Button(bf, text = 'Stop',
+                      command = lambda s=self: s.pause())
+        play = Button(
+            bf, text = 'Play',
+            command = doPlay)
+        jumpToEnd = Button(bf, text = '>>', command = toEnd)
+        jumpToStart.pack(side = LEFT, expand = 1, fill = X)
+        play.pack(side = LEFT, expand = 1, fill = X)
+        stop.pack(side = LEFT, expand = 1, fill = X)
+        jumpToEnd.pack(side = LEFT, expand = 1, fill = X)
+        bf.pack(expand = 1, fill = X)
+        outerFrame.pack(expand = 1, fill = X)
+        # Add function to update slider during setT calls
+        def update(t,es=es):
+            es.set(t, fCommand = 0)
+        if not hasattr(self, "setTHooks"):
+            self.setTHooks = []
+        self.setTHooks.append(update)
+        self.setWantsTCallback(1)
+        # Clear out function on destroy
+        def onDestroy(e, s=self, u=update):
+            if u in s.setTHooks:
+                s.setTHooks.remove(u)
+        tl.bind('<Destroy>', onDestroy)
+
+Dtool_funcToMethod(popupControls, CInterval)        
+del popupControls
+#####################################################################

direct/src/extensions_native/EggGroupNode_extensions.py

@@ -0,0 +1,18 @@
+from extension_native_helpers import *
+from libdirect import *
+####################################################################
+#Dtool_funcToMethod(func, class)        
+#del func
+#####################################################################
+    # For iterating over children
+def getChildren(self):
+        """Returns a Python list of the egg node's children."""
+        result = []
+        child = self.getFirstChild()
+        while (child != None):
+            result.append(child)
+            child = self.getNextChild()
+        return result
+    
+Dtool_funcToMethod(getChildren, EggGroupNode)        
+del getChildren

direct/src/extensions_native/EggPrimitive_extensions.py

@@ -0,0 +1,15 @@
+from extension_native_helpers import *
+from libdirect import *
+####################################################################
+#Dtool_funcToMethod(func, class)        
+#del func
+#####################################################################
+    # For iterating over vertices
+def getVertices(self):
+        """Returns a Python list of the egg primitive's vertices."""
+        result = []
+        for i in range(self.getNumVertices()):
+            result.append(self.getVertex(i))
+        return result
+Dtool_funcToMethod(getVertices, EggPrimitive)        
+del getVertices

direct/src/extensions_native/HTTPChannel_extensions.py

@@ -0,0 +1,44 @@
+from extension_native_helpers import *
+from libpandaexpress import *
+
+####################################################################
+#Dtool_funcToMethod(func, class)        
+#del func
+#####################################################################
+
+"""
+HTTPChannel-extensions module: contains methods to extend functionality
+of the HTTPChannel class
+"""
+
+def spawnTask(self, name = None, callback = None, extraArgs = []):
+        """Spawns a task to service the download recently requested
+        via beginGetDocument(), etc., and/or downloadToFile() or
+        downloadToRam().  If a callback is specified, that function is
+        called when the download is complete, passing in the extraArgs
+        given.
+
+        Returns the newly-spawned task.
+        """
+        if not name:
+            name = self.getUrl().cStr()
+        from direct.task import Task
+        task = Task.Task(self.doTask)
+        task.callback = callback
+        task.callbackArgs = extraArgs
+        return taskMgr.add(task, name)    
+Dtool_funcToMethod(spawnTask, HTTPChannel)        
+del spawnTask
+#####################################################################
+        
+def doTask(self, task):
+        from direct.task import Task
+        if self.run():
+            return Task.cont
+        if task.callback:
+            task.callback(*task.callbackArgs)
+        return Task.done
+    
+Dtool_funcToMethod(doTask, HTTPChannel)        
+del doTask
+#####################################################################

direct/src/extensions_native/Mat3_extensions.py

@@ -0,0 +1,22 @@
+from extension_native_helpers import *
+from libdirect import *
+####################################################################
+#Dtool_funcToMethod(func, class)        
+#del func
+#####################################################################
+
+"""
+Mat3-extensions module: contains methods to extend functionality
+of the LMatrix3f class.
+"""
+
+
+def pPrintValues(self):
+        """
+        Pretty print
+        """
+        return "\n%s\n%s\n%s" % (
+            self.getRow(0).pPrintValues(), self.getRow(1).pPrintValues(), self.getRow(2).pPrintValues())
+Dtool_funcToMethod(pPrintValues, Mat3)        
+del pPrintValues
+#####################################################################

direct/src/extensions_native/NodePathCollection_extensions.py

@@ -0,0 +1,40 @@
+from extension_native_helpers import *
+from libpanda import *
+
+
+#####################################################################
+
+# For iterating over children
+def asList(self):
+    """Converts a NodePathCollection into a list"""
+    if self.isEmpty():
+        return []
+    else:
+        npList = []
+        for nodePathIndex in range(self.getNumPaths()):
+            npList.append(self.getPath(nodePathIndex))
+        return npList
+        
+Dtool_funcToMethod(asList, NodePathCollection)        
+del asList
+#####################################################################3333      
+
+def getTightBounds(self):
+    from pandac import Point3
+    
+    if self.getNumPaths() == 0:
+        return (Point3.Point3(0), Point3.Point3(0))
+    v1, v2 = self.getPath(0).getTightBounds()
+    for i in range(1, self.getNumPaths()):
+        v1x, v2x = self.getPath(i).getTightBounds()
+        v1 = Point3.Point3(min(v1[0], v1x[0]),
+                           min(v1[1], v1x[1]),
+                           min(v1[2], v1x[2]))
+        v2 = Point3.Point3(max(v2[0], v2x[0]),
+                           max(v2[1], v2x[1]),
+                           max(v2[2], v2x[2]))
+    return v1, v2
+    
+Dtool_funcToMethod(getTightBounds, NodePathCollection)        
+del getTightBounds
+#####################################################################3333      

direct/src/extensions_native/NodePath_extensions.py

@@ -0,0 +1,1303 @@
+
+from extension_native_helpers import *
+from libpanda import *
+
+####################################################################
+#Dtool_funcToMethod(func, class)        
+#del func
+#####################################################################
+
+"""
+NodePath-extensions module: contains methods to extend functionality
+of the NodePath class
+"""
+
+####################################################################
+def id(self):
+        """Returns a unique id identifying the NodePath instance"""
+        return self.getKey()
+
+Dtool_funcToMethod(id, NodePath)        
+del id
+#####################################################################
+
+##    def __hash__(self):  // inside c code
+##        return self.getKey()
+#####################################################################
+
+    # For iterating over children
+def getChildrenAsList(self):
+        """Converts a node path's child NodePathCollection into a list"""
+        return self.getChildren().asList()
+
+Dtool_funcToMethod(getChildrenAsList, NodePath)        
+del getChildrenAsList
+#####################################################################
+
+def printChildren(self):
+        """Prints out the children of the bottom node of a node path"""
+        for child in self.getChildrenAsList():
+            print child.getName()
+Dtool_funcToMethod(printChildren, NodePath)        
+del printChildren
+#####################################################################
+
+def removeChildren(self):
+        """Deletes the children of the bottom node of a node path"""
+        for child in self.getChildrenAsList():
+            child.removeNode()
+Dtool_funcToMethod(removeChildren, NodePath)        
+del removeChildren
+#####################################################################
+
+def toggleVis(self):
+        """Toggles visibility of a nodePath"""
+        if self.isHidden():
+            self.show()
+            return 1
+        else:
+            self.hide()
+            return 0
+Dtool_funcToMethod(toggleVis, NodePath)        
+del toggleVis
+#####################################################################
+            
+def showSiblings(self):
+        """Show all the siblings of a node path"""
+        for sib in self.getParent().getChildrenAsList():
+            if sib.node() != self.node():
+                sib.show()
+Dtool_funcToMethod(showSiblings, NodePath)        
+del showSiblings
+#####################################################################
+
+def hideSiblings(self):
+        """Hide all the siblings of a node path"""
+        for sib in self.getParent().getChildrenAsList():
+            if sib.node() != self.node():
+                sib.hide()
+Dtool_funcToMethod(hideSiblings, NodePath)        
+del hideSiblings
+#####################################################################
+
+def showAllDescendants(self):
+        """Show the node path and all its children"""
+        self.show()
+        for child in self.getChildrenAsList():
+            child.showAllDescendants()
+Dtool_funcToMethod(showAllDescendants, NodePath)        
+del showAllDescendants
+#####################################################################
+
+def isolate(self):
+        """Show the node path and hide its siblings"""
+        self.showAllDescendants()
+        self.hideSiblings()
+Dtool_funcToMethod(isolate, NodePath)        
+del isolate
+#####################################################################
+
+def remove(self):
+        """Remove a node path from the scene graph"""
+        # Send message in case anyone needs to do something
+        # before node is deleted
+        messenger.send('preRemoveNodePath', [self])
+        # Remove nodePath
+        self.removeNode()
+Dtool_funcToMethod(remove, NodePath)        
+del remove
+#####################################################################
+
+def lsNames(self):
+        """Walk down a tree and print out the path"""
+        if self.isEmpty():
+            print "(empty)"
+        else:
+            type = self.node().getType().getName()
+            name = self.getName()
+            print type + "  " + name
+            self.lsNamesRecurse()
+
+Dtool_funcToMethod(lsNames, NodePath)        
+del lsNames
+#####################################################################
+def lsNamesRecurse(self, indentString=' '):
+        """Walk down a tree and print out the path"""
+        for nodePath in self.getChildrenAsList():
+            type = nodePath.node().getType().getName()
+            name = nodePath.getName()
+            print indentString + type + "  " + name
+            nodePath.lsNamesRecurse(indentString + " ")
+
+Dtool_funcToMethod(lsNamesRecurse, NodePath)        
+del lsNamesRecurse
+#####################################################################
+def reverseLsNames(self):
+        """Walk up a tree and print out the path to the root"""
+        ancestry = self.getAncestry()
+        indentString = ""
+        for nodePath in ancestry:
+            type = nodePath.node().getType().getName()
+            name = nodePath.getName()
+            print indentString + type + "  " + name
+            indentString = indentString + " "
+
+Dtool_funcToMethod(reverseLsNames, NodePath)        
+del reverseLsNames
+#####################################################################
+def getAncestry(self):
+        """Get a list of a node path's ancestors"""
+        node = self.node()
+        if (self.hasParent()):
+            ancestry = self.getParent().getAncestry()
+            ancestry.append(self)
+            return ancestry
+        else:
+            return [self]
+
+Dtool_funcToMethod(getAncestry, NodePath)        
+del getAncestry
+#####################################################################
+def getTightBounds(self):
+        from pandac.PandaModules import Point3
+        v1 = Point3.Point3(0)
+        v2 = Point3.Point3(0)
+        self.calcTightBounds(v1,v2)
+        return v1, v2
+Dtool_funcToMethod(getTightBounds, NodePath)        
+del getTightBounds
+#####################################################################
+
+def pPrintString(self, other = None):
+        """
+        pretty print
+        """
+        if __debug__:
+            # Normally I would have put the if __debug__ around
+            # the entire funciton, the that doesn't seem to work
+            # with -extensions.  Maybe someone will look into
+            # this further.
+            if other:
+                pos = self.getPos(other)
+                hpr = self.getHpr(other)
+                scale = self.getScale(other)
+                shear = self.getShear(other)
+                otherString = "  'other': %s,\n" % (other.getName(),)
+            else:
+                pos = self.getPos()
+                hpr = self.getHpr()
+                scale = self.getScale()
+                shear = self.getShear()
+                otherString = '\n'
+            return (
+                "%s = {"%(self.getName()) +
+                otherString + 
+                "  'Pos'  : (%s),\n" % pos.pPrintValues() +
+                "  'Hpr'  : (%s),\n" % hpr.pPrintValues() +
+                "  'Scale': (%s),\n" % scale.pPrintValues() +
+                "  'Shear': (%s),\n" % shear.pPrintValues() +
+                "}")
+Dtool_funcToMethod(pPrintString, NodePath)        
+del pPrintString
+#####################################################################
+
+def printPos(self, other = None, sd = 2):
+        """ Pretty print a node path's pos """
+        formatString = '%0.' + '%d' % sd + 'f'
+        if other:
+            pos = self.getPos(other)
+            otherString = other.getName() + ', '
+        else:
+            pos = self.getPos()
+            otherString = ''
+        print (self.getName() + '.setPos(' + otherString + 
+               formatString % pos[0] + ', ' +
+               formatString % pos[1] + ', ' +
+               formatString % pos[2] +
+               ')\n')
+Dtool_funcToMethod(printPos, NodePath)        
+del printPos
+#####################################################################
+
+def printHpr(self, other = None, sd = 2):
+        """ Pretty print a node path's hpr """
+        formatString = '%0.' + '%d' % sd + 'f'
+        if other:
+            hpr = self.getHpr(other)
+            otherString = other.getName() + ', '
+        else:
+            hpr = self.getHpr()
+            otherString = ''
+        print (self.getName() + '.setHpr(' + otherString + 
+               formatString % hpr[0] + ', ' +
+               formatString % hpr[1] + ', ' +
+               formatString % hpr[2] +
+               ')\n')
+Dtool_funcToMethod(printHpr, NodePath)        
+del printHpr
+#####################################################################
+
+def printScale(self, other = None, sd = 2):
+        """ Pretty print a node path's scale """
+        formatString = '%0.' + '%d' % sd + 'f'
+        if other:
+            scale = self.getScale(other)
+            otherString = other.getName() + ', '
+        else:
+            scale = self.getScale()
+            otherString = ''
+        print (self.getName() + '.setScale(' + otherString + 
+               formatString % scale[0] + ', ' +
+               formatString % scale[1] + ', ' +
+               formatString % scale[2] +
+               ')\n')
+
+Dtool_funcToMethod(printScale, NodePath)        
+del printScale
+#####################################################################
+def printPosHpr(self, other = None, sd = 2):
+        """ Pretty print a node path's pos and, hpr """
+        formatString = '%0.' + '%d' % sd + 'f'
+        if other:
+            pos = self.getPos(other)
+            hpr = self.getHpr(other)
+            otherString = other.getName() + ', '
+        else:
+            pos = self.getPos()
+            hpr = self.getHpr()
+            otherString = ''
+        print (self.getName() + '.setPosHpr(' + otherString + 
+               formatString % pos[0] + ', ' +
+               formatString % pos[1] + ', ' +
+               formatString % pos[2] + ', ' +
+               formatString % hpr[0] + ', ' +
+               formatString % hpr[1] + ', ' +
+               formatString % hpr[2] +
+               ')\n')
+
+Dtool_funcToMethod(printPosHpr, NodePath)        
+del printPosHpr
+#####################################################################
+def printPosHprScale(self, other = None, sd = 2):
+        """ Pretty print a node path's pos, hpr, and scale """
+        formatString = '%0.' + '%d' % sd + 'f'
+        if other:
+            pos = self.getPos(other)
+            hpr = self.getHpr(other)
+            scale = self.getScale(other)
+            otherString = other.getName() + ', '
+        else:
+            pos = self.getPos()
+            hpr = self.getHpr()
+            scale = self.getScale()
+            otherString = ''
+        print (self.getName() + '.setPosHprScale(' + otherString + 
+               formatString % pos[0] + ', ' +
+               formatString % pos[1] + ', ' +
+               formatString % pos[2] + ', ' +
+               formatString % hpr[0] + ', ' +
+               formatString % hpr[1] + ', ' +
+               formatString % hpr[2] + ', ' +
+               formatString % scale[0] + ', ' +
+               formatString % scale[1] + ', ' +
+               formatString % scale[2] +
+               ')\n')
+
+Dtool_funcToMethod(printPosHprScale, NodePath)        
+del printPosHprScale
+#####################################################################
+def iPos(self, other = None):
+        """ Set node path's pos to 0,0,0 """
+        if other:
+            self.setPos(other, 0,0,0)
+        else:
+            self.setPos(0,0,0)
+Dtool_funcToMethod(iPos, NodePath)        
+del iPos
+#####################################################################
+
+def iHpr(self, other = None):
+        """ Set node path's hpr to 0,0,0 """
+        if other:
+            self.setHpr(other, 0,0,0)
+        else:
+            self.setHpr(0,0,0)
+
+Dtool_funcToMethod(iHpr, NodePath)        
+del iHpr
+#####################################################################
+def iScale(self, other = None):
+        """ SEt node path's scale to 1,1,1 """
+        if other:
+            self.setScale(other, 1,1,1)
+        else:
+            self.setScale(1,1,1)
+
+Dtool_funcToMethod(iScale, NodePath)        
+del iScale
+#####################################################################
+def iPosHpr(self, other = None):
+        """ Set node path's pos and hpr to 0,0,0 """
+        if other:
+            self.setPosHpr(other,0,0,0,0,0,0)
+        else:
+            self.setPosHpr(0,0,0,0,0,0)
+
+Dtool_funcToMethod(iPosHpr, NodePath)        
+del iPosHpr
+#####################################################################
+def iPosHprScale(self, other = None):
+        """ Set node path's pos and hpr to 0,0,0 and scale to 1,1,1 """
+        if other:
+            self.setPosHprScale(other, 0,0,0,0,0,0,1,1,1)
+        else:
+            self.setPosHprScale(0,0,0,0,0,0,1,1,1)
+
+    # private methods
+Dtool_funcToMethod(iPosHprScale, NodePath)        
+del iPosHprScale
+#####################################################################
+            
+def __lerp(self, functorFunc, duration, blendType, taskName=None):
+        """
+        __lerp(self, functorFunc, float, string, string)
+        Basic lerp functionality used by other lerps.
+        Fire off a lerp. Make it a task if taskName given.
+        """
+        # functorFunc is a function which can be called to create a functor.
+        # functor creation is defered so initial state (sampled in functorFunc)
+        # will be appropriate for the time the lerp is spawned
+        from direct.task import Task
+        from direct.showbase import LerpBlendHelpers
+        from direct.task.TaskManagerGlobal import taskMgr
+        
+        # upon death remove the functorFunc
+        def lerpUponDeath(task):
+            # Try to break circular references
+            try:
+                del task.functorFunc
+            except:
+                pass
+            try:
+                del task.lerp
+            except:
+                pass
+        
+        # make the task function
+        def lerpTaskFunc(task):
+            from pandac.PandaModules import Lerp
+            from pandac.PandaModules import ClockObject
+            from direct.task.Task import Task, cont, done
+            if task.init == 1:
+                # make the lerp
+                functor = task.functorFunc()
+                task.lerp = Lerp(functor, task.duration, task.blendType)
+                task.init = 0
+            dt = globalClock.getDt()
+            task.lerp.setStepSize(dt)
+            task.lerp.step()
+            if (task.lerp.isDone()):
+                # Reset the init flag, in case the task gets re-used
+                task.init = 1
+                return(done)
+            else:
+                return(cont)
+        
+        # make the lerp task
+        lerpTask = Task.Task(lerpTaskFunc)
+        lerpTask.init = 1
+        lerpTask.functorFunc = functorFunc
+        lerpTask.duration = duration
+        lerpTask.blendType = LerpBlendHelpers.getBlend(blendType)
+        lerpTask.uponDeath = lerpUponDeath
+        
+        if (taskName == None):
+            # don't spawn a task, return one instead
+            return lerpTask
+        else:
+            # spawn the lerp task
+            taskMgr.add(lerpTask, taskName)
+            return lerpTask
+
+Dtool_funcToMethod(__lerp, NodePath)        
+del __lerp
+#####################################################################
+def __autoLerp(self, functorFunc, time, blendType, taskName):
+        """_autoLerp(self, functor, float, string, string)
+        This lerp uses C++ to handle the stepping. Bonus is
+        its more efficient, trade-off is there is less control"""
+        from pandac.PandaModules import AutonomousLerp
+        from direct.showbase import LerpBlendHelpers
+        # make a lerp that lives in C++ land
+        functor = functorFunc()
+        lerp = AutonomousLerp.AutonomousLerp(functor, time,
+                              LerpBlendHelpers.getBlend(blendType),
+                              base.eventHandler)
+        lerp.start()
+        return lerp
+
+Dtool_funcToMethod(__autoLerp, NodePath)        
+del __autoLerp
+#####################################################################
+
+# user callable lerp methods
+def lerpColor(self, *posArgs, **keyArgs):
+        """lerpColor(self, *positionArgs, **keywordArgs)
+        determine which lerpColor* to call based on arguments
+        """
+        if (len(posArgs) == 2):
+            return apply(self.lerpColorVBase4, posArgs, keyArgs)
+        elif (len(posArgs) == 3):
+            return apply(self.lerpColorVBase4VBase4, posArgs, keyArgs)
+        elif (len(posArgs) == 5):
+            return apply(self.lerpColorRGBA, posArgs, keyArgs)
+        elif (len(posArgs) == 9):
+            return apply(self.lerpColorRGBARGBA, posArgs, keyArgs)
+        else:
+            # bad args
+            raise Exception("Error: NodePath.lerpColor: bad number of args")
+
+Dtool_funcToMethod(lerpColor, NodePath)        
+del lerpColor
+#####################################################################
+            
+def lerpColorRGBA(self, r, g, b, a, time,
+                      blendType="noBlend", auto=None, task=None):
+        """lerpColorRGBA(self, float, float, float, float, float,
+        string="noBlend", string=none, string=none)
+        """
+        def functorFunc(self = self, r = r, g = g, b = b, a = a):
+            from pandac.PandaModules import ColorLerpFunctor
+            # just end rgba values, use current color rgba values for start
+            startColor = self.getColor()
+            functor = ColorLerpFunctor.ColorLerpFunctor(
+                self,
+                startColor[0], startColor[1],
+                startColor[2], startColor[3],
+                r, g, b, a)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+Dtool_funcToMethod(lerpColorRGBA, NodePath)        
+del lerpColorRGBA
+#####################################################################
+def lerpColorRGBARGBA(self, sr, sg, sb, sa, er, eg, eb, ea, time,
+                          blendType="noBlend", auto=None, task=None):
+        """lerpColorRGBARGBA(self, float, float, float, float, float,
+        float, float, float, float, string="noBlend", string=none, string=none)
+        """
+        def functorFunc(self = self, sr = sr, sg = sg, sb = sb, sa = sa,
+                        er = er, eg = eg, eb = eb, ea = ea):
+            from pandac.PandaModules import ColorLerpFunctor
+            # start and end rgba values
+            functor = ColorLerpFunctor.ColorLerpFunctor(self, sr, sg, sb, sa,
+                                                        er, eg, eb, ea)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+Dtool_funcToMethod(lerpColorRGBARGBA, NodePath)        
+del lerpColorRGBARGBA
+#####################################################################
+def lerpColorVBase4(self, endColor, time,
+                        blendType="noBlend", auto=None, task=None):
+        """lerpColorVBase4(self, VBase4, float, string="noBlend", string=none,
+        string=none)
+        """
+        def functorFunc(self = self, endColor = endColor):
+            from pandac.PandaModules import ColorLerpFunctor
+            # just end vec4, use current color for start
+            startColor = self.getColor()
+            functor = ColorLerpFunctor.ColorLerpFunctor(
+                self, startColor, endColor)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+Dtool_funcToMethod(lerpColorVBase4, NodePath)        
+del lerpColorVBase4
+#####################################################################
+def lerpColorVBase4VBase4(self, startColor, endColor, time,
+                          blendType="noBlend", auto=None, task=None):
+        """lerpColorVBase4VBase4(self, VBase4, VBase4, float, string="noBlend",
+        string=none, string=none)
+        """
+        def functorFunc(self = self, startColor = startColor,
+                        endColor = endColor):
+            from pandac.PandaModules import ColorLerpFunctor
+            # start color and end vec
+            functor = ColorLerpFunctor.ColorLerpFunctor(
+                self, startColor, endColor)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+
+
+Dtool_funcToMethod(lerpColorVBase4VBase4, NodePath)        
+del lerpColorVBase4VBase4
+#####################################################################
+    # user callable lerp methods
+def lerpColorScale(self, *posArgs, **keyArgs):
+        """lerpColorScale(self, *positionArgs, **keywordArgs)
+        determine which lerpColorScale* to call based on arguments
+        """
+        if (len(posArgs) == 2):
+            return apply(self.lerpColorScaleVBase4, posArgs, keyArgs)
+        elif (len(posArgs) == 3):
+            return apply(self.lerpColorScaleVBase4VBase4, posArgs, keyArgs)
+        elif (len(posArgs) == 5):
+            return apply(self.lerpColorScaleRGBA, posArgs, keyArgs)
+        elif (len(posArgs) == 9):
+            return apply(self.lerpColorScaleRGBARGBA, posArgs, keyArgs)
+        else:
+            # bad args
+            raise Exception("Error: NodePath.lerpColorScale: bad number of args")
+
+            
+Dtool_funcToMethod(lerpColorScale, NodePath)        
+del lerpColorScale
+#####################################################################
+def lerpColorScaleRGBA(self, r, g, b, a, time,
+                      blendType="noBlend", auto=None, task=None):
+        """lerpColorScaleRGBA(self, float, float, float, float, float,
+        string="noBlend", string=none, string=none)
+        """
+        def functorFunc(self = self, r = r, g = g, b = b, a = a):
+            from pandac.PandaModules import ColorScaleLerpFunctor
+            # just end rgba values, use current color rgba values for start
+            startColor = self.getColor()
+            functor = ColorScaleLerpFunctor.ColorScaleLerpFunctor(
+                self,
+                startColor[0], startColor[1],
+                startColor[2], startColor[3],
+                r, g, b, a)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+Dtool_funcToMethod(lerpColorScaleRGBA, NodePath)        
+del lerpColorScaleRGBA
+#####################################################################
+def lerpColorScaleRGBARGBA(self, sr, sg, sb, sa, er, eg, eb, ea, time,
+                          blendType="noBlend", auto=None, task=None):
+        """lerpColorScaleRGBARGBA(self, float, float, float, float, float,
+        float, float, float, float, string="noBlend", string=none, string=none)
+        """
+        def functorFunc(self = self, sr = sr, sg = sg, sb = sb, sa = sa,
+                        er = er, eg = eg, eb = eb, ea = ea):
+            from pandac.PandaModules import ColorScaleLerpFunctor
+            # start and end rgba values
+            functor = ColorScaleLerpFunctor.ColorScaleLerpFunctor(self, sr, sg, sb, sa,
+                                                        er, eg, eb, ea)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+Dtool_funcToMethod(lerpColorScaleRGBARGBA, NodePath)        
+del lerpColorScaleRGBARGBA
+#####################################################################
+def lerpColorScaleVBase4(self, endColor, time,
+                        blendType="noBlend", auto=None, task=None):
+        """lerpColorScaleVBase4(self, VBase4, float, string="noBlend", string=none,
+        string=none)
+        """
+        def functorFunc(self = self, endColor = endColor):
+            from pandac.PandaModules import ColorScaleLerpFunctor
+            # just end vec4, use current color for start
+            startColor = self.getColor()
+            functor = ColorScaleLerpFunctor.ColorScaleLerpFunctor(
+                self, startColor, endColor)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+Dtool_funcToMethod(lerpColorScaleVBase4, NodePath)        
+del lerpColorScaleVBase4
+#####################################################################
+def lerpColorScaleVBase4VBase4(self, startColor, endColor, time,
+                          blendType="noBlend", auto=None, task=None):
+        """lerpColorScaleVBase4VBase4(self, VBase4, VBase4, float, string="noBlend",
+        string=none, string=none)
+        """
+        def functorFunc(self = self, startColor = startColor,
+                        endColor = endColor):
+            from pandac.PandaModules import ColorScaleLerpFunctor
+            # start color and end vec
+            functor = ColorScaleLerpFunctor.ColorScaleLerpFunctor(
+                self, startColor, endColor)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+            
+
+Dtool_funcToMethod(lerpColorScaleVBase4VBase4, NodePath)        
+del lerpColorScaleVBase4VBase4
+#####################################################################
+def lerpHpr(self, *posArgs, **keyArgs):
+        """lerpHpr(self, *positionArgs, **keywordArgs)
+        Determine whether to call lerpHprHPR or lerpHprVBase3
+        based on first argument
+        """
+        # check to see if lerping with
+        # three floats or a VBase3
+        if (len(posArgs) == 4):
+            return apply(self.lerpHprHPR, posArgs, keyArgs)
+        elif(len(posArgs) == 2):
+            return apply(self.lerpHprVBase3, posArgs, keyArgs)
+        else:
+            # bad args
+            raise Exception("Error: NodePath.lerpHpr: bad number of args")
+    
+Dtool_funcToMethod(lerpHpr, NodePath)        
+del lerpHpr
+#####################################################################
+def lerpHprHPR(self, h, p, r, time, other=None,
+                   blendType="noBlend", auto=None, task=None, shortest=1):
+        """lerpHprHPR(self, float, float, float, float, string="noBlend",
+        string=none, string=none, NodePath=none)
+        Perform a hpr lerp with three floats as the end point
+        """
+        def functorFunc(self = self, h = h, p = p, r = r,
+                        other = other, shortest=shortest):
+            from pandac.PandaModules import HprLerpFunctor
+            # it's individual hpr components
+            if (other != None):
+                # lerp wrt other
+                startHpr = self.getHpr(other)
+                functor = HprLerpFunctor.HprLerpFunctor(
+                    self,
+                    startHpr[0], startHpr[1], startHpr[2],
+                    h, p, r, other)
+                if shortest:
+                    functor.takeShortest()
+            else:
+                startHpr = self.getHpr()
+                functor = HprLerpFunctor.HprLerpFunctor(
+                    self,
+                    startHpr[0], startHpr[1], startHpr[2],
+                    h, p, r)
+                if shortest:
+                    functor.takeShortest()
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+    
+Dtool_funcToMethod(lerpHprHPR, NodePath)        
+del lerpHprHPR
+#####################################################################
+def lerpHprVBase3(self, hpr, time, other=None,
+                      blendType="noBlend", auto=None, task=None, shortest=1):
+        """lerpHprVBase3(self, VBase3, float, string="noBlend", string=none,
+        string=none, NodePath=None)
+        Perform a hpr lerp with a VBase3 as the end point
+        """
+        def functorFunc(self = self, hpr = hpr,
+                        other = other, shortest=shortest):
+            from pandac.PandaModules import HprLerpFunctor
+            # it's a vbase3 hpr
+            if (other != None):
+                # lerp wrt other
+                functor = HprLerpFunctor.HprLerpFunctor(
+                    self, (self.getHpr(other)), hpr, other)
+                if shortest:
+                    functor.takeShortest()
+            else:
+                functor = HprLerpFunctor.HprLerpFunctor(
+                    self, (self.getHpr()), hpr)
+                if shortest:
+                    functor.takeShortest()
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+        
+
+Dtool_funcToMethod(lerpHprVBase3, NodePath)        
+del lerpHprVBase3
+#####################################################################
+def lerpPos(self, *posArgs, **keyArgs):
+        """lerpPos(self, *positionArgs, **keywordArgs)
+        Determine whether to call lerpPosXYZ or lerpPosPoint3
+        based on the first argument
+        """
+        # check to see if lerping with three
+        # floats or a Point3
+        if (len(posArgs) == 4):
+            return apply(self.lerpPosXYZ, posArgs, keyArgs)
+        elif(len(posArgs) == 2):
+            return apply(self.lerpPosPoint3, posArgs, keyArgs)
+        else:
+            # bad number off args
+            raise Exception("Error: NodePath.lerpPos: bad number of args")
+
+Dtool_funcToMethod(lerpPos, NodePath)        
+del lerpPos
+#####################################################################
+def lerpPosXYZ(self, x, y, z, time, other=None,
+                   blendType="noBlend", auto=None, task=None):
+        """lerpPosXYZ(self, float, float, float, float, string="noBlend",
+        string=None, NodePath=None)
+        Perform a pos lerp with three floats as the end point
+        """
+        def functorFunc(self = self, x = x, y = y, z = z, other = other):
+            from pandac.PandaModules import PosLerpFunctor
+            if (other != None):
+                # lerp wrt other
+                startPos = self.getPos(other)
+                functor = PosLerpFunctor.PosLerpFunctor(self,
+                                         startPos[0], startPos[1], startPos[2],
+                                         x, y, z, other)
+            else:
+                startPos = self.getPos()
+                functor = PosLerpFunctor.PosLerpFunctor(self, startPos[0],
+                                         startPos[1], startPos[2], x, y, z)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return  self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+Dtool_funcToMethod(lerpPosXYZ, NodePath)        
+del lerpPosXYZ
+#####################################################################
+def lerpPosPoint3(self, pos, time, other=None,
+                      blendType="noBlend", auto=None, task=None):
+        """lerpPosPoint3(self, Point3, float, string="noBlend", string=None,
+        string=None, NodePath=None)
+        Perform a pos lerp with a Point3 as the end point
+        """
+        def functorFunc(self = self, pos = pos, other = other):
+            from pandac.PandaModules import PosLerpFunctor
+            if (other != None):
+                #lerp wrt other
+                functor = PosLerpFunctor.PosLerpFunctor(
+                    self, (self.getPos(other)), pos, other)
+            else:
+                functor = PosLerpFunctor.PosLerpFunctor(
+                    self, (self.getPos()), pos)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+
+Dtool_funcToMethod(lerpPosPoint3, NodePath)        
+del lerpPosPoint3
+#####################################################################
+def lerpPosHpr(self, *posArgs, **keyArgs):
+        """lerpPosHpr(self, *positionArgs, **keywordArgs)
+        Determine whether to call lerpPosHprXYZHPR or lerpHprPoint3VBase3
+        based on first argument
+        """
+        # check to see if lerping with
+        # six floats or a Point3 and a VBase3
+        if (len(posArgs) == 7):
+            return apply(self.lerpPosHprXYZHPR, posArgs, keyArgs)
+        elif(len(posArgs) == 3):
+            return apply(self.lerpPosHprPoint3VBase3, posArgs, keyArgs)
+        else:
+            # bad number off args
+            raise Exception("Error: NodePath.lerpPosHpr: bad number of args")
+
+Dtool_funcToMethod(lerpPosHpr, NodePath)        
+del lerpPosHpr
+#####################################################################
+def lerpPosHprPoint3VBase3(self, pos, hpr, time, other=None,
+                               blendType="noBlend", auto=None, task=None, shortest=1):
+        """lerpPosHprPoint3VBase3(self, Point3, VBase3, string="noBlend",
+        string=none, string=none, NodePath=None)
+        """
+        def functorFunc(self = self, pos = pos, hpr = hpr,
+                        other = other, shortest=shortest):
+            from pandac.PandaModules import PosHprLerpFunctor
+            if (other != None):
+                # lerp wrt other
+                startPos = self.getPos(other)
+                startHpr = self.getHpr(other)
+                functor = PosHprLerpFunctor.PosHprLerpFunctor(
+                    self, startPos, pos,
+                    startHpr, hpr, other)
+                if shortest:
+                    functor.takeShortest()
+            else:
+                startPos = self.getPos()
+                startHpr = self.getHpr()
+                functor = PosHprLerpFunctor.PosHprLerpFunctor(
+                    self, startPos, pos,
+                    startHpr, hpr)
+                if shortest:
+                    functor.takeShortest()
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+Dtool_funcToMethod(lerpPosHprPoint3VBase3, NodePath)        
+del lerpPosHprPoint3VBase3
+#####################################################################
+def lerpPosHprXYZHPR(self, x, y, z, h, p, r, time, other=None,
+                         blendType="noBlend", auto=None, task=None, shortest=1):
+        """lerpPosHpr(self, float, string="noBlend", string=none,
+        string=none, NodePath=None)
+        """
+        def functorFunc(self = self, x = x, y = y, z = z,
+                        h = h, p = p, r = r, other = other, shortest=shortest):
+            from pandac.PandaModules import PosHprLerpFunctor
+            if (other != None):
+                # lerp wrt other
+                startPos = self.getPos(other)
+                startHpr = self.getHpr(other)
+                functor = PosHprLerpFunctor.PosHprLerpFunctor(self,
+                                            startPos[0], startPos[1],
+                                            startPos[2], x, y, z,
+                                            startHpr[0], startHpr[1],
+                                            startHpr[2], h, p, r,
+                                            other)
+                if shortest:
+                    functor.takeShortest()
+            else:
+                startPos = self.getPos()
+                startHpr = self.getHpr()
+                functor = PosHprLerpFunctor.PosHprLerpFunctor(self,
+                                            startPos[0], startPos[1],
+                                            startPos[2], x, y, z,
+                                            startHpr[0], startHpr[1],
+                                            startHpr[2], h, p, r)
+                if shortest:
+                    functor.takeShortest()
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+
+Dtool_funcToMethod(lerpPosHprXYZHPR, NodePath)        
+del lerpPosHprXYZHPR
+#####################################################################
+def lerpPosHprScale(self, pos, hpr, scale, time, other=None,
+                        blendType="noBlend", auto=None, task=None, shortest=1):
+        """lerpPosHpr(self, Point3, VBase3, float, float, string="noBlend",
+        string=none, string=none, NodePath=None)
+        Only one case, no need for extra args. Call the appropriate lerp
+        (auto, spawned, or blocking) based on how(if) a task name is given
+        """
+        def functorFunc(self = self, pos = pos, hpr = hpr,
+                        scale = scale, other = other, shortest=shortest):
+            from pandac.PandaModules import PosHprScaleLerpFunctor
+            if (other != None):
+                # lerp wrt other
+                startPos = self.getPos(other)
+                startHpr = self.getHpr(other)
+                startScale = self.getScale(other)
+                functor = PosHprScaleLerpFunctor.PosHprScaleLerpFunctor(self,
+                                                 startPos, pos,
+                                                 startHpr, hpr,
+                                                 startScale, scale, other)
+                if shortest:
+                    functor.takeShortest()
+            else:
+                startPos = self.getPos()
+                startHpr = self.getHpr()
+                startScale = self.getScale()
+                functor = PosHprScaleLerpFunctor.PosHprScaleLerpFunctor(self,
+                                                 startPos, pos,
+                                                 startHpr, hpr,
+                                                 startScale, scale)
+                if shortest:
+                    functor.takeShortest()
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+
+Dtool_funcToMethod(lerpPosHprScale, NodePath)        
+del lerpPosHprScale
+#####################################################################
+def lerpScale(self, *posArgs, **keyArgs):
+        """lerpSclae(self, *positionArgs, **keywordArgs)
+        Determine whether to call lerpScaleXYZ or lerpScaleaseV3
+        based on the first argument
+        """
+        # check to see if lerping with three
+        # floats or a Point3
+        if (len(posArgs) == 4):
+            return apply(self.lerpScaleXYZ, posArgs, keyArgs)
+        elif(len(posArgs) == 2):
+            return apply(self.lerpScaleVBase3, posArgs, keyArgs)
+        else:
+            # bad number off args
+            raise Exception("Error: NodePath.lerpScale: bad number of args")
+
+Dtool_funcToMethod(lerpScale, NodePath)        
+del lerpScale
+#####################################################################
+def lerpScaleVBase3(self, scale, time, other=None,
+                        blendType="noBlend", auto=None, task=None):
+        """lerpPos(self, VBase3, float, string="noBlend", string=none,
+        string=none, NodePath=None)
+        """
+        def functorFunc(self = self, scale = scale, other = other):
+            from pandac.PandaModules import ScaleLerpFunctor
+            if (other != None):
+                # lerp wrt other
+                functor = ScaleLerpFunctor.ScaleLerpFunctor(self,
+                                           (self.getScale(other)),
+                                           scale, other)
+            else:
+                functor = ScaleLerpFunctor.ScaleLerpFunctor(self,
+                                           (self.getScale()), scale)
+
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+Dtool_funcToMethod(lerpScaleVBase3, NodePath)        
+del lerpScaleVBase3
+#####################################################################
+def lerpScaleXYZ(self, sx, sy, sz, time, other=None,
+                     blendType="noBlend", auto=None, task=None):
+        """lerpPos(self, float, float, float, float, string="noBlend",
+        string=none, string=none, NodePath=None)
+        """
+        def functorFunc(self = self, sx = sx, sy = sy, sz = sz, other = other):
+            from pandac.PandaModules import ScaleLerpFunctor
+            if (other != None):
+                # lerp wrt other
+                startScale = self.getScale(other)
+                functor = ScaleLerpFunctor.ScaleLerpFunctor(self,
+                                           startScale[0], startScale[1],
+                                           startScale[2], sx, sy, sz, other)
+            else:
+                startScale = self.getScale()
+                functor = ScaleLerpFunctor.ScaleLerpFunctor(self,
+                                           startScale[0], startScale[1],
+                                           startScale[2], sx, sy, sz)
+            return functor
+        #determine whether to use auto, spawned, or blocking lerp
+        if (auto != None):
+            return self.__autoLerp(functorFunc, time, blendType, auto)
+        elif (task != None):
+            return self.__lerp(functorFunc, time, blendType, task)
+        else:
+            return self.__lerp(functorFunc, time, blendType)
+
+
+
+            
+Dtool_funcToMethod(lerpScaleXYZ, NodePath)        
+del lerpScaleXYZ
+#####################################################################
+def place(self):
+        base.startDirect(fWantTk = 1)
+        from direct.tkpanels import Placer
+        return Placer.place(self)
+
+Dtool_funcToMethod(place, NodePath)        
+del place
+#####################################################################
+def explore(self):
+        base.startDirect(fWantTk = 1)
+        from direct.tkwidgets import SceneGraphExplorer
+        return SceneGraphExplorer.explore(self)
+
+Dtool_funcToMethod(explore, NodePath)        
+del explore
+#####################################################################
+def rgbPanel(self, cb = None):
+        base.startTk()
+        from direct.tkwidgets import Slider
+        return Slider.rgbPanel(self, cb)
+
+Dtool_funcToMethod(rgbPanel, NodePath)        
+del rgbPanel
+#####################################################################
+def select(self):
+        base.startDirect(fWantTk = 0)
+        direct.select(self)
+
+Dtool_funcToMethod(select, NodePath)        
+del select
+#####################################################################
+def deselect(self):
+        base.startDirect(fWantTk = 0)
+        direct.deselect(self)
+
+Dtool_funcToMethod(deselect, NodePath)        
+del deselect
+#####################################################################
+def showCS(self, mask = None):
+        """
+        Shows the collision solids at or below this node.  If mask is
+        not None, it is a BitMask32 object (e.g. WallBitmask,
+        CameraBitmask) that indicates which particular collision
+        solids should be made visible; otherwise, all of them will be.
+        """
+        npc = self.findAllMatches('**/+CollisionNode')
+        for p in range(0, npc.getNumPaths()):
+            np = npc[p]
+            if (mask == None or (np.node().getIntoCollideMask() & mask).getWord()):
+                np.show()
+
+Dtool_funcToMethod(showCS, NodePath)        
+del showCS
+#####################################################################
+def hideCS(self, mask = None):
+        """
+        Hides the collision solids at or below this node.  If mask is
+        not None, it is a BitMask32 object (e.g. WallBitmask,
+        CameraBitmask) that indicates which particular collision
+        solids should be hidden; otherwise, all of them will be.
+        """
+        npc = self.findAllMatches('**/+CollisionNode')
+        for p in range(0, npc.getNumPaths()):
+            np = npc[p]
+            if (mask == None or (np.node().getIntoCollideMask() & mask).getWord()):
+                np.hide()
+
+Dtool_funcToMethod(hideCS, NodePath)        
+del hideCS
+#####################################################################
+def posInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpPosInterval(self, *args, **kw)
+    
+Dtool_funcToMethod(posInterval, NodePath)        
+del posInterval
+#####################################################################
+def hprInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpHprInterval(self, *args, **kw)
+    
+Dtool_funcToMethod(hprInterval, NodePath)        
+del hprInterval
+#####################################################################
+def quatInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpQuatInterval(self, *args, **kw)
+
+Dtool_funcToMethod(quatInterval, NodePath)        
+del quatInterval
+#####################################################################
+def scaleInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpScaleInterval(self, *args, **kw)
+
+Dtool_funcToMethod(scaleInterval, NodePath)        
+del scaleInterval
+#####################################################################
+def shearInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpShearInterval(self, *args, **kw)
+
+Dtool_funcToMethod(shearInterval, NodePath)        
+del shearInterval
+#####################################################################
+def posHprInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpPosHprInterval(self, *args, **kw)
+
+Dtool_funcToMethod(posHprInterval, NodePath)        
+del posHprInterval
+#####################################################################
+def posQuatInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpPosQuatInterval(self, *args, **kw)
+
+Dtool_funcToMethod(posQuatInterval, NodePath)        
+del posQuatInterval
+#####################################################################
+def hprScaleInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpHprScaleInterval(self, *args, **kw)
+
+Dtool_funcToMethod(hprScaleInterval, NodePath)        
+del hprScaleInterval
+#####################################################################
+def quatScaleInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpQuatScaleInterval(self, *args, **kw)
+
+Dtool_funcToMethod(quatScaleInterval, NodePath)        
+del quatScaleInterval
+#####################################################################
+def posHprScaleInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpPosHprScaleInterval(self, *args, **kw)
+
+Dtool_funcToMethod(posHprScaleInterval, NodePath)        
+del posHprScaleInterval
+#####################################################################
+def posQuatScaleInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpPosQuatScaleInterval(self, *args, **kw)
+
+Dtool_funcToMethod(posQuatScaleInterval, NodePath)        
+del posQuatScaleInterval
+#####################################################################
+def posHprScaleShearInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpPosHprScaleShearInterval(self, *args, **kw)
+
+Dtool_funcToMethod(posHprScaleShearInterval, NodePath)        
+del posHprScaleShearInterval
+#####################################################################
+def posQuatScaleShearInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpPosQuatScaleShearInterval(self, *args, **kw)
+
+Dtool_funcToMethod(posQuatScaleShearInterval, NodePath)        
+del posQuatScaleShearInterval
+#####################################################################
+def colorInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpColorInterval(self, *args, **kw)
+
+Dtool_funcToMethod(colorInterval, NodePath)        
+del colorInterval
+#####################################################################
+def colorScaleInterval(self, *args, **kw):
+        from direct.interval import LerpInterval
+        return LerpInterval.LerpColorScaleInterval(self, *args, **kw)
+
+Dtool_funcToMethod(colorScaleInterval, NodePath)        
+del colorScaleInterval
+#####################################################################
+def attachCollisionSphere(self, name, cx,cy,cz,r, fromCollide, intoCollide):
+        from pandac.PandaModules import CollisionSphere
+        from pandac.PandaModules import CollisionNode
+        coll = CollisionSphere.CollisionSphere(cx,cy,cz,r)
+        collNode = CollisionNode.CollisionNode(name)
+        collNode.addSolid(coll)
+        collNode.setFromCollideMask(fromCollide)
+        collNode.setIntoCollideMask(intoCollide)
+        collNodePath = self.attachNewNode(collNode)
+        return collNodePath
+
+Dtool_funcToMethod(attachCollisionSphere, NodePath)        
+del attachCollisionSphere
+#####################################################################
+def attachCollisionSegment(self, name, ax,ay,az, bx,by,bz, fromCollide, intoCollide):
+        from pandac.PandaModules import CollisionSegment
+        from pandac.PandaModules import CollisionNode
+        coll = CollisionSegment.CollisionSegment(ax,ay,az, bx,by,bz)
+        collNode = CollisionNode.CollisionNode(name)
+        collNode.addSolid(coll)
+        collNode.setFromCollideMask(fromCollide)
+        collNode.setIntoCollideMask(intoCollide)
+        collNodePath = self.attachNewNode(collNode)
+        return collNodePath
+
+Dtool_funcToMethod(attachCollisionSegment, NodePath)        
+del attachCollisionSegment
+#####################################################################
+def attachCollisionRay(self, name, ox,oy,oz, dx,dy,dz, fromCollide, intoCollide):
+        from pandac.PandaModules import CollisionRay
+        from pandac.PandaModules import CollisionNode
+        coll = CollisionRay.CollisionRay(ox,oy,oz, dx,dy,dz)
+        collNode = CollisionNode.CollisionNode(name)
+        collNode.addSolid(coll)
+        collNode.setFromCollideMask(fromCollide)
+        collNode.setIntoCollideMask(intoCollide)
+        collNodePath = self.attachNewNode(collNode)
+        return collNodePath
+
+Dtool_funcToMethod(attachCollisionRay, NodePath)        
+del attachCollisionRay
+#####################################################################
+def flattenMultitex(self, stateFrom = None, target = None,
+                        useGeom = 0, allowTexMat = 0, win = None):
+        from pandac.PandaModules import MultitexReducer
+        mr = MultitexReducer.MultitexReducer()
+        if target != None:
+            mr.setTarget(target)
+        mr.setUseGeom(useGeom)
+        mr.setAllowTexMat(allowTexMat)
+
+        if win == None:
+            win = base.win
+
+        if stateFrom == None:
+            mr.scan(self)
+        else:
+            mr.scan(self, stateFrom)
+        mr.flatten(win)
+Dtool_funcToMethod(flattenMultitex, NodePath)        
+del flattenMultitex
+#####################################################################

direct/src/extensions_native/PandaModules.py

@@ -0,0 +1,12 @@
+from libpandaexpressModules import *
+from libpandaModules import *
+from libpandaphysicsModules import *
+from libdirectModules import *
+from libpandafxModules import *
+from libpandaeggModules import *
+from libotpModules import *
+from libtoontownModules import *
+from libpiratesModules import *
+
+
+

direct/src/extensions_native/__init__.py

@@ -0,0 +1 @@
+from PandaModules import *

direct/src/extensions_native/extension_native_helpers.py

@@ -0,0 +1,18 @@
+###  Tools 
+from libpandaexpress import *
+
+
+def Dtool_ObjectToDict(clas,name,obj):
+    clas.DtoolClassDict[name] = obj;            
+
+def Dtool_funcToMethod(func,clas,method_name=None):
+    """Adds func to class so it is an accessible method; use method_name to specify the name to be used for calling the method.
+    The new method is accessible to any instance immediately."""
+    func.im_class=clas
+    func.im_func=func
+    func.im_self=None
+    if not method_name: 
+            method_name = func.__name__
+    clas.DtoolClassDict[method_name] = func;            
+
+

direct/src/extensions_native/libdirectModules.py

@@ -0,0 +1,3 @@
+from libdirect import *
+
+from direct.extensions_native import CInterval_extensions 

direct/src/extensions_native/libotpModules.py

@@ -0,0 +1,5 @@
+try:
+    from libotp import *
+except ImportError , e:
+    print " ** Warning * Failed to load -->", e    
+

direct/src/extensions_native/libpandaModules.py

@@ -0,0 +1,6 @@
+from libpanda import *
+
+## import pathing files..
+from direct.extensions_native import NodePathCollection_extensions 
+from direct.extensions_native import NodePath_extensions 
+

direct/src/extensions_native/libpandaeggModules.py

@@ -0,0 +1 @@
+from libpandaegg import *

direct/src/extensions_native/libpandaexpressModules.py

@@ -0,0 +1,4 @@
+from libpandaexpress import *
+
+from direct.extensions_native import HTTPChannel_extensions 
+#from direct.extensions_native import ConfigVariableDouble_extensions 

direct/src/extensions_native/libpandafxModules.py

@@ -0,0 +1 @@
+from libpandafx import *

direct/src/extensions_native/libpandaphysicsModules.py

@@ -0,0 +1 @@
+from libpandaphysics import *

direct/src/extensions_native/libpiratesModules.py

@@ -0,0 +1,4 @@
+try:
+    from libpiratesModules import *
+except ImportError , e:
+    print " ** Warning * Failed to load -->", e    

direct/src/extensions_native/libtoontownModules.py

@@ -0,0 +1,5 @@
+try:
+    from libtoontown import *
+except ImportError , e:
+    print " ** Warning * Failed to load -->", e    
+