*** empty log message ***

direct/src/actor/Actor.py

@@ -1,14 +1,16 @@
 """Actor module: contains the Actor class"""
 
 from PandaObject import *
+import LODNode
 
 class Actor(PandaObject, NodePath):
     """Actor class: Contains methods for creating, manipulating
     and playing animations on characters"""
 
-    #create the Actor class DirectNotify category
+    #create the Actor class globals (ewww!)
     notify = directNotify.newCategory("Actor")
     partPrefix = "__Actor_"
+
     
     #special methods
     
@@ -56,8 +58,11 @@ class Actor(PandaObject, NodePath):
             a.attach("head", "torso", "joint-head")
             a.attach("torso", "legs", "joint-hips")
 
+        #
+        # ADD LOD COMMENT HERE!
+        #
 
-        Other useful Acotr class functions:
+        Other useful Actor class functions:
 
             #fix actor eye rendering
             a.drawInFront("joint-pupil?", "eyes*")
@@ -68,64 +73,117 @@ class Actor(PandaObject, NodePath):
             
         """
 
-        try:
-            self.Actor_initialized
-        except:
-            self.Actor_initialized = 1
-            # initial our NodePath essence
-            NodePath.__init__(self)
-            
-            # create data structures
-            self.__partBundleDict = {}
-            self.__animControlDict = {}
+        # initialize our NodePath essence
+        NodePath.__init__(self)
+
+        # create data structures
+        self.__partBundleDict = {}
+        self.__animControlDict = {}
+
+        if (other == None):
+            # act like a normal contructor
+
+            # create base hierarchy
+            self.assign(hidden.attachNewNode('actor'))
+            self.setGeomNode(self.attachNewNode('actorGeom'))
+            self.__LODNode = None
+            self.__hasLOD = 0
             
-            if (other == None):
-                # act like a normal contructor
-                
-                # create base hierarchy
-                self.assign(hidden.attachNewNode('actor'))
-                self.setGeomNode(self.attachNewNode('actorGeom'))
-                
-                # load models
-                # make sure we have models
-                if (models):
-                    # if this is a dictionary
-                    if (type(models)==type({})):
-                        # then it must be multipart actor
+            # load models
+            #
+            # four cases:
+            #
+            #   models, anims{} = single part actor
+            #   models{}, anims{} =  single part actor w/ LOD
+            #   models{}, anims{}{} = multi-part actor
+            #   models{}{}, anims{}{} = multi-part actor w/ LOD
+            #
+            # make sure we have models
+            if (models):
+                # do we have a dictionary of models?
+                if (type(models)==type({})):
+                    # if this is a dictionary of dictionaries
+                    if (type(models[models.keys()[0]]) == type({})):
+                        # then it must be a multipart actor w/LOD
+                        self.setLODNode()
+                        # preserve numerical order for lod's
+                        # this will make it easier to set ranges
+                        sortedKeys = models.keys()
+                        sortedKeys.sort()
+                        for lodName in sortedKeys:
+                            # make a node under the LOD switch
+                            # for each lod (just because!)
+                            self.addLOD(str(lodName))
+                            # iterate over both dicts
+                            for modelName in models[lodName].keys():
+                                self.loadModel(models[lodName][modelName],
+                                               modelName, lodName)
+                    # then if there is a dictionary of dictionaries of anims
+                    elif (type(anims[anims.keys()[0]])==type({})):
+                        # then this is a multipart actor w/o LOD
                         for partName in models.keys():
+                            # pass in each part
                             self.loadModel(models[partName], partName)
                     else:
-                        # else it is a single part actor
-                        self.loadModel(models)
-
-                # load anims
-                # make sure the actor has animations
-                if (anims):
-                    if (len(anims) >= 1):
-                        # if so, does it have a dictionary of dictionaries
-                        if (type(anims[anims.keys()[0]])==type({})):
-                            # then it must be multipart
-                            for partName in anims.keys():
-                                self.loadAnims(anims[partName], partName)
-                        else:
-                            # else it is not multipart
-                            self.loadAnims(anims)
+                        # it is a single part actor w/LOD
+                        self.setLODNode()
+                        # preserve order of LOD's
+                        sortedKeys = models.keys()
+                        sortedKeys.sort()
+                        for lodName in sortedKeys:
+                            self.addLOD(str(lodName))
+                            # pass in dictionary of parts
+                            self.loadModel(models[lodName], lodName=lodName)
+                else:
+                    # else it is a single part actor
+                    self.loadModel(models)
+
+            # load anims
+            # make sure the actor has animations
+            if (anims):
+                if (len(anims) >= 1):
+                    # if so, does it have a dictionary of dictionaries?
+                    if (type(anims[anims.keys()[0]])==type({})):
+                        # are the models a dict of dicts too?
+                        if (type(models)==type({})):
+                            if (type(models[models.keys()[0]]) == type({})):
+                                # then we have a multi-part w/ LOD
+                                sortedKeys = models.keys()
+                                sortedKeys.sort()
+                                for lodName in sortedKeys:
+                                    # iterate over both dicts
+                                    for partName in anims.keys():
+                                        self.loadAnims(
+                                            anims[partName], partName, lodName)
+                            else:
+                                # then it must be multi-part w/o LOD
+                                for partName in anims.keys():
+                                    self.loadAnims(anims[partName], partName)
+                    elif (type(models)==type({})):
+                        # then we have single-part w/ LOD
+                        sortedKeys = models.keys()
+                        sortedKeys.sort()
+                        for lodName in sortedKeys:
+                            self.loadAnims(anims, lodName=lodName)
+                    else:
+                        # else it is single-part w/o LOD
+                        self.loadAnims(anims)
 
-            else:
-                # act like a copy constructor
-                
-                # copy the scene graph elements of other
-                otherCopy = other.copyTo(hidden)
-                # assign these elements to ourselve
-                self.assign(otherCopy)
-                self.setGeomNode(otherCopy.getChild(0))
-                
-                # copy the part dictionary from other
-                self.__copyPartBundles(other)
-                
-                # copy the anim dictionary from other
-                self.__copyAnimControls(other)
-        return None
+        else:
+            # act like a copy constructor
+
+            # copy the scene graph elements of other
+            otherCopy = other.copyTo(hidden)
+            # assign these elements to ourselve
+            self.assign(otherCopy)
+            self.setGeomNode(otherCopy.getChild(0))
+            
+            # copy the part dictionary from other
+            self.__copyPartBundles(other)
+            
+            # copy the anim dictionary from other
+            self.__copyAnimControls(other)
+            
  
     def __str__(self):
         """__str__(self)
