"""

notify = DirectNotifyGlobal.directNotify.newCategory("Actor")

partPrefix = "__Actor_"

modelLoaderOptions = LoaderOptions(LoaderOptions.LFSearch |

LoaderOptions.LFReportErrors |

LoaderOptions.LFConvertSkeleton)

animLoaderOptions = LoaderOptions(LoaderOptions.LFSearch |

LoaderOptions.LFReportErrors |

LoaderOptions.LFConvertAnim)

validateSubparts = ConfigVariableBool('validate-subparts', True)

class PartDef:

"""Instances of this class are stored within the

def __init__(self, partBundleNP, partBundleHandle, partModel):

# We also save the ModelRoot node along with the

# PartBundle, so that the reference count in the ModelPool

# will be accurate.

self.partBundleNP = partBundleNP

self.partBundleHandle = partBundleHandle

self.partModel = partModel

def getBundle(self):

return self.partBundleHandle.getBundle()

def __repr__(self):

return 'Actor.PartDef(%s, %s)' % (repr(self.partBundleNP), repr(self.partModel))

class AnimDef:

"""Instances of this class are stored within the

def __init__(self, filename = None, animBundle = None):

self.filename = filename

self.animBundle = None

self.animControl = None

def makeCopy(self):

return Actor.AnimDef(self.filename, self.animBundle)

def __repr__(self):

return 'Actor.AnimDef(%s)' % (repr(self.filename))

class SubpartDef:

"""Instances of this class are stored within the SubpartDict

def __init__(self, truePartName, subset = PartSubset()):

self.truePartName = truePartName

self.subset = subset

def makeCopy(self):

return Actor.SubpartDef(self.truePartName, PartSubset(self.subset))

def __repr__(self):

return 'Actor.SubpartDef(%s, %s)' % (repr(self.truePartName), repr(self.subset))

def __init__(self, models=None, anims=None, other=None, copy=True,

lodNode = None, flattenable = True, setFinal = False,

mergeLODBundles = None, allowAsyncBind = None,

okMissing = None):

