mirror of
https://github.com/panda3d/panda3d.git
synced 2025-10-04 10:54:24 -04:00
750 lines
27 KiB
Python
750 lines
27 KiB
Python
from libpandaexpressModules import *
|
|
from DirectNotifyGlobal import *
|
|
from PythonUtil import *
|
|
from MessengerGlobal import *
|
|
import time
|
|
import fnmatch
|
|
import string
|
|
import signal
|
|
|
|
|
|
# MRM: Need to make internal task variables like time, name, index
|
|
# more unique (less likely to have name clashes)
|
|
|
|
exit = -1
|
|
done = 0
|
|
cont = 1
|
|
|
|
def print_exc_plus():
|
|
"""
|
|
Print the usual traceback information, followed by a listing of all the
|
|
local variables in each frame.
|
|
"""
|
|
import sys
|
|
import traceback
|
|
|
|
tb = sys.exc_info()[2]
|
|
while 1:
|
|
if not tb.tb_next:
|
|
break
|
|
tb = tb.tb_next
|
|
stack = []
|
|
f = tb.tb_frame
|
|
while f:
|
|
stack.append(f)
|
|
f = f.f_back
|
|
stack.reverse()
|
|
traceback.print_exc()
|
|
print "Locals by frame, innermost last"
|
|
for frame in stack:
|
|
print
|
|
print "Frame %s in %s at line %s" % (frame.f_code.co_name,
|
|
frame.f_code.co_filename,
|
|
frame.f_lineno)
|
|
for key, value in frame.f_locals.items():
|
|
print "\t%20s = " % key,
|
|
#We have to be careful not to cause a new error in our error
|
|
#printer! Calling str() on an unknown object could cause an
|
|
#error we don't want.
|
|
try:
|
|
print value
|
|
except:
|
|
print "<ERROR WHILE PRINTING VALUE>"
|
|
|
|
|
|
# Store the global clock
|
|
globalClock = ClockObject.getGlobalClock()
|
|
|
|
|
|
class Task:
|
|
count = 0
|
|
def __init__(self, callback, priority = 0):
|
|
# Unique ID for each task
|
|
self.id = Task.count
|
|
Task.count += 1
|
|
self.__call__ = callback
|
|
self.__priority = priority
|
|
self.uponDeath = None
|
|
self.dt = 0.0
|
|
self.maxDt = 0.0
|
|
self.avgDt = 0.0
|
|
self.runningTotal = 0.0
|
|
self.pstats = None
|
|
self.__removed = 0
|
|
|
|
def remove(self):
|
|
self.__removed = 1
|
|
|
|
def isRemoved(self):
|
|
return self.__removed
|
|
|
|
def getPriority(self):
|
|
return self.__priority
|
|
|
|
def setPriority(self, pri):
|
|
self.__priority = pri
|
|
|
|
def setStartTimeFrame(self, startTime, startFrame):
|
|
self.starttime = startTime
|
|
self.startframe = startFrame
|
|
|
|
def setCurrentTimeFrame(self, currentTime, currentFrame):
|
|
# Calculate and store this task's time (relative to when it started)
|
|
self.time = currentTime - self.starttime
|
|
self.frame = currentFrame - self.startframe
|
|
|
|
def setupPStats(self, name):
|
|
if __debug__:
|
|
import PStatCollector
|
|
self.pstats = PStatCollector.PStatCollector("App:Show code:" + name)
|
|
|
|
def finishTask(self, verbose):
|
|
if self.uponDeath:
|
|
self.uponDeath(self)
|
|
if verbose:
|
|
# We regret to announce...
|
|
messenger.send('TaskManager-removeTask', sentArgs = [self, self.name])
|
|
|
|
def __repr__(self):
|
|
if hasattr(self, 'name'):
|
|
return ('Task id: %s, name %s' % (self.id, self.name))
|
|
else:
|
|
return ('Task id: %s, no name' % (self.id))
|
|
|
|
def pause(delayTime):
|
|
def func(self):
|
|
if (self.time < self.delayTime):
|
|
return cont
|
|
else:
|
|
# Time is up, return done
|
|
# TaskManager.notify.debug('pause done: ' + self.name)
|
|
return done
|
|
task = Task(func)
|
|
task.name = 'pause'
|
|
task.delayTime = delayTime
|
|
return task
|
|
|
|
def sequence(*taskList):
|
|
return make_sequence(taskList)
|
|
|
|
|
|
def make_sequence(taskList):
|
|
def func(self):
|
|
frameFinished = 0
|
|
taskDoneStatus = -1
|
|
while (not frameFinished):
|
|
task = self.taskList[self.index]
|
|
# If this is a new task, set its start time and frame
|
|
if (self.index > self.prevIndex):
|
|
task.setStartTimeFrame(self.time, self.frame)
|
|
self.prevIndex = self.index
|
|
# Calculate this task's time since it started
|
|
task.setCurrentTimeFrame(self.time, self.frame)
|
|
# Execute the current task
|
|
ret = task(task)
|
|
# Check the return value from the task
|
|
# If this current task wants to continue,
|
|
# come back to it next frame
|
|
if (ret == cont):
|
|
taskDoneStatus = cont
|
|
frameFinished = 1
|
|
# If this task is done, increment the index so that next frame
|
|
# we will start executing the next task on the list
|
|
elif (ret == done):
|
|
self.index = self.index + 1
|
|
taskDoneStatus = cont
|
|
frameFinished = 0
|
|
# If this task wants to exit, the sequence exits
|
|
elif (ret == exit):
|
|
taskDoneStatus = exit
|
|
frameFinished = 1
|
|
|
|
# If we got to the end of the list, this sequence is done
|
|
if (self.index >= len(self.taskList)):
|
|
TaskManager.notify.debug('sequence done: ' + self.name)
|
|
frameFinished = 1
|
|
taskDoneStatus = done
|
|
|
|
return taskDoneStatus
|
|
|
|
task = Task(func)
|
|
task.name = 'sequence'
|
|
task.taskList = taskList
|
|
task.prevIndex = -1
|
|
task.index = 0
|
|
return task
|
|
|
|
def resetSequence(task):
|
|
# Should this automatically be done as part of spawnTaskNamed?
|
|
# Or should one have to create a new task instance every time
|
|
# one wishes to spawn a task (currently sequences and can
|
|
# only be fired off once
|
|
task.index = 0
|
|
task.prevIndex = -1
|
|
|
|
def loop(*taskList):
|
|
return make_loop(taskList)
|
|
|
|
def make_loop(taskList):
|
|
def func(self):
|
|
frameFinished = 0
|
|
taskDoneStatus = -1
|
|
while (not frameFinished):
|
|
task = self.taskList[self.index]
|
|
# If this is a new task, set its start time and frame
|
|
if (self.index > self.prevIndex):
|
|
task.setStartTimeFrame(self.time, self.frame)
|
|
self.prevIndex = self.index
|
|
# Calculate this task's time since it started
|
|
task.setCurrentTimeFrame(self.time, self.frame)
|
|
# Execute the current task
|
|
ret = task(task)
|
|
# Check the return value from the task
|
|
# If this current task wants to continue,
|
|
# come back to it next frame
|
|
if (ret == cont):
|
|
taskDoneStatus = cont
|
|
frameFinished = 1
|
|
# If this task is done, increment the index so that next frame
|
|
# we will start executing the next task on the list
|
|
# TODO: we should go to the next frame now
|
|
elif (ret == done):
|
|
self.index = self.index + 1
|
|
taskDoneStatus = cont
|
|
frameFinished = 0
|
|
# If this task wants to exit, the sequence exits
|
|
elif (ret == exit):
|
|
taskDoneStatus = exit
|
|
frameFinished = 1
|
|
# If we got to the end of the list, wrap back around
|
|
if (self.index >= len(self.taskList)):
|
|
self.prevIndex = -1
|
|
self.index = 0
|
|
frameFinished = 1
|
|
return taskDoneStatus
|
|
task = Task(func)
|
|
task.name = 'loop'
|
|
task.taskList = taskList
|
|
task.prevIndex = -1
|
|
task.index = 0
|
|
return task
|
|
|
|
|
|
class TaskPriorityList(list):
|
|
def __init__(self, priority):
|
|
self.__priority = priority
|
|
self.__emptyIndex = 0
|
|
def getPriority(self):
|
|
return self.__priority
|
|
def getEmptyIndex(self):
|
|
return self.__emptyIndex
|
|
def setEmptyIndex(self, index):
|
|
self.__emptyIndex = index
|
|
def add(self, task):
|
|
if (self.__emptyIndex >= len(self)):
|
|
self.append(task)
|
|
self.__emptyIndex += 1
|
|
else:
|
|
self[self.__emptyIndex] = task
|
|
self.__emptyIndex += 1
|
|
def remove(self, i):
|
|
assert(i <= len(self))
|
|
if (len(self) == 1) and (i == 1):
|
|
self[i] = None
|
|
self.__emptyIndex = 0
|
|
else:
|
|
# Swap the last element for this one
|
|
lastElement = self[self.__emptyIndex-1]
|
|
self[i] = lastElement
|
|
self[self.__emptyIndex-1] = None
|
|
self.__emptyIndex -= 1
|
|
|
|
|
|
class TaskManager:
|
|
|
|
notify = None
|
|
|
|
def __init__(self):
|
|
self.running = 0
|
|
self.stepping = 0
|
|
self.taskList = []
|
|
self.newTasks = []
|
|
self.doLaterList = []
|
|
self.currentTime, self.currentFrame = self.__getTimeFrame()
|
|
if (TaskManager.notify == None):
|
|
TaskManager.notify = directNotify.newCategory("TaskManager")
|
|
self.taskTimerVerbose = 0
|
|
self.extendedExceptions = 0
|
|
self.fKeyboardInterrupt = 0
|
|
self.interruptCount = 0
|
|
self.pStatsTasks = 0
|
|
self.resumeFunc = None
|
|
self.fVerbose = 0
|
|
self.nameDict = {}
|
|
self.add(self.__doLaterProcessor, "doLaterProcessor")
|
|
# Dictionary of task name to list of tasks with that name
|
|
|
|
def stepping(self, value):
|
|
self.stepping = value
|
|
|
|
def setVerbose(self, value):
|
|
self.fVerbose = value
|
|
messenger.send('TaskManager-setVerbose', sentArgs = [value])
|
|
|
|
def keyboardInterruptHandler(self, signalNumber, stackFrame):
|
|
self.fKeyboardInterrupt = 1
|
|
self.interruptCount += 1
|
|
if self.interruptCount == 2:
|
|
# The user must really want to interrupt this process
|
|
# Next time around use the default interrupt handler
|
|
signal.signal(signal.SIGINT, signal.default_int_handler)
|
|
|
|
def hasTaskNamed(self, taskName):
|
|
# Get the tasks with this name
|
|
tasks = self.nameDict.get(taskName)
|
|
# If we found some, see if any of them are still active (not removed)
|
|
if tasks:
|
|
for task in tasks:
|
|
if not task.isRemoved():
|
|
return 1
|
|
# Didnt find any, return 0
|
|
return 0
|
|
|
|
def getTasksNamed(self, taskName):
|
|
# Get the tasks with this name
|
|
tasks = self.nameDict.get(taskName, [])
|
|
# Filter out the tasks that have been removed
|
|
if tasks:
|
|
tasks = filter(lambda task: not task.isRemoved(), tasks)
|
|
return tasks
|
|
|
|
def __doLaterProcessor(self, task):
|
|
# Make a temp list of all the dolaters that expired this time
|
|
# through so we can remove them after we are done with the
|
|
# for loop. Removing them during the for loop is a bad idea
|
|
removedTasks = []
|
|
for dl in self.doLaterList:
|
|
if dl.isRemoved():
|
|
removedTasks.append(dl)
|
|
continue
|
|
# If the time now is less than the start of the doLater + delay
|
|
# then we are not ready yet, continue to next one
|
|
if task.time < dl.starttime + dl.delayTime:
|
|
# Since the list is sorted, the first one we get to, that
|
|
# is not ready to go, we can return
|
|
break
|
|
else:
|
|
removedTasks.append(dl)
|
|
dl.setStartTimeFrame(self.currentTime, self.currentFrame)
|
|
self.newTasks.append(dl)
|
|
continue
|
|
if removedTasks:
|
|
self.doLaterList = unique(self.doLaterList, removedTasks)
|
|
return cont
|
|
|
|
def __spawnDoLater(self, task):
|
|
if TaskManager.notify.getDebug():
|
|
TaskManager.notify.debug('spawning doLater named: ' + task.name)
|
|
# Add this task to the nameDict
|
|
nameList = ifAbsentPut(self.nameDict, task.name, [])
|
|
nameList.append(task)
|
|
task.setStartTimeFrame(self.currentTime, self.currentFrame)
|
|
# search from the beginning of the list to put this doLater in
|
|
# the list in order of execution from earliest to latest
|
|
# Assume it goes last unless we break out early
|
|
index = len(self.doLaterList) + 1
|
|
for i in range(len(self.doLaterList)):
|
|
dl = self.doLaterList[i]
|
|
remainingTime = ((dl.starttime + dl.delayTime) - self.currentTime)
|
|
if task.delayTime < remainingTime:
|
|
index = i
|
|
break
|
|
self.doLaterList.insert(index, task)
|
|
if self.fVerbose:
|
|
# Alert the world, a new task is born!
|
|
messenger.send('TaskManager-spawnDoLater',
|
|
sentArgs = [task, task.name, index])
|
|
return task
|
|
|
|
def doLater(self, delayTime, task, taskName):
|
|
task.delayTime = delayTime
|
|
task.name = taskName
|
|
return self.__spawnDoLater(task)
|
|
|
|
def doMethodLater(self, delayTime, func, taskName):
|
|
task = Task(func)
|
|
return self.doLater(delayTime, task, taskName)
|
|
|
|
def add(self, funcOrTask, name, priority = 0):
|
|
"""
|
|
Add a new task to the taskMgr.
|
|
You can add a Task object or a method that takes one argument.
|
|
"""
|
|
if isinstance(funcOrTask, Task):
|
|
funcOrTask.setPriority(priority)
|
|
return self.__spawnTaskNamed(funcOrTask, name)
|
|
elif callable(funcOrTask):
|
|
return self.__spawnMethodNamed(funcOrTask, name, priority)
|
|
else:
|
|
self.notify.error('Tried to add a task that was not a Task or a func')
|
|
|
|
def __spawnMethodNamed(self, func, name, priority=0):
|
|
task = Task(func, priority)
|
|
return self.__spawnTaskNamed(task, name)
|
|
|
|
def __spawnTaskNamed(self, task, name):
|
|
if TaskManager.notify.getDebug():
|
|
TaskManager.notify.debug('spawning task named: ' + name)
|
|
# Init params
|
|
task.name = name
|
|
task.setStartTimeFrame(self.currentTime, self.currentFrame)
|
|
nameList = ifAbsentPut(self.nameDict, name, [])
|
|
nameList.append(task)
|
|
# Put it on the list for the end of this frame
|
|
self.newTasks.append(task)
|
|
|
|
def __addNewTask(self, task):
|
|
# The taskList is really an ordered list of TaskPriorityLists
|
|
# search back from the end of the list until we find a
|
|
# taskList with a lower priority, or we hit the start of the list
|
|
taskPriority = task.getPriority()
|
|
index = len(self.taskList) - 1
|
|
while (1):
|
|
if (index < 0):
|
|
newList = TaskPriorityList(taskPriority)
|
|
newList.add(task)
|
|
# Add the new list to the beginning of the taskList
|
|
self.taskList.insert(0, newList)
|
|
break
|
|
taskListPriority = self.taskList[index].getPriority()
|
|
if (taskListPriority == taskPriority):
|
|
self.taskList[index].add(task)
|
|
break
|
|
elif (taskListPriority > taskPriority):
|
|
index = index - 1
|
|
elif (taskListPriority < taskPriority):
|
|
# Time to insert
|
|
newList = TaskPriorityList(taskPriority)
|
|
newList.add(task)
|
|
# Insert this new priority level
|
|
# If we are already at the end, just append it
|
|
if (index == len(self.taskList)-1):
|
|
self.taskList.append(newList)
|
|
else:
|
|
# Otherwise insert it
|
|
self.taskList.insert(index+1, newList)
|
|
break
|
|
|
|
if __debug__:
|
|
if self.pStatsTasks and task.name != "igloop":
|
|
# Get the PStats name for the task. By convention,
|
|
# this is everything until the first hyphen; the part
|
|
# of the task name following the hyphen is generally
|
|
# used to differentiate particular tasks that do the
|
|
# same thing to different objects.
|
|
name = task.name
|
|
hyphen = name.find('-')
|
|
if hyphen >= 0:
|
|
name = name[0:hyphen]
|
|
task.setupPStats(name)
|
|
|
|
if self.fVerbose:
|
|
# Alert the world, a new task is born!
|
|
messenger.send('TaskManager-spawnTask',
|
|
sentArgs = [task, task.name, index])
|
|
|
|
return task
|
|
|
|
def remove(self, taskOrName):
|
|
if type(taskOrName) == type(''):
|
|
return self.__removeTasksNamed(taskOrName)
|
|
elif isinstance(taskOrName, Task):
|
|
return self.__removeTasksEqual(taskOrName)
|
|
else:
|
|
self.notify.error('remove takes a string or a Task')
|
|
|
|
def removeTasksMatching(self, taskPattern):
|
|
"""removeTasksMatching(self, string taskPattern)
|
|
|
|
Removes tasks whose names match the pattern, which can include
|
|
standard shell globbing characters like *, ?, and [].
|
|
|
|
"""
|
|
if TaskManager.notify.getDebug():
|
|
TaskManager.notify.debug('removing tasks matching: ' + taskPattern)
|
|
num = 0
|
|
keyList = filter(lambda key: fnmatch.fnmatchcase(key, taskPattern), self.nameDict.keys())
|
|
for key in keyList:
|
|
num += self.__removeTasksNamed(key)
|
|
return num
|
|
|
|
def __removeTasksEqual(self, task):
|
|
if TaskManager.notify.getDebug():
|
|
TaskManager.notify.debug('__removeTasksEqual: removing task: %s' % (task))
|
|
taskName = task.name
|
|
# Remove this task from the nameDict (should be a short list)
|
|
self.__removeTaskFromNameDict(task)
|
|
# Flag the task for removal from the real list
|
|
task.remove()
|
|
# Cleanup stuff
|
|
task.finishTask(self.fVerbose)
|
|
return 1
|
|
|
|
def __removeTasksNamed(self, taskName):
|
|
if TaskManager.notify.getDebug():
|
|
TaskManager.notify.debug('__removeTasksNamed: removing tasks named: %s' % (taskName))
|
|
if not self.nameDict.has_key(taskName):
|
|
return 0
|
|
for task in self.nameDict[taskName]:
|
|
# Flag for removal
|
|
task.remove()
|
|
# Cleanup stuff
|
|
task.finishTask(self.fVerbose)
|
|
# Record the number of tasks removed
|
|
num = len(self.nameDict[taskName])
|
|
# Blow away the nameDict entry completely
|
|
del self.nameDict[taskName]
|
|
return num
|
|
|
|
def __removeTaskFromNameDict(self, task):
|
|
taskName = task.name
|
|
# If this is the only task with that name, remove the dict entry
|
|
tasksWithName = self.nameDict.get(taskName)
|
|
if tasksWithName:
|
|
tasksWithName.remove(task)
|
|
if len(tasksWithName) == 0:
|
|
del self.nameDict[taskName]
|
|
|
|
def __executeTask(self, task, currentTime, currentFrame):
|
|
task.setCurrentTimeFrame(currentTime, currentFrame)
|
|
if not self.taskTimerVerbose:
|
|
# don't record timing info
|
|
ret = task(task)
|
|
else:
|
|
# Run the task and check the return value
|
|
if task.pstats:
|
|
task.pstats.start()
|
|
startTime = time.clock()
|
|
ret = task(task)
|
|
endTime = time.clock()
|
|
if task.pstats:
|
|
task.pstats.stop()
|
|
|
|
# Record the dt
|
|
dt = endTime - startTime
|
|
task.dt = dt
|
|
|
|
# See if this is the new max
|
|
if dt > task.maxDt:
|
|
task.maxDt = dt
|
|
|
|
# Record the running total of all dts so we can compute an average
|
|
task.runningTotal = task.runningTotal + dt
|
|
if (task.frame > 0):
|
|
task.avgDt = (task.runningTotal / task.frame)
|
|
else:
|
|
task.avgDt = 0
|
|
return ret
|
|
|
|
def step(self):
|
|
if TaskManager.notify.getDebug():
|
|
TaskManager.notify.debug('step')
|
|
self.currentTime, self.currentFrame = self.__getTimeFrame()
|
|
# Replace keyboard interrupt handler during task list processing
|
|
# so we catch the keyboard interrupt but don't handle it until
|
|
# after task list processing is complete.
|
|
self.fKeyboardInterrupt = 0
|
|
self.interruptCount = 0
|
|
signal.signal(signal.SIGINT, self.keyboardInterruptHandler)
|
|
|
|
# Traverse the task list in order because it is in priority order
|
|
for taskPriList in self.taskList:
|
|
# Traverse the taskPriList with an iterator
|
|
i = 0
|
|
while (i < len(taskPriList)):
|
|
task = taskPriList[i]
|
|
# See if we are at the end of the real tasks
|
|
if task is None:
|
|
TaskManager.notify.debug('step: end of priList %s' % (taskPriList.getPriority()))
|
|
break
|
|
# See if this task has been removed in show code
|
|
if task.isRemoved():
|
|
TaskManager.notify.debug('step: task is flagged for removal %s' % (task))
|
|
task.finishTask(self.fVerbose)
|
|
taskPriList.remove(i)
|
|
# Do not increment the iterator
|
|
continue
|
|
# Now actually execute the task
|
|
ret = self.__executeTask(task, self.currentTime, self.currentFrame)
|
|
# See if the task is done
|
|
if (ret == cont):
|
|
# Leave it for next frame, its not done yet
|
|
pass
|
|
elif ((ret == done) or (ret == exit)):
|
|
TaskManager.notify.debug('step: task is finished %s' % (task))
|
|
# Remove the task
|
|
if not task.isRemoved():
|
|
task.remove()
|
|
task.finishTask(self.fVerbose)
|
|
self.__removeTaskFromNameDict(task)
|
|
taskPriList.remove(i)
|
|
# Do not increment the iterator
|
|
continue
|
|
else:
|
|
raise StandardError, "Task named %s did not return cont, exit, or done" % task.name
|
|
# Move to the next element
|
|
i += 1
|
|
|
|
# Add all the new tasks now
|
|
for task in self.newTasks:
|
|
TaskManager.notify.debug('step: adding new task to list %s' % (task))
|
|
self.__addNewTask(task)
|
|
# Reset for next frame
|
|
self.newTasks = []
|
|
|
|
# Restore default interrupt handler
|
|
signal.signal(signal.SIGINT, signal.default_int_handler)
|
|
if self.fKeyboardInterrupt:
|
|
raise KeyboardInterrupt
|
|
return
|
|
|
|
def run(self):
|
|
# Set the clock to have last frame's time in case we were
|
|
# Paused at the prompt for a long time
|
|
t = globalClock.getFrameTime()
|
|
timeDelta = t - globalClock.getRealTime()
|
|
globalClock.setRealTime(t)
|
|
|
|
messenger.send("resetClock", [timeDelta])
|
|
|
|
if self.resumeFunc != None:
|
|
self.resumeFunc()
|
|
|
|
if self.stepping:
|
|
self.step()
|
|
else:
|
|
self.running = 1
|
|
while self.running:
|
|
try:
|
|
self.step()
|
|
except KeyboardInterrupt:
|
|
self.stop()
|
|
except:
|
|
if self.extendedExceptions:
|
|
self.stop()
|
|
print_exc_plus()
|
|
else:
|
|
raise
|
|
|
|
def stop(self):
|
|
# Set a flag so we will stop before beginning next frame
|
|
self.running = 0
|
|
|
|
def replaceMethod(self, oldMethod, newFunction):
|
|
import new
|
|
for taskPriList in self.taskList:
|
|
for task in taskPriList:
|
|
if task is None:
|
|
break
|
|
method = task.__call__
|
|
if (type(method) == types.MethodType):
|
|
function = method.im_func
|
|
else:
|
|
function = method
|
|
#print ('function: ' + `function` + '\n' +
|
|
# 'method: ' + `method` + '\n' +
|
|
# 'oldMethod: ' + `oldMethod` + '\n' +
|
|
# 'newFunction: ' + `newFunction` + '\n')
|
|
if (function == oldMethod):
|
|
newMethod = new.instancemethod(newFunction,
|
|
method.im_self,
|
|
method.im_class)
|
|
task.__call__ = newMethod
|
|
# Found it return true
|
|
return 1
|
|
return 0
|
|
|
|
def __repr__(self):
|
|
import fpformat
|
|
taskNameWidth = 32
|
|
dtWidth = 10
|
|
priorityWidth = 10
|
|
totalDt = 0
|
|
totalAvgDt = 0
|
|
str = ('taskList'.ljust(taskNameWidth)
|
|
+ 'dt(ms)'.rjust(dtWidth)
|
|
+ 'avg'.rjust(dtWidth)
|
|
+ 'max'.rjust(dtWidth)
|
|
+ 'priority'.rjust(priorityWidth)
|
|
+ '\n')
|
|
str = str + '---------------------------------------------------------------\n'
|
|
for taskPriList in self.taskList:
|
|
priority = `taskPriList.getPriority()`
|
|
for task in taskPriList:
|
|
if task is None:
|
|
break
|
|
totalDt = totalDt + task.dt
|
|
totalAvgDt = totalAvgDt + task.avgDt
|
|
if task.isRemoved():
|
|
taskName = '(R)' + task.name
|
|
else:
|
|
taskName = task.name
|
|
if (self.taskTimerVerbose):
|
|
str = str + (taskName.ljust(taskNameWidth)
|
|
+ fpformat.fix(task.dt*1000, 2).rjust(dtWidth)
|
|
+ fpformat.fix(task.avgDt*1000, 2).rjust(dtWidth)
|
|
+ fpformat.fix(task.maxDt*1000, 2).rjust(dtWidth)
|
|
+ priority.rjust(priorityWidth)
|
|
+ '\n')
|
|
else:
|
|
str = str + (task.name.ljust(taskNameWidth)
|
|
+ '----'.rjust(dtWidth)
|
|
+ '----'.rjust(dtWidth)
|
|
+ '----'.rjust(dtWidth)
|
|
+ priority.rjust(priorityWidth)
|
|
+ '\n')
|
|
str = str + '---------------------------------------------------------------\n'
|
|
str = str + ' doLaterList\n'
|
|
str = str + '---------------------------------------------------------------\n'
|
|
for task in self.doLaterList:
|
|
remainingTime = ((task.starttime + task.delayTime) - self.currentTime)
|
|
if task.isRemoved():
|
|
taskName = '(R)' + task.name
|
|
else:
|
|
taskName = task.name
|
|
str = str + (' ' + taskName.ljust(taskNameWidth-2)
|
|
+ fpformat.fix(remainingTime, 2).rjust(dtWidth)
|
|
+ '\n')
|
|
str = str + '---------------------------------------------------------------\n'
|
|
if (self.taskTimerVerbose):
|
|
str = str + ('total'.ljust(taskNameWidth)
|
|
+ fpformat.fix(totalDt*1000, 2).rjust(dtWidth)
|
|
+ fpformat.fix(totalAvgDt*1000, 2).rjust(dtWidth)
|
|
+ '\n')
|
|
else:
|
|
str = str + ('total'.ljust(taskNameWidth)
|
|
+ '----'.rjust(dtWidth)
|
|
+ '----'.rjust(dtWidth)
|
|
+ '\n')
|
|
return str
|
|
|
|
def resetStats(self):
|
|
# WARNING: this screws up your do-later timings
|
|
for task in self.taskList:
|
|
task.dt = 0
|
|
task.avgDt = 0
|
|
task.maxDt = 0
|
|
task.runningTotal = 0
|
|
task.setStartTimeFrame(self.currentTime, self.currentFrame)
|
|
|
|
def popupControls(self):
|
|
import TaskManagerPanel
|
|
return TaskManagerPanel.TaskManagerPanel(self)
|
|
|
|
def __getTimeFrame(self):
|
|
# WARNING: If you are testing tasks without an igloop,
|
|
# you must manually tick the clock
|
|
# Ask for the time last frame
|
|
return globalClock.getFrameTime(), globalClock.getFrameCount()
|
|
|