@@ -136,11 +194,17 @@ class Actor(PandaObject, NodePath):
 
     # accessing
     
+    def getLODNames(self):
+        """getLODNames(self):
+        Return list of Actor LOD names. If not an LOD actor,
+        returns 'lodRoot'"""
+        return self.__partBundleDict.keys()
+    
     def getPartNames(self):
         """getPartNames(self):
-        Return list of Actor part names. If not multipart,
-        returns modelRoot"""
-        return self.__partBundleDict.keys()
+        Return list of Actor part names. If not an multipart actor,
+        returns 'modelRoot' NOTE: returns parts of first LOD"""
+        return self.__partBundleDict[0].keys()
     
     def getGeomNode(self):
         """getGeomNode(self)
@@ -152,19 +216,115 @@ class Actor(PandaObject, NodePath):
         Set the node that contains all actor geometry"""
         self.__geomNode = node
 
+    def getLODNode(self):
+        """getLODNode(self)
+        Return the node that switches actor geometry in and out"""
+        return self.__LODNode.node()
+
+    def setLODNode(self, node=None):
+        """setLODNode(self, LODNode=None)
+        Set the node that switches actor geometry in and out.
+        If one is not supplied as an argument, make one"""
+        if (node == None):
+            lod = LODNode.LODNode("lod")
+            self.__LODNode = self.__geomNode.attachNewNode(lod)
+        else:
+            self.__LODNode = self.__geomNode.attachNewNode(node)            
+        self.__hasLOD = 1
+        self.switches = {}
+
+    def useLOD(self, lodName):
+        """useLOD(self, string)
+        Make the Actor ONLY display the given LOD"""
+        # make sure we don't call this twice in a row
+        # and pollute the the switches dictionary
+        self.resetLOD()
+        # store the data in the switches for later use
+        sortedKeys = self.switches.keys()
+        sortedKeys.sort()
+        for eachLod in sortedKeys:
+            index = sortedKeys.index(eachLod)
+            # set the switches to not display ever
+            self.__LODNode.node().setSwitch(index, 0, 10000)
+        # turn the given LOD on 'always'
+        index = sortedKeys.index(lodName)
+        self.__LODNode.node().setSwitch(index, 10000, 0)
+
+    def printLOD(self):
+        sortedKeys = self.switches.keys()
+        sortedKeys.sort()
+        for eachLod in sortedKeys:
+            print "python switches for %s: in: %d, out %d" % (eachLod,
+                                              self.switches[eachLod][0],
+                                              self.switches[eachLod][1])
+
+        switchNum = self.__LODNode.node().getNumSwitches()
+        for eachSwitch in range(0, switchNum):
+            print "c++ switches for %d: in: %d, out: %d" % (eachSwitch,
+                   self.__LODNode.node().getIn(eachSwitch),
+                   self.__LODNode.node().getOut(eachSwitch))
+                                                        
+            
+    def resetLOD(self):
+        """resetLOD(self)
+        Restore all switch distance info (usually after a useLOD call)"""
+        sortedKeys = self.switches.keys()
+        sortedKeys.sort()
+        for eachLod in sortedKeys:
+            index = sortedKeys.index(eachLod)
+            self.__LODNode.node().setSwitch(index, self.switches[eachLod][0],
+                                     self.switches[eachLod][1])
+                    
+    def addLOD(self, lodName, inDist=0, outDist=0):
+        """addLOD(self, string) 
+        Add a named node under the LODNode to parent all geometry
+        of a specific LOD under."""
+        self.__LODNode.attachNewNode(str(lodName))
+        # save the switch distance info
+        self.switches[lodName] = [inDist, outDist]
+        # add the switch distance info
+        self.__LODNode.node().addSwitch(inDist, outDist)
+
+    def setLOD(self, lodName, inDist=0, outDist=0):
+        """setLOD(self, string)
+        Set the switch distance for given LOD"""
+        # save the switch distance info
+        self.switches[lodName] = [inDist, outDist]
+        # add the switch distance info
+        sortedKeys = self.switches.keys()
+        sortedKeys.sort()
+        index = sortedKeys.index(lodName)
+        self.__LODNode.node().setSwitch(index, inDist, outDist)
+
+    def getLOD(self, lodName):
+        """getLOD(self, string)
+        Get the named node under the LOD to which we parent all LOD
+        specific geometry to. Returns 'None' if not found"""
+        lod = self.__LODNode.find("**/" + str(lodName))
+        if lod.isEmpty():
+            return None
+        else:
+            return lod
+        
+    def hasLOD(self):
+        """hasLOD(self)
+        Return 1 if the actor has LODs, 0 otherwise"""
+        return self.__hasLOD
+    
     def getFrameRate(self, animName=None, partName=None):
         """getFrameRate(self, string, string=None)
         Return duration of given anim name and given part.
         If no anim specified, use the currently playing anim.