"""__init__(self, string | string:string{}, string:string{} |

try:

self.Actor_initialized

return

except:

self.Actor_initialized = 1

# initialize our NodePath essence

NodePath.__init__(self)

# Set the mergeLODBundles flag. If this is true, all

# different LOD's will be merged into a single common bundle

# (joint hierarchy). All LOD's will thereafter share the same

# skeleton, even though they may have been loaded from

# different egg files. If this is false, LOD's will be kept

# completely isolated, and each LOD will have its own

# skeleton.

# When this flag is true, __animControlDict has only one key,

# ['common']; when it is false, __animControlDict has one key

# per each LOD name.

if mergeLODBundles == None:

# If this isn't specified, it comes from the Config.prc

# file.

self.mergeLODBundles = base.config.GetBool('merge-lod-bundles', True)

else:

self.mergeLODBundles = mergeLODBundles

# Set the allowAsyncBind flag. If this is true, it enables

# asynchronous animation binding. This requires that you have

# run "egg-optchar -preload" on your animation and models to

# generate the appropriate AnimPreloadTable.

if allowAsyncBind == None:

self.allowAsyncBind = base.config.GetBool('allow-async-bind', True)

else:

self.allowAsyncBind = allowAsyncBind

# create data structures

self.__commonBundleHandles = {}

self.__partBundleDict = {}

self.__subpartDict = {}

self.__sortedLODNames = []

self.__animControlDict = {}

self.__subpartsComplete = False

self.__LODNode = None

self.__LODAnimation = None

self.__LODCenter = Point3(0, 0, 0)

self.switches = None

if (other == None):

# act like a normal constructor

# create base hierarchy

self.gotName = 0

if flattenable:

# If we want a flattenable Actor, don't create all

# those ModelNodes, and the GeomNode is the same as

# the root.

root = PandaNode('actor')

self.assign(NodePath(root))

self.setGeomNode(NodePath(self))

else:

# A standard Actor has a ModelNode at the root, and

# another ModelNode to protect the GeomNode.

root = ModelNode('actor')

root.setPreserveTransform(1)

self.assign(NodePath(root))

self.setGeomNode(self.attachNewNode(ModelNode('actorGeom')))

self.__hasLOD = 0

# 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(node = lodNode)

# 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, copy = copy,

okMissing = okMissing)

# 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,

copy = copy, okMissing = okMissing)

else:

# it is a single part actor w/LOD

self.setLODNode(node = lodNode)

# 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,

copy = copy, okMissing = okMissing)

else:

# else it is a single part actor

self.loadModel(models, copy = copy, okMissing = okMissing)

# 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:

self.copyActor(other, True) # overwrite everything

if setFinal:

# If setFinal is true, the Actor will set its top bounding

# volume to be the "final" bounding volume: the bounding

# volumes below the top volume will not be tested. If a

# cull test passes the top bounding volume, the whole

# Actor is rendered.

# We do this partly because an Actor is likely to be a

# fairly small object relative to the scene, and is pretty

# much going to be all onscreen or all offscreen anyway;

# and partly because of the Character bug that doesn't

# update the bounding volume for pieces that animate away

# from their original position. It's disturbing to see

# someone's hands disappear; better to cull the whole

# object or none of it.

self.__geomNode.node().setFinal(1)

def delete(self):

try:

self.Actor_deleted

return

except:

self.Actor_deleted = 1

self.cleanup()

def copyActor(self, other, overwrite=False):

# act like a copy constructor

self.gotName = other.gotName

# copy the scene graph elements of other

if (overwrite):

otherCopy = other.copyTo(NodePath())

otherCopy.detachNode()

# assign these elements to ourselve (overwrite)

self.assign(otherCopy)

else:

# just copy these to ourselves

otherCopy = other.copyTo(self)

# masad: check if otherCopy has a geomNode as its first child

# if actor is initialized with flattenable, then otherCopy, not

# its first child, is the geom node; check __init__, for reference

if other.getGeomNode().getName() == other.getName():

self.setGeomNode(otherCopy)

else:

self.setGeomNode(otherCopy.getChild(0))

# copy the switches for lods

self.switches = other.switches

self.__LODNode = self.find('**/+LODNode')

self.__hasLOD = 0

if (not self.__LODNode.isEmpty()):

self.__hasLOD = 1

# copy the part dictionary from other

self.__copyPartBundles(other)

self.__copySubpartDict(other)

self.__subpartsComplete = other.__subpartsComplete

# copy the anim dictionary from other

self.__copyAnimControls(other)

def __cmp__(self, other):

# Actor inherits from NodePath, which inherits a definition of

# __cmp__ from FFIExternalObject that uses the NodePath's

# compareTo() method to compare different NodePaths. But we

# don't want this behavior for Actors; Actors should only be

# compared pointerwise. A NodePath that happens to reference

# the same node is still different from the Actor.

if self is other:

return 0

else:

return 1

def __str__(self):

"""

return "Actor %s, parts = %s, LODs = %s, anims = %s" % \

(self.getName(), self.getPartNames(), self.getLODNames(), self.getAnimNames())

def listJoints(self, partName="modelRoot", lodName="lodRoot"):

"""Handy utility function to list the joint hierarchy of the

if self.mergeLODBundles:

partBundleDict = self.__commonBundleHandles

else:

partBundleDict = self.__partBundleDict.get(lodName)

if not partBundleDict:

Actor.notify.error("no lod named: %s" % (lodName))

subpartDef = self.__subpartDict.get(partName, Actor.SubpartDef(partName))

partDef = partBundleDict.get(subpartDef.truePartName)

if partDef == None:

Actor.notify.error("no part named: %s" % (partName))

self.__doListJoints(0, partDef.getBundle(),

subpartDef.subset.isIncludeEmpty(), subpartDef.subset)

def __doListJoints(self, indentLevel, part, isIncluded, subset):

name = part.getName()

if subset.matchesInclude(name):

isIncluded = True

elif subset.matchesExclude(name):

isIncluded = False

if isIncluded:

value = ''

if hasattr(part, 'outputValue'):

lineStream = LineStream()

part.outputValue(lineStream)

value = lineStream.getLine()

print ' ' * indentLevel, part.getName(), value

for i in range(part.getNumChildren()):

self.__doListJoints(indentLevel + 2, part.getChild(i),

isIncluded, subset)

def getActorInfo(self):

"""

