Panda3D
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Properties
Classes | Public Member Functions | Public Attributes | Static Public Attributes | List of all members
Actor Class Reference
Inheritance diagram for Actor:
DirectObject DistributedActor

Classes

class  AnimDef
 
class  PartDef
 
class  SubpartDef
 

Public Member Functions

def __init__
 
def __cmp__
 
def __str__
 
def cleanup
 
def clearPythonData
 
def copyActor
 
def delete
 
def flush
 
def getActorInfo
 
def getAnimControlDict
 
def getAnimNames
 
def getGeomNode
 
def getLODNames
 
def getLODNode
 
def getPartBundleDict
 
def getPartBundles
 
def getPartNames
 
def listJoints
 
def pprint
 
def removeAnimControlDict
 
def removeNode
 
def setGeomNode
 
def setLODNode
 
def useLOD
 
- Public Member Functions inherited from DirectObject
def __init__
 
def accept
 
def acceptOnce
 
def addTask
 
def detectLeaks
 
def doMethodLater
 
def getAllAccepting
 
def ignore
 
def ignoreAll
 
def isAccepting
 
def isIgnoring
 
def removeAllTasks
 
def removeTask
 

Public Attributes

 Actor_deleted
 
 Actor_initialized
 
 allowAsyncBind
 
 gotName
 
 mergeLODBundles
 
 switches
 

Static Public Attributes

tuple allowAsyncBind = ConfigVariableBool('allow-async-bind', True)
 
tuple animLoaderOptions
 
tuple mergeLODBundles = ConfigVariableBool('merge-lod-bundles', True)
 
tuple modelLoaderOptions
 
tuple notify = DirectNotifyGlobal.directNotify.newCategory("Actor")
 
string partPrefix = "__Actor_"
 
tuple validateSubparts = ConfigVariableBool('validate-subparts', True)
 

Detailed Description

Actor class: Contains methods for creating, manipulating
and playing animations on characters

Constructor & Destructor Documentation

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{} |
string:(string:string{}){}, Actor=None)
Actor constructor: can be used to create single or multipart
actors. If another Actor is supplied as an argument this
method acts like a copy constructor. Single part actors are
created by calling with a model and animation dictionary
(animName:animPath{}) as follows:

   a = Actor("panda-3k.egg", {"walk":"panda-walk.egg" \
                      "run":"panda-run.egg"})

This could be displayed and animated as such:

   a.reparentTo(render)
   a.loop("walk")
   a.stop()

Multipart actors expect a dictionary of parts and a dictionary
of animation dictionaries (partName:(animName:animPath{}){}) as
below:

    a = Actor(

# part dictionary
{"head":"char/dogMM/dogMM_Shorts-head-mod", \
 "torso":"char/dogMM/dogMM_Shorts-torso-mod", \
 "legs":"char/dogMM/dogMM_Shorts-legs-mod"}, \

# dictionary of anim dictionaries
{"head":{"walk":"char/dogMM/dogMM_Shorts-head-walk", \
         "run":"char/dogMM/dogMM_Shorts-head-run"}, \
 "torso":{"walk":"char/dogMM/dogMM_Shorts-torso-walk", \
          "run":"char/dogMM/dogMM_Shorts-torso-run"}, \
 "legs":{"walk":"char/dogMM/dogMM_Shorts-legs-walk", \
         "run":"char/dogMM/dogMM_Shorts-legs-run"} \
 })

In addition multipart actor parts need to be connected together
in a meaningful fashion:

    a.attach("head", "torso", "joint-head")
    a.attach("torso", "legs", "joint-hips")

#
# ADD LOD COMMENT HERE!
#

Other useful Actor class functions:

    #fix actor eye rendering
    a.drawInFront("joint-pupil?", "eyes*")

    #fix bounding volumes - this must be done after drawing
    #the actor for a few frames, otherwise it has no effect
    a.fixBounds()

Member Function Documentation

def __cmp__ (   self,
  other 
)
def __str__ (   self)
Actor print function
def cleanup (   self)
Actor cleanup function
def clearPythonData (   self)
def copyActor (   self,
  other,
  overwrite = False 
)
def delete (   self)
def flush (   self)
Actor flush function
def getActorInfo (   self)
Utility function to create a list of information about an actor.
Useful for iterating over details of an actor.
def getAnimControlDict (   self)
def getAnimNames (   self)
def getGeomNode (   self)
Return the node that contains all actor geometry
def getLODNames (   self)
Return list of Actor LOD names. If not an LOD actor,
returns 'lodRoot'
Caution - this returns a reference to the list - not your own copy
def getLODNode (   self)
Return the node that switches actor geometry in and out
def getPartBundleDict (   self)
def getPartBundles (   self,
  partName = None 
)
Returns a list of PartBundle objects for the entire Actor,
or for the indicated part only. 
def getPartNames (   self)
Return list of Actor part names. If not an multipart actor,
returns 'modelRoot' NOTE: returns parts of arbitrary LOD
def listJoints (   self,
  partName = "modelRoot",
  lodName = "lodRoot" 
)
Handy utility function to list the joint hierarchy of the
actor. 
def pprint (   self)
Pretty print actor's details
def removeAnimControlDict (   self)
def removeNode (   self)
def setGeomNode (   self,
  node 
)
Set the node that contains all actor geometry
def setLODNode (   self,
  node = None 
)
Set the node that switches actor geometry in and out.
If one is not supplied as an argument, make one
def useLOD (   self,
  lodName 
)
Make the Actor ONLY display the given LOD

Member Data Documentation

Actor_deleted
Actor_initialized
tuple allowAsyncBind = ConfigVariableBool('allow-async-bind', True)
static
allowAsyncBind
tuple animLoaderOptions
static
Initial value:
1 = LoaderOptions(LoaderOptions.LFSearch |
2  LoaderOptions.LFReportErrors |
3  LoaderOptions.LFConvertAnim)
gotName
tuple mergeLODBundles = ConfigVariableBool('merge-lod-bundles', True)
static
mergeLODBundles
tuple modelLoaderOptions
static
Initial value:
1 = LoaderOptions(LoaderOptions.LFSearch |
2  LoaderOptions.LFReportErrors |
3  LoaderOptions.LFConvertSkeleton)
tuple notify = DirectNotifyGlobal.directNotify.newCategory("Actor")
static
string partPrefix = "__Actor_"
static
switches
tuple validateSubparts = ConfigVariableBool('validate-subparts', True)
static