-        If no part specified, return anim durations of first part"""
+        If no part specified, return anim durations of first part.
+        NOTE: returns info only for the first LOD"""
         if (partName == None):
-            partName = self.__animControlDict.keys()[0]
+            partName = self.__animControlDict[0].keys()[0]
     
         if (animName==None):
             animName = self.getCurrentAnim(partName)
 
         # get duration for named part only
-        if (self.__animControlDict.has_key(partName)):        
+        if (self.__animControlDict[0].has_key(partName)):        
             animControl = self.__getAnimControl(animName, partName)
             if (animControl != None):
                 return animControl.getFrameRate()
@@ -177,9 +337,10 @@ class Actor(PandaObject, NodePath):
         """getPlayRate(self, string=None, string=None)
         Return the play rate of given anim for a given part.
         If no part is given, assume first part in dictionary.
-        If no anim is given, find the current anim for the part"""
+        If no anim is given, find the current anim for the part.
+        NOTE: Returns info only for the first LOD"""
         if (partName==None):
-            partName = self.__animControlDict.keys()[0]
+            partName = self.__animControlDict[0].keys()[0]
 
         if (animName==None):
             animName = self.getCurrentAnim(partName)
@@ -194,35 +355,39 @@ class Actor(PandaObject, NodePath):
         """getPlayRate(self, float, string=None, string=None)
         Set the play rate of given anim for a given part.
         If no part is given, set for all parts in dictionary.
-        If no anim is given, find the current anim for the part"""
+        If no anim is given, find the current anim for the part.
+        NOTE: sets play rate on all LODs"""
         # make a list of partNames for loop below