lodInfo = []

for lodName, partDict in self.__animControlDict.items():

if self.mergeLODBundles:

lodName = self.__sortedLODNames[0]

partInfo = []

for partName in partDict.keys():

subpartDef = self.__subpartDict.get(partName, Actor.SubpartDef(partName))

partBundleDict = self.__partBundleDict.get(lodName)

partDef = partBundleDict.get(subpartDef.truePartName)

partBundle = partDef.getBundle()

animDict = partDict[partName]

animInfo = []

for animName in animDict.keys():

file = animDict[animName].filename

animControl = animDict[animName].animControl

animInfo.append([animName, file, animControl])

partInfo.append([partName, partBundle, animInfo])

lodInfo.append([lodName, partInfo])

return lodInfo

def getAnimNames(self):

animNames = []

for lodName, lodInfo in self.getActorInfo():

for partName, bundle, animInfo in lodInfo:

for animName, file, animControl in animInfo:

if animName not in animNames:

animNames.append(animName)

return animNames

def pprint(self):

"""

for lodName, lodInfo in self.getActorInfo():

print 'LOD:', lodName

for partName, bundle, animInfo in lodInfo:

print ' Part:', partName

print ' Bundle:', repr(bundle)

for animName, file, animControl in animInfo:

print ' Anim:', animName

print ' File:', file

if animControl == None:

print ' (not loaded)'

else:

print (' NumFrames: %d PlayRate: %0.2f' %

(animControl.getNumFrames(),

animControl.getPlayRate()))

def cleanup(self):

"""

self.stop(None)

self.clearPythonData()

self.flush()

if(self.__geomNode):

self.__geomNode.removeNode()

self.__geomNode = None

if not self.isEmpty():

self.removeNode()

def removeNode(self):

if self.__geomNode and (self.__geomNode.getNumChildren() > 0):

assert self.notify.warning("called actor.removeNode() on %s without calling cleanup()" % self.getName())

NodePath.removeNode(self)

def clearPythonData(self):

self.__commonBundleHandles = {}

self.__partBundleDict = {}

self.__subpartDict = {}

self.__sortedLODNames = []

self.__animControlDict = {}

def flush(self):

"""

self.clearPythonData()

if self.__LODNode and (not self.__LODNode.isEmpty()):

self.__LODNode.removeNode()

self.__LODNode = None

# remove all its children

if(self.__geomNode):

self.__geomNode.removeChildren()

self.__hasLOD = 0

# accessing

def getAnimControlDict(self):

return self.__animControlDict

def removeAnimControlDict(self):

self.__animControlDict = {}

def getPartBundleDict(self):

return self.__partBundleDict

def getPartBundles(self, partName = None):

""" Returns a list of PartBundle objects for the entire Actor,

bundles = []

for lodName, partBundleDict in self.__partBundleDict.items():

if partName == None:

for partDef in partBundleDict.values():

bundles.append(partDef.getBundle())

else:

subpartDef = self.__subpartDict.get(partName, Actor.SubpartDef(partName))

partDef = partBundleDict.get(subpartDef.truePartName)

if partDef != None:

bundles.append(partDef.getBundle())

else:

Actor.notify.warning("Couldn't find part: %s" % (partName))

return bundles

def __updateSortedLODNames(self):

# Cache the sorted LOD names so we don't have to grab them

# and sort them every time somebody asks for the list

self.__sortedLODNames = self.__partBundleDict.keys()

# Reverse sort the doing a string->int

def sortKey(x):

if not str(x).isdigit():

smap = {'h':3,

'm':2,

'l':1,

'f':0}

