Panda3D Manual: TasksTasks are special functions that are called once each frame while your application executes. They are similar in concept to threads. However, in Panda3D, tasks are not generally separate threads; instead, all tasks are run cooperatively, one at a time, within the main thread. This design simplifies game programming considerably by removing the requirement to protect critical sections of code from mutual access. (See Task Chains in the next section if you really want to use threading.) When you start Panda3D by initializing ShowBase, a handful of tasks are created by default, but you are free to add as many additional tasks as you like.
The Task FunctionA task is defined with a function or class method; this function is the main entry point for the task and will be called once per frame while the task is running. By default, the function receives one parameter, which is the task object; the task object carries information about the task itself, such as the amount of time that the task has been running. Your task function should return when it has finished processing for the frame. Because all tasks are run in the same thread, you must not spend too much time processing any one task function; the entire application will be locked up until the function returns. The task function may return either You can check how long your task has been running by checking The below example imports the Task module and shows a function used as a task. from direct.task import Task Task Return ValuesThe value returned from a task affects how the task manager handles that task going forward.
The Do-Later TaskA useful special kind of task is the do-later: this is similar to a task, but rather than being called every frame it will be called only once, after a certain amount of time (in seconds) has elapsed. You can, of course, implement a do-later task with a regular task that simply does nothing until a certain amount of time has elapsed (as in the above example), but using a do-later is a much more efficient way to achieve the same thing, especially if you will have many such tasks waiting around. taskMgr.doMethodLater(delayTime, myFunction, 'Task Name') In this example myFunction must accept a task variable. If you wish to use a function that does not accept a task variable: taskMgr.doMethodLater(delayTime, myFunction, 'Task Name', extraArgs = [variables]) Note: if you wish to call a function which takes no variables simply pass Do-Later task's can be repeated from the task function by returning # This task increments itself so that the delay between task executions If you wish to change the delayTime outside of the task function itself, and have it make an immediate effect, you can remove and re-add the task by hand, for instance: taskMgr.remove(task) Although there is a public member The Task ObjectThe
To remove the task and stop it from executing, call The Task ManagerAll tasks are handled through the global Task Manager object, called taskMgr.add(exampleTask, 'MyTaskName') You can add extra arguments to the call through the extraArgs parameter. When you add extraArgs, the task parameter is no longer sent to your function by default. If you still want it, make sure to set appendTask to true. taskMgr.add(exampleTask, 'MyTaskName', extraArgs=[a,b,c], appendTask=True)
Although normally each task is given a unique name, you may also create multiple different tasks with the same name. This can be convenient for removing many task functions at the same time. Each task remains independent of the others, even if they have the same name; this means that a task function returning taskMgr.add(taskFunc, 'Existing TaskName')
To remove the task and stop it from executing, call taskMgr.remove('MyTaskName')
You may add a cleanup function to the task function with the uponDeath parameter. Similar to task functions, the uponDeath function has a task object as a parameter. The cleanup function is called whenever the task finishes, for instance by taskMgr.add(exampleTask, 'TaskName', uponDeath=cleanupFunc)
To control order in which tasks are executed, you can use sort or priority argument. If you use only sort or only priority, tasks given lesser value will execute sooner.
taskMgr.add(task2, "second",sort=2) or taskMgr.add(task2, "second",priority=2) In both cases, task1 given name "first" will be executed before task2 ("second"). If you use both sort and priority arguments, tasks with lower sort value will be executed first. However, if there are several tasks which have same sort value, but different priority value then that tasks are going to be executed in a way that ones with HIGHER priority value will be executed first. To clarify it a bit, here is code sample, tasks are named in order in which they are executed. taskMgr.add(task1, "first", sort=1, priority=2)
To print the list of tasks currently running, simply print out
There also is graphical interface for managing tasks. This is very useful for having a look at the tasks while your application is running. taskMgr.popupControls()
Task timingTo see the specific timing information for each task when you print taskMgr, add the following line to your Config.prc file
(see The Configuration File for config syntax) ExamplesuponDeath taskAccumulator = 0
© Carnegie Mellon University 2010 |