-        if (partName==None):
-            partNames = self.__animControlDict.keys()
-        else:
-            partNames = []
-            partNames.append(partName)
+        for lodName in self.__animControlDict.keys():
+            animControlDict = self.__animControlDict[lodName]
+            if (partName==None):
+                partNames = animControlDict.keys()
+            else:
+                partNames = []
+                partNames.append(partName)
 
-        # for each part in list, set play rate on given or current anim
-        for partName in partNames:
-            if (animName==None):
-                animName = self.getCurrentAnim(partName)          
-            animControl = self.__getAnimControl(animName, partName)
-            if (animControl != None):
-                animControl.setPlayRate(rate)
+            # for each part in list, set play rate on given or current anim
+            for partName in partNames:
+                if (animName==None):
+                    animName = self.getCurrentAnim(partName)          
+                animControl = self.__getAnimControl(animName, partName)
+                if (animControl != None):
+                    animControl.setPlayRate(rate)
             
     def getDuration(self, animName=None, partName=None):
         """getDuration(self, string, string=None)
         Return duration of given anim name and given part.
         If no anim specified, use the currently playing anim.
-        If no part specified, return anim duration of first part"""
+        If no part specified, return anim duration of first part.
+        NOTE: returns info for first LOD only"""
         if (partName == None):
-            partName = self.__animControlDict.keys()[0]
+            partName = self.__animControlDict[0].keys()[0]
 
         if (animName==None):
             animName = self.getCurrentAnim(partName)          
 
         # get duration for named part only
-        if (self.__animControlDict.has_key(partName)):        
+        if (self.__animControlDict[0].has_key(partName)):        
             animControl = self.__getAnimControl(animName, partName)
             if (animControl != None):
                 return (animControl.getNumFrames() / \
@@ -235,12 +400,13 @@ class Actor(PandaObject, NodePath):
     def getCurrentAnim(self, partName=None):
         """getCurrentAnim(self, string=None)
         Return the anim current playing on the actor. If part not
-        specified return current anim of first part in dictionary"""
+        specified return current anim of first part in dictionary.
+        NOTE: only returns info for the first LOD"""
         if (partName==None):
-            partName = self.__animControlDict.keys()[0]
+            partName = self.__animControlDict[0].keys()[0]
 
         # loop through all anims for named part and find if any are playing
-        if (self.__animControlDict.has_key(partName)):
+        if (self.__animControlDict[0].has_key(partName)):
             for animName in self.__animControlDict[partName].keys():
                 if (self.__getAnimControl(animName, partName).isPlaying()):
                     return animName
@@ -251,102 +417,156 @@ class Actor(PandaObject, NodePath):
         return None
 
 
-
     # arranging
 