"""

return smap[x[0]]

else:

return int(x)

self.__sortedLODNames.sort(key=sortKey, reverse=True)

def getLODNames(self):

"""

return self.__sortedLODNames

def getPartNames(self):

"""

partNames = []

if self.__partBundleDict:

partNames = self.__partBundleDict.values()[0].keys()

return partNames + self.__subpartDict.keys()

def getGeomNode(self):

"""

return self.__geomNode

def setGeomNode(self, node):

"""

self.__geomNode = node

def getLODNode(self):

"""

return self.__LODNode.node()

def setLODNode(self, node=None):

"""

if (node == None):

node = LODNode.makeDefaultLod("lod")

if self.__LODNode:

self.__LODNode = node

else:

self.__LODNode = self.__geomNode.attachNewNode(node)

self.__hasLOD = 1

self.switches = {}

def useLOD(self, lodName):

"""

# make sure we don't call this twice in a row

# and pollute the the switches dictionary

child = self.__LODNode.find(str(lodName))

index = self.__LODNode.node().findChild(child.node())

self.__LODNode.node().forceSwitch(index)

def printLOD(self):

sortedKeys = self.__sortedLODNames

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

"""

self.__LODNode.node().clearForceSwitch()

def addLOD(self, lodName, inDist=0, outDist=0, center=None):

"""addLOD(self, string)

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)

if center != None:

self.setCenter(center)

def setLOD(self, lodName, inDist=0, outDist=0):

"""setLOD(self, string)

# save the switch distance info

self.switches[lodName] = [inDist, outDist]

# add the switch distance info

self.__LODNode.node().setSwitch(self.getLODIndex(lodName), inDist, outDist)

def getLODIndex(self, lodName):

"""getLODIndex(self)

return list(self.__LODNode.getChildren()).index(self.getLOD(lodName))

def getLOD(self, lodName):

"""getLOD(self, string)

if self.__LODNode:

lod = self.__LODNode.find(str(lodName))

if lod.isEmpty():

return None

else:

return lod

else:

return None

def hasLOD(self):

"""

return self.__hasLOD

def setCenter(self, center):

if center == None:

center = Point3(0, 0, 0)

self.__LODCenter = center

if self.__LODNode:

self.__LODNode.node().setCenter(self.__LODCenter)

if self.__LODAnimation:

self.setLODAnimation(*self.__LODAnimation)

def setLODAnimation(self, farDistance, nearDistance, delayFactor):

""" Activates a special mode in which the Actor animates less

self.__LODAnimation = (farDistance, nearDistance, delayFactor)

for lodData in self.__partBundleDict.values():

for partData in lodData.values():

char = partData.partBundleNP

char.node().setLodAnimation(self.__LODCenter, farDistance, nearDistance, delayFactor)

def clearLODAnimation(self):

""" Description: Undoes the effect of a recent call to

self.__LODAnimation = None

for lodData in self.__partBundleDict.values():

for partData in lodData.values():

char = partData.partBundleNP

char.node().clearLodAnimation()

def update(self, lod=0, partName=None, lodName=None, force=False):

""" Updates all of the Actor's joints in the indicated LOD.

if lodName == None:

lodNames = self.getLODNames()

else:

lodNames = [lodName]

anyChanged = False

if lod < len(lodNames):

lodName = lodNames[lod]

if partName == None:

partBundleDict = self.__partBundleDict[lodName]

partNames = partBundleDict.keys()

else:

partNames = [partName]

for partName in partNames:

partBundle = self.getPartBundle(partName, lodNames[lod])

if force:

if partBundle.forceUpdate():

anyChanged = True

else:

if partBundle.update():

anyChanged = True

else:

self.notify.warning('update() - no lod: %d' % lod)

return anyChanged

def getFrameRate(self, animName=None, partName=None):

"""getFrameRate(self, string, string=None)

lodName = self.__animControlDict.keys()[0]

controls = self.getAnimControls(animName, partName)

if len(controls) == 0:

return None

return controls[0].getFrameRate()

