|
def | __init__ (self) |
|
def | __repr__ (self) |
|
def | add (self, funcOrTask, name=None, sort=None, extraArgs=None, priority=None, uponDeath=None, appendTask=False, taskChain=None, owner=None) |
|
def | destroy (self) |
|
def | doMethodLater (self, delayTime, funcOrTask, name, extraArgs=None, sort=None, priority=None, taskChain=None, uponDeath=None, appendTask=False, owner=None) |
|
def | doYield (self, frameStartTime, nextScheduledTaskTime) |
|
def | finalInit (self) |
|
def | flushTaskProfiles (self, name=None) |
|
def | getAllTasks (self) |
|
def | getCurrentTask (self) |
|
def | getDoLaters (self) |
|
def | getProfileFrames (self) |
|
def | getProfileFramesSV (self) |
|
def | getProfileSession (self, name=None) |
|
def | getProfileTasks (self) |
|
def | getProfileTasksSV (self) |
|
def | getTasks (self) |
|
def | getTasksMatching (self, taskPattern) |
|
def | getTasksNamed (self, taskName) |
|
def | hasTaskChain (self, chainName) |
|
def | hasTaskNamed (self, taskName) |
|
def | invokeDefaultHandler (self, signalNumber, stackFrame) |
|
def | keyboardInterruptHandler (self, signalNumber, stackFrame) |
|
def | logTaskProfiles (self, name=None) |
|
def | popupControls (self) |
|
def | profileFrames (self, num=None, session=None, callback=None) |
|
def | remove (self, taskOrName) |
|
def | removeTasksMatching (self, taskPattern) |
|
def | replaceMethod (self, oldMethod, newFunction) |
|
def | run (self) |
|
def | setClock (self, clockObject) |
|
def | setProfileFrames (self, profileFrames) |
|
def | setProfileTasks (self, profileTasks) |
|
def | setupTaskChain (self, chainName, numThreads=None, tickClock=None, threadPriority=None, frameBudget=None, frameSync=None, timeslicePriority=None) |
|
def | step (self) |
|
def | stop (self) |
|
def add |
( |
|
self, |
|
|
|
funcOrTask, |
|
|
|
name = None , |
|
|
|
sort = None , |
|
|
|
extraArgs = None , |
|
|
|
priority = None , |
|
|
|
uponDeath = None , |
|
|
|
appendTask = False , |
|
|
|
taskChain = None , |
|
|
|
owner = None |
|
) |
| |
Add a new task to the taskMgr. The task will begin executing
immediately, or next frame if its sort value has already
passed this frame.
The parameters are:
funcOrTask - either an existing Task object (not already added
to the task manager), or a callable function object. If this
is a function, a new Task object will be created and returned.
name - the name to assign to the Task. Required, unless you
are passing in a Task object that already has a name.
extraArgs - the list of arguments to pass to the task
function. If this is omitted, the list is just the task
object itself.
appendTask - a boolean flag. If this is true, then the task
object itself will be appended to the end of the extraArgs
list before calling the function.
sort - the sort value to assign the task. The default sort is
0. Within a particular task chain, it is guaranteed that the
tasks with a lower sort value will all run before tasks with a
higher sort value run.
priority - the priority at which to run the task. The default
priority is 0. Higher priority tasks are run sooner, and/or
more often. For historical purposes, if you specify a
priority without also specifying a sort, the priority value is
understood to actually be a sort value. (Previously, there
was no priority value, only a sort value, and it was called
"priority".)
uponDeath - a function to call when the task terminates,
either because it has run to completion, or because it has
been explicitly removed.
taskChain - the name of the task chain to assign the task to.
owner - an optional Python object that is declared as the
"owner" of this task for maintenance purposes. The owner must
have two methods: owner._addTask(self, task), which is called
when the task begins, and owner._clearTask(self, task), which
is called when the task terminates. This is all the owner
means.
The return value of add() is the new Task object that has been
added, or the original Task object that was passed in.
def doMethodLater |
( |
|
self, |
|
|
|
delayTime, |
|
|
|
funcOrTask, |
|
|
|
name, |
|
|
|
extraArgs = None , |
|
|
|
sort = None , |
|
|
|
priority = None , |
|
|
|
taskChain = None , |
|
|
|
uponDeath = None , |
|
|
|
appendTask = False , |
|
|
|
owner = None |
|
) |
| |
Adds a task to be performed at some time in the future.
This is identical to add(), except that the specified
delayTime is applied to the Task object first, which means
that the task will not begin executing until at least the
indicated delayTime (in seconds) has elapsed.
After delayTime has elapsed, the task will become active, and
will run in the soonest possible frame thereafter. If you
wish to specify a task that will run in the next frame, use a
delayTime of 0.
def setupTaskChain |
( |
|
self, |
|
|
|
chainName, |
|
|
|
numThreads = None , |
|
|
|
tickClock = None , |
|
|
|
threadPriority = None , |
|
|
|
frameBudget = None , |
|
|
|
frameSync = None , |
|
|
|
timeslicePriority = None |
|
) |
| |
Defines a new task chain. Each task chain executes tasks
potentially in parallel with all of the other task chains (if
numThreads is more than zero). When a new task is created, it
may be associated with any of the task chains, by name (or you
can move a task to another task chain with
task.setTaskChain()). You can have any number of task chains,
but each must have a unique name.
numThreads is the number of threads to allocate for this task
chain. If it is 1 or more, then the tasks on this task chain
will execute in parallel with the tasks on other task chains.
If it is greater than 1, then the tasks on this task chain may
execute in parallel with themselves (within tasks of the same
sort value).
If tickClock is True, then this task chain will be responsible
for ticking the global clock each frame (and thereby
incrementing the frame counter). There should be just one
task chain responsible for ticking the clock, and usually it
is the default, unnamed task chain.
threadPriority specifies the priority level to assign to
threads on this task chain. It may be one of TPLow, TPNormal,
TPHigh, or TPUrgent. This is passed to the underlying
threading system to control the way the threads are scheduled.
frameBudget is the maximum amount of time (in seconds) to
allow this task chain to run per frame. Set it to -1 to mean
no limit (the default). It's not directly related to
threadPriority.
frameSync is true to force the task chain to sync to the
clock. When this flag is false, the default, the task chain
will finish all of its tasks and then immediately start from
the first task again, regardless of the clock frame. When it
is true, the task chain will finish all of its tasks and then
wait for the clock to tick to the next frame before resuming
the first task. This only makes sense for threaded tasks
chains; non-threaded task chains are automatically
synchronous.
timeslicePriority is False in the default mode, in which each
task runs exactly once each frame, round-robin style,
regardless of the task's priority value; or True to change the
meaning of priority so that certain tasks are run less often,
in proportion to their time used and to their priority value.
See AsyncTaskManager.setTimeslicePriority() for more.