-    def getPart(self, partName):
-        """getPart(self, string)
-        Find the named part in the partBundleDict and return it, or
+    def getPart(self, partName, lodName="lodRoot"):
+        """getPart(self, string, key="lodRoot")
+        Find the named part in the optional named lod and return it, or
         return None if not present"""
-        if (self.__partBundleDict.has_key(partName)):
-            return self.__partBundleDict[partName]
+        if (self.__partBundleDict.has_key(lodName)):
+            partBundleDict = self.__partBundleDict[lodName]
+        else:
+            Actor.notify.warning("no lod named: %s" % (lodName))
+            return None
+                
+        if (partBundleDict.has_key(partName)):
+            return partBundleDict[partName]
         else:
             return None
 
-    def removePart(self, partName):
-        """removePart(Self, string)
-        Remove the geometry and animations of the named part if present
-        NOTE: this will remove parented geometry also!"""
-        # remove the geometry
-        if (self.__partBundleDict.has_key(partName)):
-            self.__partBundleDict[partName].removeNode()
-            del(self.__partBundleDict[partName])
-        # remove the animations
-        if (self.__animControlDict.has_key(partName)):
-            del(self.__animControlDict[partName])
+    def removePart(self, partName, lodName="lodRoot"):
+        """removePart(self, string, key="lodRoot")
+        Remove the geometry and animations of the named part of the
+        optional named lod if present.
+        NOTE: this will remove child geometry also!"""
+        # find the corresponding part bundle dict
+        if (self.__partBundleDict.has_key(lodName)):
+            partBundleDict = self.__partBundleDict[lodName]
+        else:
+            Actor.notify.warning("no lod named: %s" % (lodName))
+            return None
+
+        # find the corresponding anim control dict
+        if (self.__animControlDict.has_key(lodName)):
+            animControlDict = self.__animControlDict[lodName]
+        else:
+            Actor.notify.warning("no lod named: %s" % (lodName))
+            return None
 
+        # remove the part
+        if (partBundleDict.has_key(partName)):
+            partBundleDict[partName].removeNode()
+            del(partBundleDict[partName])
+
+        # remove the animations
+        if (animControlDict.has_key(partName)):
+            del(animControlDict[partName])
             
-    def hidePart(self, partName):
-        """hidePart(self, string)
-        Make the given part not render, even though still in the tree.
-        NOTE: this functionality will be effected by the 'attach' method"""
-        if (self.__partBundleDict.has_key(partName)):
-            self.__partBundleDict[partName].hide()
+    def hidePart(self, partName, lodName="lodName"):
+        """hidePart(self, string, key="lodName")
+        Make the given part of the optional given lod not render,
+        even though still in the tree.
+        NOTE: this will affect child geometry"""
+        if (self.__partBundleDict.has_key(lodName)):
+            partBundleDict = self.__partBundleDict[lodName]
+        else:
+            Actor.notify.warning("no lod named: %s" % (lodName))
+            return None
+
+        if (partBundleDict.has_key(partName)):
+            partBundleDict[partName].hide()
         else:
             Actor.notify.warning("no part named %s!" % (partName))
 
-    def showPart(self, partName):
-        """showPart(self, string)
+    def showPart(self, partName, lodName="lodRoot"):
+        """showPart(self, string, key="lodRoot")
         Make the given part render while in the tree.
-        NOTE: this functionality will be effected by the 'attach' method"""
-        if (self.__partBundleDict.has_key(partName)):
-            self.__partBundleDict[partName].show()
+        NOTE: this will affect child geometry"""
+        if (self.__partBundleDict.has_key(lodName)):
+            partBundleDict = self.__partBundleDict[lodName]
+        else:
+            Actor.notify.warning("no lod named: %s" % (lodName))
+            return None
+
+        if (partBundleDict.has_key(partName)):
+            partBundleDict[partName].show()
         else:
             Actor.notify.warning("no part named %s!" % (partName))
             
-    def instance(self, partName, anotherPart, jointName):
-        """instance(self, string, string, string)
+    def instance(self, partName, anotherPart, jointName, lodName="lodRoot"):
+        """instance(self, string, string, string, key="lodRoot")
         Instance one actor part to another at a joint called jointName"""
-        if (self.__partBundleDict.has_key(partName)):
-            if (self.__partBundleDict.has_key(anotherPart)):
-                joint = NodePath(self.__partBundleDict[anotherPart], \
-                                 "**/" + jointName)
-                if (joint.isEmpty()):
-                    Actor.notify.warning("%s not found!" % (jointName))
+        if (self.__partBundleDict.has_key(lodName)):
+            partBundleDict = self.__partBundleDict[lodName]
+            if (partBundleDict.has_key(partName)):
+                if (partBundleDict.has_key(anotherPart)):
+                    joint = NodePath(partBundleDict[anotherPart],
+                                     "**/" + jointName)
+                    if (joint.isEmpty()):
+                        Actor.notify.warning("%s not found!" % (jointName))
+                    else:
+                        return partBundleDict[partName].instanceTo(joint)
                 else:
-                    return self.__partBundleDict[partName].instanceTo(joint)
+                    Actor.notify.warning("no part named %s!" % (anotherPart))
             else:
-                Actor.notify.warning("no part named %s!" % (anotherPart))
+                Actor.notify.warning("no part named %s!" % (partName))
         else:
-            Actor.notify.warning("no part named %s!" % (partName))
+            Actor.notify.warning("no lod named %s!" % (lodName))
 