def getBaseFrameRate(self, animName=None, partName=None):

"""getBaseFrameRate(self, string, string=None)

lodName = self.__animControlDict.keys()[0]

controls = self.getAnimControls(animName, partName)

if len(controls) == 0:

return None

return controls[0].getAnim().getBaseFrameRate()

def getPlayRate(self, animName=None, partName=None):

"""

if self.__animControlDict:

# use the first lod

lodName = self.__animControlDict.keys()[0]

controls = self.getAnimControls(animName, partName)

if controls:

return controls[0].getPlayRate()

return None

def setPlayRate(self, rate, animName, partName=None):

"""setPlayRate(self, float, string, string=None)

for control in self.getAnimControls(animName, partName):

control.setPlayRate(rate)

def getDuration(self, animName=None, partName=None,

fromFrame=None, toFrame=None):

"""

lodName = self.__animControlDict.keys()[0]

controls = self.getAnimControls(animName, partName)

if len(controls) == 0:

return None

animControl = controls[0]

if fromFrame is None:

fromFrame = 0

if toFrame is None:

toFrame = animControl.getNumFrames()-1

return ((toFrame+1)-fromFrame) / animControl.getFrameRate()

def getNumFrames(self, animName=None, partName=None):

lodName = self.__animControlDict.keys()[0]

controls = self.getAnimControls(animName, partName)

if len(controls) == 0:

return None

return controls[0].getNumFrames()

def getFrameTime(self, anim, frame, partName=None):

numFrames = self.getNumFrames(anim,partName)

animTime = self.getDuration(anim,partName)

frameTime = animTime * float(frame) / numFrames

return frameTime

def getCurrentAnim(self, partName=None):

"""

if len(self.__animControlDict.items()) == 0:

return

lodName, animControlDict = self.__animControlDict.items()[0]

if partName == None:

partName, animDict = animControlDict.items()[0]

else:

animDict = animControlDict.get(partName)

if animDict == None:

# part was not present

Actor.notify.warning("couldn't find part: %s" % (partName))

return None

# loop through all anims for named part and find if any are playing

for animName, anim in animDict.items():

if anim.animControl and anim.animControl.isPlaying():

return animName

# we must have found none, or gotten an error

return None

def getCurrentFrame(self, animName=None, partName=None):

"""

lodName, animControlDict = self.__animControlDict.items()[0]

if partName == None:

partName, animDict = animControlDict.items()[0]

else:

animDict = animControlDict.get(partName)

if animDict == None:

# part was not present

Actor.notify.warning("couldn't find part: %s" % (partName))

return None

if animName:

anim = animDict.get(animName)

if not anim:

Actor.notify.warning("couldn't find anim: %s" % (animName))

elif anim.animControl:

return anim.animControl.getFrame()

else:

# loop through all anims for named part and find if any are playing

for animName, anim in animDict.items():

if anim.animControl and anim.animControl.isPlaying():

return anim.animControl.getFrame()

# we must have found none, or gotten an error

return None

# arranging

def getPart(self, partName, lodName="lodRoot"):

"""

partBundleDict = self.__partBundleDict.get(lodName)

if not partBundleDict:

Actor.notify.warning("no lod named: %s" % (lodName))

return None

subpartDef = self.__subpartDict.get(partName, Actor.SubpartDef(partName))

partDef = partBundleDict.get(subpartDef.truePartName)

if partDef != None:

return partDef.partBundleNP

return None

def getPartBundle(self, partName, lodName="lodRoot"):

"""

partBundleDict = self.__partBundleDict.get(lodName)

if not partBundleDict:

Actor.notify.warning("no lod named: %s" % (lodName))

return None

subpartDef = self.__subpartDict.get(partName, Actor.SubpartDef(partName))

partDef = partBundleDict.get(subpartDef.truePartName)

if partDef != None:

return partDef.getBundle()

return None

def removePart(self, partName, lodName="lodRoot"):

"""

# find the corresponding part bundle dict

partBundleDict = self.__partBundleDict.get(lodName)