-
-    def attach(self, partName, anotherPart, jointName):
-        """attach(self, string, string, string)
+    def attach(self, partName, anotherPart, jointName, lodName="lodRoot"):
+        """attach(self, string, string, string, key="lodRoot")
         Attach one actor part to another at a joint called jointName"""
-        if (self.__partBundleDict.has_key(partName)):
-            if (self.__partBundleDict.has_key(anotherPart)):
-                joint = NodePath(self.__partBundleDict[anotherPart], \
+        if (self.__partBundleDict.has_key(lodName)):
+            partBundleDict = self.__partBundleDict[lodName]
+            if (partBundleDict.has_key(partName)):
+                if (partBundleDict.has_key(anotherPart)):
+                    joint = NodePath(partBundleDict[anotherPart],
                                  "**/" + jointName)
-                if (joint.isEmpty()):
-                    Actor.notify.warning("%s not found!" % (jointName))
+                    if (joint.isEmpty()):
+                        Actor.notify.warning("%s not found!" % (jointName))
+                    else:
+                        partBundleDict[partName].reparentTo(joint)
                 else:
-                    self.__partBundleDict[partName].reparentTo(joint)
+                    Actor.notify.warning("no part named %s!" % (anotherPart))
             else:
-                Actor.notify.warning("no part named %s!" % (anotherPart))
+                Actor.notify.warning("no part named %s!" % (partName))
         else:
-            Actor.notify.warning("no part named %s!" % (partName))
+            Actor.notify.warning("no lod named %s!" % (lodName))
 
                     
-    def drawInFront(self, frontPartName, backPartName, root=None):
-        """drawInFront(self, string, string=None)
+    def drawInFront(self, frontPartName, backPartName, root=None,
+                    lodName=None):
+        """drawInFront(self, string, string=None, key=None)
         Arrange geometry so the frontPart is drawn properly wrt backPart.
         Takes an optional argument root as the start of the search for the
-        given parts"""
+        given parts. Also takes optional lod name to refine search for the
+        named parts. If root and lod are defined, we search for the given
+        root under the given lod."""
+
+        # check to see if we are working within an lod
+        if (lodName != None):
+            # find the named lod node
+            lodRoot = self.find("**/" + str(lodName))
+            if (root == None):
+                # no need to look further
+                root = lodRoot
+            else:
+                # look for root under lod
+                root = lodRoot.find("**/" + root)
+        else:
+            # start search from self if no root and no lod given
+            if (root == None):
+                root = self
 
-        # start search from self if no root given
-        if (root==None):
-            root = self
-            
         # make the back part have the proper transition
-        backPart = NodePath(root, "**/"+backPartName)
+        backPart = NodePath(root, "**/" + backPartName)
         if (backPart.isEmpty()):
             Actor.notify.warning("no part named %s!" % (backPartName))
         else:
             (backPart.getBottomArc()).setTransition(DirectRenderTransition())
 
-        #reparent the front parts to the back parts
-        frontParts = self.findAllMatches( "**/"+frontPartName)
+        #reparent the front parts to the back part
+        frontParts = root.findAllMatches( "**/" + frontPartName)
         numFrontParts = frontParts.getNumPaths()
         for partNum in range(0, numFrontParts):
             (frontParts.getPath(partNum)).reparentTo(backPart)
@@ -406,140 +626,198 @@ class Actor(PandaObject, NodePath):
     def stop(self, animName=None, partName=None):
         """stop(self, string=None, string=None)
         Stop named animation on the given part of the actor.
-        If no name specified then stop all animations on the actor"""
-        if (animName == None):
-            #loop and stop ALL anims
-            for animControl in self.__animControlDict[partName].keys():
-                self.__animControlDict[partName][animControl].stop()
-        else:
-            #stop the specified anim
-            animControl = self.__getAnimControl(animName, partName)
-            if (animControl != None):
-                animControl.stop()
+        If no name specified then stop all animations on the actor.
+        NOTE: stops all LODs"""
+        for lodName in self.__animControlDict.keys():
+            animControlDict = self.__animControlDict[lodName]
+            if (animName == None):
+                # loop and stop all anims
+                if (partName == None):
+                    # loop over all parts
+                    for thisPart in animControlDict.keys():
+                        for thisAnim in animControlDict[thisPart].keys():
+                            animControlDict[thisPart][thisAnim].stop()
+                else:
+                    # stop just this part
+                    for thisAnim in animControlDict[partName].keys():
+                        animControlDict[partName][thisAnim].stop()
+            else:
+                # stop the specified anim
+                if (partName == None):
+                    # loop over all parts
+                    for thisPart in animControlDict.keys():
+                        animControlDict[thisPart][animName].stop()
+                else:
+                    animControlDict[partName][animName].stop()
+                    
         
     def play(self, animName, partName=None):
         """play(self, string, string=None)
         Play the given animation on the given part of the actor.
-        If no part is specified, try to play on all parts"""
-        if (partName == None):
-            # loop all parts
-            for partName in self.__animControlDict.keys():            
-                animControl = self.__getAnimControl(animName, partName)
+        If no part is specified, try to play on all parts. NOTE:
+        plays over ALL LODs"""
+        for lodName in self.__animControlDict.keys():
+            animControlDict = self.__animControlDict[lodName]
+            if (partName == None):
+                # loop all parts
+                for thisPart in animControlDict.keys():            
+                    animControl = self.__getAnimControl(animName, thisPart,
+                                                        lodName)
+                    if (animControl != None):
+                        animControl.play()
+
+            else:
+                animControl = self.__getAnimControl(animName, partName,
+                                                    lodName)
                 if (animControl != None):
                     animControl.play()
-        else:
-            animControl = self.__getAnimControl(animName, partName)
-            if (animControl != None):
-                animControl.play()
 
 
     def loop(self, animName, restart=1, partName=None):
         """loop(self, string, int=1, string=None)
         Loop the given animation on the given part of the actor,
         restarting at zero frame if requested. If no part name
-        is given then try to loop on all parts"""
-        if (partName == None):
-            # loop all parts
-            for partName in self.__animControlDict.keys():
-                animControl = self.__getAnimControl(animName, partName)
+        is given then try to loop on all parts. NOTE: loops on
+        all LOD's"""
+        for lodName in self.__animControlDict.keys():
+            animControlDict = self.__animControlDict[lodName]
+            if (partName == None):
+                # loop all parts
+                for thisPart in animControlDict.keys():
+                    animControl = self.__getAnimControl(animName, thisPart,
+                                                        lodName)
+                    if (animControl != None):
+                        animControl.loop(restart)
+            else:
+                # loop a specific part
+                animControl = self.__getAnimControl(animName, partName,
+                                                    lodName)
                 if (animControl != None):
                     animControl.loop(restart)
-        else:
-            # loop a specific part
-            animControl = self.__getAnimControl(animName, partName)
-            if (animControl != None):
-                animControl.loop(restart)
         
     def pose(self, animName, frame, partName=None):
         """pose(self, string, int, string=None)
         Pose the actor in position found at given frame in the specified
         animation for the specified part. If no part is specified attempt
-        to apply pose to all parts"""
-        if (partName==None):
-            # pose all parts
-            for partName in self.__animControlDict.keys():
-                animControl = self.__getAnimControl(animName, partName)
+        to apply pose to all parts. NOTE: poses all LODs"""
+        for lodName in self.__animControlDict.keys():
+            animControlDict = self.__animControlDict[lodName]
+            if (partName==None):
+                # pose all parts
+                for thisPart in animControlDict.keys():
+                    animControl = self.__getAnimControl(animName, thisPart,
+                                                        lodName)
+                    if (animControl != None):
+                        animControl.pose(frame)
+            else:
+                # pose a specific part
+                animControl = self.__getAnimControl(animName, partName,
+                                                    lodName)
                 if (animControl != None):
                     animControl.pose(frame)
-        else:
-            # pose a specific part
-            animControl = self.__getAnimControl(animName, partName)
-            if (animControl != None):
-                animControl.pose(frame)
         
-
     #private
     
-    def __getAnimControl(self, animName, partName):
-        """__getAnimControl(self, string, string)
-        Search the animControl dictionary for given anim and part.
-        Return the animControl if present, or None otherwise"""
-        if (self.__animControlDict.has_key(partName)):
-            if (self.__animControlDict[partName].has_key(animName)):
-                return self.__animControlDict[partName][animName]
+    def __getAnimControl(self, animName, partName, lodName="lodRoot"):
+        """__getAnimControl(self, string, string, string="lodRoot")
+        Search the animControl dictionary indicated by lodName for
+        a given anim and part. Return the animControl if present,
+        or None otherwise
+        """
+        if (self.__animControlDict.has_key(lodName)):
+            animControlDict = self.__animControlDict[lodName]
+            if (animControlDict.has_key(partName)):
+                if (animControlDict[partName].has_key(animName)):
+                    return animControlDict[partName][animName]
+                else:
+                    # anim was not present
+                    Actor.notify.warning("couldn't find anim: %s" % (animName))
             else:
-                # anim was not present
-                Actor.notify.warning("couldn't find anim: %s" % (animName))
+                # part was not present
+                Actor.notify.warning("couldn't find part: %s" % (partName))
         else:
-            # part was not present
-            Actor.notify.warning("couldn't find part: %s" % (partName))
-                
+            # lod was not present
+            Actor.notify.warning("couldn't find lod: %s" % (lodName))
+            
         return None
 
             
-    def loadModel(self, modelPath, partName="modelRoot"):
-        """loadModel(self, string, string="modelRoot")
-        Actor model loader. Takes a model name (ie file path) and
-        a partName (defaults to "modelRoot")"""
-        
-        Actor.notify.info("in loadModel: %s , part: %s" % \
-            (modelPath, partName))
+    def loadModel(self, modelPath, partName="modelRoot", lodName="lodRoot"):
+        """loadModel(self, string, string="modelRoot", string="base")
+        Actor model loader. Takes a model name (ie file path), a part
+        name(defaults to "modelRoot") and an lod name(defaults to "lodRoot").
+        """
+        Actor.notify.warning("in loadModel: %s , part: %s, lod: %s" % \
+            (modelPath, partName, lodName))
 
         # load the model and extract its part bundle
         model = loader.loadModelCopy(modelPath)
-
-
         bundle = NodePath(model, "**/+PartBundleNode")
         if (bundle.isEmpty()):
             Actor.notify.warning("%s is not a character!" % (modelPath))
         else:
             # we rename this node to make Actor copying easier
             bundle.node().setName(Actor.partPrefix + partName)
-            bundle.reparentTo(self.__geomNode)
+
+            if (self.__partBundleDict.has_key(lodName) == 0):
+                # make a dictionary to store these parts in
+                needsDict = 1
+                bundleDict = {}
+            else:
+                needsDict = 0
+                
+            if (lodName!="lodRoot"):
+                # reparent to appropriate node under LOD switch
+                bundle.reparentTo(self.__LODNode.find("**/" + str(lodName)))
+            else:
+                bundle.reparentTo(self.__geomNode)
+
+            if (needsDict):
+                bundleDict[partName] = bundle
+                self.__partBundleDict[lodName] = bundleDict
+            else:
+                self.__partBundleDict[lodName][partName] = bundle
+
             model.removeNode()        
 
-        #make this mimic mutli-part by giving it a default part anme
-        self.__partBundleDict[partName] = bundle
-        
 
-    def loadAnims(self, anims, partName="modelRoot"):
-        """loadAnims(self, string:string{}, string="modelRoot")
+    def loadAnims(self, anims, partName="modelRoot", lodName="lodRoot"):
+        """loadAnims(self, string:string{}, string='modelRoot',
+        string='lodRoot')
         Actor anim loader. Takes an optional partName (defaults to
-        'modelRoot' for non-multipart actors) and dict of corresponding
+        'modelRoot' for non-multipart actors) and lodName (defaults
+        to 'lodRoot' for non-LOD actors) and dict of corresponding
         anims in the form animName:animPath{}"""
         
-        Actor.notify.info("in loadAnims: %s, part: %s" % (anims, partName))
+        Actor.notify.warning("in loadAnims: %s, part: %s, lod: %s" %
+                          (anims, partName, lodName))
 
         animDict = {}
 
         for animName in anims.keys():
             
-            #load the anim and get its anim bundle
-            anim = loader.loadModelCopy(anims[animName])
+            # load the anim and get its anim bundle
+            anim = loader.loadModelOnce(anims[animName])
             animBundle = \
                 (NodePath(anim, "**/+AnimBundleNode").node()).getBundle()
 
-            #bind anim
-            bundleNode = (self.__partBundleDict[partName]).node()
+            # bind anim
+            bundleNode = (
+                self.__partBundleDict[lodName][partName]).node()
+                
             animControl = (bundleNode.getBundle()).bindAnim(animBundle, -1)
             if (animControl == None):
                 Actor.notify.error("Null AnimControl: %s" % (animName))
             else:
                 animDict[animName] = animControl
             
-        # add this part's dictionary to animation dictionary
-        self.__animControlDict[partName] = animDict
-    
+            # add this part's dictionary to animation dictionary
+            if not (self.__animControlDict.has_key(lodName)):
+                lodDict = {}
+                self.__animControlDict[lodName] = lodDict
+                
+            self.__animControlDict[lodName][partName] = animDict
+                
 
     def __copyPartBundles(self, other):
         """__copyPartBundles(self, Actor)